All phase1 and phase2 tests now take optional alias nperf_protocols that can be used to limit which netperf tests to run.
For example, if set to 'tcp udp', only TCP_STREAM and UDP_STREAM are run, SCTP_STREAM will be skipped. The default value is all protocol tests, i.e. TCP, UDP and SCTP.
This patch also removes the 'enable_udp_perf' alias from virtual bridge tests since the new alias can be used in similar manner.
Signed-off-by: Jan Tluka jtluka@redhat.com --- recipes/regression_tests/phase1/3_vlans.py | 109 +++++---- recipes/regression_tests/phase1/3_vlans.xml | 1 + .../phase1/3_vlans_over_active_backup_bond.xml | 1 + .../regression_tests/phase1/3_vlans_over_bond.py | 109 +++++---- .../regression_tests/phase1/active_backup_bond.xml | 1 + .../phase1/active_backup_double_bond.xml | 1 + recipes/regression_tests/phase1/bonding_test.py | 101 ++++---- recipes/regression_tests/phase1/simple_netperf.py | 121 +++++----- recipes/regression_tests/phase1/simple_netperf.xml | 1 + ...tual_bridge_2_vlans_over_active_backup_bond.xml | 1 + .../phase1/virtual_bridge_2_vlans_over_bond.py | 140 +++++------ .../phase1/virtual_bridge_vlan_in_guest.py | 142 +++++------ .../phase1/virtual_bridge_vlan_in_guest.xml | 1 + .../phase1/virtual_bridge_vlan_in_host.py | 142 +++++------ .../phase1/virtual_bridge_vlan_in_host.xml | 1 + .../phase2/3_vlans_over_active_backup_team.xml | 1 + .../regression_tests/phase2/3_vlans_over_team.py | 137 ++++++----- .../phase2/active_backup_double_team.xml | 1 + .../regression_tests/phase2/active_backup_team.xml | 1 + .../active_backup_team_vs_active_backup_bond.xml | 1 + recipes/regression_tests/phase2/team_test.py | 268 +++++++++++---------- ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 146 +++++------ ..._ovs_bridge_2_vlans_over_active_backup_bond.xml | 1 + .../phase2/virtual_ovs_bridge_vlan_in_guest.py | 146 +++++------ .../phase2/virtual_ovs_bridge_vlan_in_guest.xml | 1 + .../phase2/virtual_ovs_bridge_vlan_in_host.py | 145 +++++------ .../phase2/virtual_ovs_bridge_vlan_in_host.xml | 1 + 27 files changed, 899 insertions(+), 822 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py index 6e6611f..442dbdc 100644 --- a/recipes/regression_tests/phase1/3_vlans.py +++ b/recipes/regression_tests/phase1/3_vlans.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) - result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) + result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting: + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", @@ -327,8 +329,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -359,36 +362,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) - result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) - result_tcp.set_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) + result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_tcp.set_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting: + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", @@ -419,8 +423,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/3_vlans.xml b/recipes/regression_tests/phase1/3_vlans.xml index 3c56aad..fdc681f 100644 --- a/recipes/regression_tests/phase1/3_vlans.xml +++ b/recipes/regression_tests/phase1/3_vlans.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="3_vlans.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/> diff --git a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml index 431202b..50a984e 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml +++ b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="3_vlans_over_active_backup_bond.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/> diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py index 2e0685e..8fc8dd6 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) - result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) + result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting: + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", @@ -327,8 +329,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -359,36 +362,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) - result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) + result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting: + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", @@ -419,8 +423,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/active_backup_bond.xml b/recipes/regression_tests/phase1/active_backup_bond.xml index ce2e610..ca65f54 100644 --- a/recipes/regression_tests/phase1/active_backup_bond.xml +++ b/recipes/regression_tests/phase1/active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_bond.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/> diff --git a/recipes/regression_tests/phase1/active_backup_double_bond.xml b/recipes/regression_tests/phase1/active_backup_double_bond.xml index 5154504..e769ffb 100644 --- a/recipes/regression_tests/phase1/active_backup_double_bond.xml +++ b/recipes/regression_tests/phase1/active_backup_double_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_double_bond.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/> diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py index 8b1dfc5..e08a4e5 100644 --- a/recipes/regression_tests/phase1/bonding_test.py +++ b/recipes/regression_tests/phase1/bonding_test.py @@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -256,34 +257,35 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting: + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", @@ -312,8 +314,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -344,34 +347,35 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting: + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", @@ -400,8 +404,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py index 272b57d..9ef7cf6 100644 --- a/recipes/regression_tests/phase1/simple_netperf.py +++ b/recipes/regression_tests/phase1/simple_netperf.py @@ -40,6 +40,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -220,33 +221,34 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter("num_parallel", nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", @@ -274,8 +276,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -304,33 +307,34 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter("num_parallel", nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", @@ -358,8 +362,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/simple_netperf.xml b/recipes/regression_tests/phase1/simple_netperf.xml index a202852..cd90233 100644 --- a/recipes/regression_tests/phase1/simple_netperf.xml +++ b/recipes/regression_tests/phase1/simple_netperf.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2" /> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="simple_netperf.mapping" /> <alias name="net" value="192.168.101" /> <alias name="driver" value="ixgbe" /> diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml index 9a2b3f4..a0d96e6 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml +++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_bridge_2_vlans_over_active_backup_bond.mapping" /> <alias name="vlan10_net" value="192.168.10"/> diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py index ae8baf9..c8715e8 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py @@ -46,6 +46,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -61,7 +62,6 @@ else: pr_comment = generate_perfrepo_comment([h1, g1, g2, h2, g3, g4], pr_user_comment)
mtu = ctl.get_alias("mtu") -enable_udp_perf = ctl.get_alias("enable_udp_perf")
h1_nic1 = h1.get_interface("nic1") h1_nic2 = h1.get_interface("nic2") @@ -326,37 +326,38 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = g3.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - if enable_udp_perf is not None and ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", @@ -388,8 +389,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -423,38 +425,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = g3.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None and ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=['kernel_release', @@ -485,8 +488,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py index f769086..0cfdf23 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py @@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else: pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu") -enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10") g1_vlan10 = g1.get_interface("vlan10") @@ -258,38 +258,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if enable_udp_perf is not None and ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=['kernel_release', @@ -320,8 +321,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -352,38 +354,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None and ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=['kernel_release', @@ -414,8 +417,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml index dd33be1..22aedf4 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_bridge_vlan_in_guest.mapping" /> <alias name="vlan10_net" value="192.168.10"/> diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py index 9607132..9cebece 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py @@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else: pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu") -enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10") g1_guestnic= g1.get_interface("guestnic") @@ -258,38 +258,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if enable_udp_perf is not None and ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=['kernel_release', @@ -320,8 +321,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -352,38 +354,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if enable_udp_perf and ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=['kernel_release', @@ -414,8 +417,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml index 382d9c6..5a71d40 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_bridge_vlan_in_host.mapping" /> <alias name="vlan10_net" value="192.168.10"/> diff --git a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml index 683675f..8e778f2 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml +++ b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="3_vlans_over_active_backup_team.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/> diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py index 4824db7..0c58fdf 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_team.py +++ b/recipes/regression_tests/phase2/3_vlans_over_team.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,37 +268,38 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) - result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[ @@ -327,8 +329,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -359,37 +362,38 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) - result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_tcp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[ @@ -419,8 +423,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase2/active_backup_double_team.xml b/recipes/regression_tests/phase2/active_backup_double_team.xml index 420992f..b4be042 100644 --- a/recipes/regression_tests/phase2/active_backup_double_team.xml +++ b/recipes/regression_tests/phase2/active_backup_double_team.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_double_team.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/> diff --git a/recipes/regression_tests/phase2/active_backup_team.xml b/recipes/regression_tests/phase2/active_backup_team.xml index 7a1f059..7b332a0 100644 --- a/recipes/regression_tests/phase2/active_backup_team.xml +++ b/recipes/regression_tests/phase2/active_backup_team.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_team.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/> diff --git a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml index 37e0d02..fca487f 100644 --- a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml +++ b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_team_vs_active_backup_bond.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/> diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py index 25a2823..e953ac0 100644 --- a/recipes/regression_tests/phase2/team_test.py +++ b/recipes/regression_tests/phase2/team_test.py @@ -40,6 +40,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,37 +256,38 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.set_parameter('netperf_server', "testmachine1") - result_tcp.set_parameter('netperf_client', "testmachine2") - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.set_parameter('netperf_server', "testmachine1") + result_tcp.set_parameter('netperf_client', "testmachine2") + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[ @@ -316,8 +318,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp # for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -349,37 +352,38 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.set_parameter('netperf_server', "testmachine1") - result_tcp.set_parameter('netperf_client', "testmachine2") - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*5) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.set_parameter('netperf_server', "testmachine1") + result_tcp.set_parameter('netperf_client', "testmachine2") + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*5) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[ @@ -494,37 +498,38 @@ for setting in offload_settings: server_proc = m2.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.set_parameter('netperf_server', "testmachine2") - result_tcp.set_parameter('netperf_client', "testmachine1") - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m1.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.set_parameter('netperf_server', "testmachine2") + result_tcp.set_parameter('netperf_client', "testmachine1") + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m1.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[ @@ -555,8 +560,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp # for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -588,37 +594,38 @@ for setting in offload_settings: server_proc = m2.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.set_parameter('netperf_server', "testmachine2") - result_tcp.set_parameter('netperf_client', "testmachine1") - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m1.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.set_parameter('netperf_server', "testmachine2") + result_tcp.set_parameter('netperf_client', "testmachine1") + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m1.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[ @@ -649,8 +656,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp # for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py index ccabb5b..0a5f6c3 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py @@ -47,6 +47,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -324,39 +325,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = g3.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[ @@ -388,8 +390,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -413,6 +416,7 @@ for setting in offload_settings: perf_api.save_result(result_sctp)
server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6) g4.run(ping_mod62) @@ -422,39 +426,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = g3.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[ @@ -486,8 +491,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml index 01c4291..8991be0 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="mtu" value="1500" /> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="virtual_ovs_bridge_2_vlans_over_active_backup_bond.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/> diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py index 8274601..dede110 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -257,39 +258,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[ @@ -321,8 +323,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -346,45 +349,47 @@ for setting in offload_settings: perf_api.save_result(result_sctp)
server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)
server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[ @@ -416,8 +421,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml index 786b9d3..739450e 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_guest.mapping" /> <alias name="vlan10_net" value="192.168.10"/> diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py index f0fd8c1..6b07372 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,39 +256,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[ @@ -319,8 +321,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[ @@ -351,39 +354,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr', - r'host\d+..*tap\d*.hwaddr', - r'host\d+..*tap\d*.devname']) - for offload in setting: - result_tcp.set_parameter(offload[0], offload[1]) - - if nperf_msg_size is not None: - result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) - - result_tcp.add_tag(product_name) - if nperf_mode == "multi": - result_tcp.add_tag("multithreaded") - result_tcp.set_parameter('num_parallel', nperf_num_parallel) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - result_tcp.set_comment(pr_comment) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if ("gro", "off") not in setting: + if nperf_protocols.find("tcp") > -1: + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr', + r'host\d+..*tap\d*.hwaddr', + r'host\d+..*tap\d*.devname']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + + if nperf_msg_size is not None: + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size) + + result_tcp.add_tag(product_name) + if nperf_mode == "multi": + result_tcp.add_tag("multithreaded") + result_tcp.set_parameter('num_parallel', nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + result_tcp.set_comment(pr_comment) + perf_api.save_result(result_tcp) + + if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: + # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[ @@ -415,8 +419,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off - if (len({val for val in setting if val[1] == 'off'}) == 0 or - ('gso', 'off') in setting): + if (nperf_protocols.find("sctp") > -1 and + (len({val for val in setting if val[1] == 'off'}) == 0 or + ('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[ diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml index 5f8b9e5..8c1de53 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/> + <alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_host.mapping" /> <alias name="vlan10_net" value="192.168.10"/>
Scratch this one too.
Wed, Nov 09, 2016 at 07:30:45PM CET, jtluka@redhat.com wrote:
All phase1 and phase2 tests now take optional alias nperf_protocols that can be used to limit which netperf tests to run.
For example, if set to 'tcp udp', only TCP_STREAM and UDP_STREAM are run, SCTP_STREAM will be skipped. The default value is all protocol tests, i.e. TCP, UDP and SCTP.
This patch also removes the 'enable_udp_perf' alias from virtual bridge tests since the new alias can be used in similar manner.
Signed-off-by: Jan Tluka jtluka@redhat.com
recipes/regression_tests/phase1/3_vlans.py | 109 +++++---- recipes/regression_tests/phase1/3_vlans.xml | 1 + .../phase1/3_vlans_over_active_backup_bond.xml | 1 + .../regression_tests/phase1/3_vlans_over_bond.py | 109 +++++---- .../regression_tests/phase1/active_backup_bond.xml | 1 + .../phase1/active_backup_double_bond.xml | 1 + recipes/regression_tests/phase1/bonding_test.py | 101 ++++---- recipes/regression_tests/phase1/simple_netperf.py | 121 +++++----- recipes/regression_tests/phase1/simple_netperf.xml | 1 + ...tual_bridge_2_vlans_over_active_backup_bond.xml | 1 + .../phase1/virtual_bridge_2_vlans_over_bond.py | 140 +++++------ .../phase1/virtual_bridge_vlan_in_guest.py | 142 +++++------ .../phase1/virtual_bridge_vlan_in_guest.xml | 1 + .../phase1/virtual_bridge_vlan_in_host.py | 142 +++++------ .../phase1/virtual_bridge_vlan_in_host.xml | 1 + .../phase2/3_vlans_over_active_backup_team.xml | 1 + .../regression_tests/phase2/3_vlans_over_team.py | 137 ++++++----- .../phase2/active_backup_double_team.xml | 1 + .../regression_tests/phase2/active_backup_team.xml | 1 + .../active_backup_team_vs_active_backup_bond.xml | 1 + recipes/regression_tests/phase2/team_test.py | 268 +++++++++++---------- ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 146 +++++------ ..._ovs_bridge_2_vlans_over_active_backup_bond.xml | 1 + .../phase2/virtual_ovs_bridge_vlan_in_guest.py | 146 +++++------ .../phase2/virtual_ovs_bridge_vlan_in_guest.xml | 1 + .../phase2/virtual_ovs_bridge_vlan_in_host.py | 145 +++++------ .../phase2/virtual_ovs_bridge_vlan_in_host.xml | 1 + 27 files changed, 899 insertions(+), 822 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py index 6e6611f..442dbdc 100644 --- a/recipes/regression_tests/phase1/3_vlans.py +++ b/recipes/regression_tests/phase1/3_vlans.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.set_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.set_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/3_vlans.xml b/recipes/regression_tests/phase1/3_vlans.xml index 3c56aad..fdc681f 100644 --- a/recipes/regression_tests/phase1/3_vlans.xml +++ b/recipes/regression_tests/phase1/3_vlans.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="3_vlans.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml index 431202b..50a984e 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml +++ b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="3_vlans_over_active_backup_bond.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py index 2e0685e..8fc8dd6 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/active_backup_bond.xml b/recipes/regression_tests/phase1/active_backup_bond.xml index ce2e610..ca65f54 100644 --- a/recipes/regression_tests/phase1/active_backup_bond.xml +++ b/recipes/regression_tests/phase1/active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_bond.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/active_backup_double_bond.xml b/recipes/regression_tests/phase1/active_backup_double_bond.xml index 5154504..e769ffb 100644 --- a/recipes/regression_tests/phase1/active_backup_double_bond.xml +++ b/recipes/regression_tests/phase1/active_backup_double_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_double_bond.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py index 8b1dfc5..e08a4e5 100644 --- a/recipes/regression_tests/phase1/bonding_test.py +++ b/recipes/regression_tests/phase1/bonding_test.py @@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -256,34 +257,35 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result",
@@ -312,8 +314,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -344,34 +347,35 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result",
@@ -400,8 +404,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py index 272b57d..9ef7cf6 100644 --- a/recipes/regression_tests/phase1/simple_netperf.py +++ b/recipes/regression_tests/phase1/simple_netperf.py @@ -40,6 +40,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -220,33 +221,34 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result",
@@ -274,8 +276,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -304,33 +307,34 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result",
@@ -358,8 +362,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.xml b/recipes/regression_tests/phase1/simple_netperf.xml index a202852..cd90233 100644 --- a/recipes/regression_tests/phase1/simple_netperf.xml +++ b/recipes/regression_tests/phase1/simple_netperf.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2" /> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="simple_netperf.mapping" /> <alias name="net" value="192.168.101" /> <alias name="driver" value="ixgbe" />
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml index 9a2b3f4..a0d96e6 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml +++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_bridge_2_vlans_over_active_backup_bond.mapping" /> <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py index ae8baf9..c8715e8 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py @@ -46,6 +46,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -61,7 +62,6 @@ else: pr_comment = generate_perfrepo_comment([h1, g1, g2, h2, g3, g4], pr_user_comment)
mtu = ctl.get_alias("mtu") -enable_udp_perf = ctl.get_alias("enable_udp_perf")
h1_nic1 = h1.get_interface("nic1") h1_nic2 = h1.get_interface("nic2") @@ -326,37 +326,38 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = g3.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if enable_udp_perf is not None and ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = g3.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting: # prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result",
@@ -388,8 +389,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -423,38 +425,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = g3.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if enable_udp_perf is not None and ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = g3.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=['kernel_release',
@@ -485,8 +488,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py index f769086..0cfdf23 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py @@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else: pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu") -enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10") g1_vlan10 = g1.get_interface("vlan10") @@ -258,38 +258,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if enable_udp_perf is not None and ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if enable_udp_perf is not None and ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml index dd33be1..22aedf4 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_bridge_vlan_in_guest.mapping" /> <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py index 9607132..9cebece 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py @@ -41,6 +41,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else: pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu") -enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10") g1_guestnic= g1.get_interface("guestnic") @@ -258,38 +258,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if enable_udp_perf is not None and ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if enable_udp_perf and ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=['kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml index 382d9c6..5a71d40 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_bridge_vlan_in_host.mapping" /> <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml index 683675f..8e778f2 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml +++ b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="3_vlans_over_active_backup_team.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py index 4824db7..0c58fdf 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_team.py +++ b/recipes/regression_tests/phase2/3_vlans_over_team.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,37 +268,38 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[
@@ -327,8 +329,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -359,37 +362,38 @@ for setting in offload_settings: srv_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[
@@ -419,8 +423,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase2/active_backup_double_team.xml b/recipes/regression_tests/phase2/active_backup_double_team.xml index 420992f..b4be042 100644 --- a/recipes/regression_tests/phase2/active_backup_double_team.xml +++ b/recipes/regression_tests/phase2/active_backup_double_team.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_double_team.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team.xml b/recipes/regression_tests/phase2/active_backup_team.xml index 7a1f059..7b332a0 100644 --- a/recipes/regression_tests/phase2/active_backup_team.xml +++ b/recipes/regression_tests/phase2/active_backup_team.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_team.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml index 37e0d02..fca487f 100644 --- a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml +++ b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="active_backup_team_vs_active_backup_bond.mapping" /> <alias name="net" value="192.168.0"/> <alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py index 25a2823..e953ac0 100644 --- a/recipes/regression_tests/phase2/team_test.py +++ b/recipes/regression_tests/phase2/team_test.py @@ -40,6 +40,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,37 +256,38 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine1")
result_tcp.set_parameter('netperf_client', "testmachine2")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine1")
result_tcp.set_parameter('netperf_client', "testmachine2")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[
@@ -316,8 +318,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp # for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -349,37 +352,38 @@ for setting in offload_settings: server_proc = m1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine1")
result_tcp.set_parameter('netperf_client', "testmachine2")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*5)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine1")
result_tcp.set_parameter('netperf_client', "testmachine2")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*5)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[
@@ -494,37 +498,38 @@ for setting in offload_settings: server_proc = m2.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine2")
result_tcp.set_parameter('netperf_client', "testmachine1")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m1.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine2")
result_tcp.set_parameter('netperf_client', "testmachine1")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = m1.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[
@@ -555,8 +560,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp # for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -588,37 +594,38 @@ for setting in offload_settings: server_proc = m2.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine2")
result_tcp.set_parameter('netperf_client', "testmachine1")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m1.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.set_parameter('netperf_server', "testmachine2")
result_tcp.set_parameter('netperf_client', "testmachine1")
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = m1.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[
@@ -649,8 +656,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp # for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py index ccabb5b..0a5f6c3 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py @@ -47,6 +47,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -324,39 +325,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = g3.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = g3.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[
@@ -388,8 +390,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -413,6 +416,7 @@ for setting in offload_settings: perf_api.save_result(result_sctp)
server_proc.intr()
- if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6) g4.run(ping_mod62)
@@ -422,39 +426,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = g3.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = g3.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[
@@ -486,8 +491,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml index 01c4291..8991be0 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml @@ -10,6 +10,7 @@ <alias name="mtu" value="1500" /> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mapping_file" value="virtual_ovs_bridge_2_vlans_over_active_backup_bond.mapping" /> <alias name="vlan10_net" value="192.168.10"/> <alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py index 8274601..dede110 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -257,39 +258,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[
@@ -321,8 +323,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -346,45 +349,47 @@ for setting in offload_settings: perf_api.save_result(result_sctp)
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)
server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[
@@ -416,8 +421,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml index 786b9d3..739450e 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_guest.mapping" /> <alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py index f0fd8c1..6b07372 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py @@ -42,6 +42,7 @@ nperf_max_dev = ctl.get_alias("nperf_max_dev") nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads") +nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,39 +256,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
"tcp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp, baseline)
tcp_res_data = h2.run(netperf_cli_tcp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp result_udp = perf_api.new_result("udp_ipv4_id", "udp_ipv4_result", hash_ignore=[
@@ -319,8 +321,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv4_id", "sctp_ipv4_result", hash_ignore=[
@@ -351,39 +354,40 @@ for setting in offload_settings: server_proc = g1.run(netperf_srv6, bg=True) ctl.wait(2)
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
# prepare PerfRepo result for udp ipv6
if ("gro", "off") not in setting:
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp ipv6
result_tcp = perf_api.new_result("tcp_ipv6_id",
"tcp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release',
r'guest\d+\.hostname',
r'guest\d+\..*hwaddr',
r'host\d+\..*tap\d*\.hwaddr',
r'host\d+\..*tap\d*\.devname'])
for offload in setting:
result_tcp.set_parameter(offload[0], offload[1])
if nperf_msg_size is not None:
result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
result_tcp.add_tag(product_name)
if nperf_mode == "multi":
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_tcp)
netperf_baseline_template(netperf_cli_tcp6, baseline)
tcp_res_data = h2.run(netperf_cli_tcp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
perf_api.save_result(result_tcp)
if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6 result_udp = perf_api.new_result("udp_ipv6_id", "udp_ipv6_result", hash_ignore=[
@@ -415,8 +419,9 @@ for setting in offload_settings: perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
if (len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting):
if (nperf_protocols.find("sctp") > -1 and
(len({val for val in setting if val[1] == 'off'}) == 0 or
('gso', 'off') in setting)): result_sctp = perf_api.new_result("sctp_ipv6_id", "sctp_ipv6_result", hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml index 5f8b9e5..8c1de53 100644 --- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml +++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml @@ -9,6 +9,7 @@ <alias name="nperf_num_parallel" value="2"/> <alias name="nperf_debug" value="0"/> <alias name="nperf_max_dev" value="20%"/>
<alias name="nperf_protocols" value="tcp udp sctp"/> <alias name="mtu" value="1500" /> <alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_host.mapping" /> <alias name="vlan10_net" value="192.168.10"/>
-- 2.7.4 _______________________________________________ LNST-developers mailing list -- lnst-developers@lists.fedorahosted.org To unsubscribe send an email to lnst-developers-leave@lists.fedorahosted.org
lnst-developers@lists.fedorahosted.org