This patch adds SCTP_STREAM to all phase1 and phase2 tests. The default packet size is set to 16K because the netperf defaults to bigger value that's not commonly used.
Signed-off-by: Jan Tluka jtluka@redhat.com --- recipes/regression_tests/phase1/3_vlans.py | 92 ++++++++++++ .../regression_tests/phase1/3_vlans_over_bond.py | 92 ++++++++++++ recipes/regression_tests/phase1/bonding_test.py | 88 ++++++++++++ recipes/regression_tests/phase1/simple_netperf.py | 90 ++++++++++++ .../phase1/virtual_bridge_2_vlans_over_bond.py | 92 ++++++++++++ .../phase1/virtual_bridge_vlan_in_guest.py | 90 ++++++++++++ .../phase1/virtual_bridge_vlan_in_host.py | 90 ++++++++++++ .../regression_tests/phase2/3_vlans_over_team.py | 92 ++++++++++++ recipes/regression_tests/phase2/team_test.py | 156 +++++++++++++++++++++ ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 92 ++++++++++++ .../phase2/virtual_ovs_bridge_vlan_in_guest.py | 90 ++++++++++++ .../phase2/virtual_ovs_bridge_vlan_in_host.py | 90 ++++++++++++ 12 files changed, 1154 insertions(+)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py index e4f1067..e0e8da0 100644 --- a/recipes/regression_tests/phase1/3_vlans.py +++ b/recipes/regression_tests/phase1/3_vlans.py @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -162,22 +164,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_vlan1.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_vlan1.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings: #apply offload setting @@ -284,6 +322,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_sctp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -349,6 +414,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_sctp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py index 342e105..79a125b 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_vlan1.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_vlan1.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings: #apply offload setting @@ -283,6 +321,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_sctp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -348,6 +413,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_sctp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py index 222613e..b3a96c1 100644 --- a/recipes/regression_tests/phase1/bonding_test.py +++ b/recipes/regression_tests/phase1/bonding_test.py @@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -171,22 +173,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : test_if1.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : test_if1.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -258,6 +296,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -321,6 +384,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py index 13996ca..9e7963a 100644 --- a/recipes/regression_tests/phase1/simple_netperf.py +++ b/recipes/regression_tests/phase1/simple_netperf.py @@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -130,6 +132,36 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_testiface.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_testiface.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + netperf_srv = ctl.get_module("Netperf", options={ "role" : "server", @@ -145,19 +177,25 @@ netperf_srv6 = ctl.get_module("Netperf", if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel" : nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel" : nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel" : nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel" : nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel" : nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel" : nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -230,6 +268,32 @@ for setting in offload_settings: netperf_result_template(result_udp, udp_res_data) result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -288,6 +352,32 @@ for setting in offload_settings: netperf_result_template(result_udp, udp_res_data) result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
# reset offload states 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 48142d7..284ea0e 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 @@ -47,6 +47,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : + "-L %s" % (g3_guestnic.get_ip(0)), + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : + "-L %s -6" % (g3_guestnic.get_ip(1)), + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing", options={ @@ -339,6 +381,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = g3.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -411,6 +478,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = g3.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states 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 eb23990..a637590 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py @@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -166,22 +168,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_vlan10.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_vlan10.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu h1.get_interface("nic").set_mtu(mtu) @@ -275,6 +315,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -344,6 +409,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states 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 695d322..21411e8 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py @@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -165,22 +167,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu h1.get_interface("nic").set_mtu(mtu) @@ -275,6 +315,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -344,6 +409,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py index fd16fe4..3f41d95 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_team.py +++ b/recipes/regression_tests/phase2/3_vlans_over_team.py @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_vlan1.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : m1_vlan1.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings: #apply offload setting @@ -283,6 +321,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_sctp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -348,6 +413,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server_on_vlan', vlans[0]) + result_sctp.set_parameter('netperf_client_on_vlan', vlans[0]) + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + srv_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py index 92a6169..0fa8bc2 100644 --- a/recipes/regression_tests/phase2/team_test.py +++ b/recipes/regression_tests/phase2/team_test.py @@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -170,22 +172,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : test_if1.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : test_if1.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -261,6 +299,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
+ # 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server', "testmachine1") + result_sctp.set_parameter('netperf_client', "testmachine2") + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr() if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6) @@ -327,6 +393,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
+ # 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server', "testmachine1") + result_sctp.set_parameter('netperf_client', "testmachine2") + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states @@ -366,6 +460,12 @@ netperf_cli_tcp6.update_options({"netperf_server" : test_if2.get_ip(1), netperf_cli_udp6.update_options({"netperf_server" : test_if2.get_ip(1), "netperf_opts" : p_opts6 })
+netperf_cli_sctp.update_options({"netperf_server" : test_if2.get_ip(0), + "netperf_opts" : p_opts}) + +netperf_cli_sctp6.update_options({"netperf_server" : test_if2.get_ip(1), + "netperf_opts" : p_opts6}) + for setting in offload_settings: dev_features = "" for offload in setting: @@ -438,6 +538,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
+ # 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server', "testmachine2") + result_sctp.set_parameter('netperf_client', "testmachine1") + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m1.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr() if ipv in [ 'ipv6', 'both' ]: m2.run(ping_mod6) @@ -504,6 +632,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
+ # 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.set_parameter('netperf_server', "testmachine2") + result_sctp.set_parameter('netperf_client', "testmachine1") + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = m1.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states 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 cb8fa99..288ef1e 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 @@ -48,6 +48,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : + "-L %s" % (g3_guestnic.get_ip(0)), + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : + "-L %s -6" % (g3_guestnic.get_ip(1)), + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing", options={ @@ -339,6 +381,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = g3.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr() if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6) @@ -412,6 +479,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = g3.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states 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 07dbf4b..63bea22 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 @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -164,22 +166,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_vlan10.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_vlan10.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu h1.get_interface("nic").set_mtu(mtu) @@ -276,6 +316,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr() if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6) @@ -346,6 +411,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states 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 07864a0..f375997 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 @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K" + if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -163,22 +165,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(0), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + +netperf_cli_sctp6 = ctl.get_module("Netperf", + options={ + "role" : "client", + "netperf_server" : + g1_guestnic.get_ip(1), + "duration" : netperf_duration, + "testname" : "SCTP_STREAM", + "confidence" : nperf_confidence, + "cpu_util" : nperf_cpu_util, + "runs" : nperf_max_runs, + "netperf_opts" : p_opts6, + "msg_size" : sctp_default_msg_size, + "debug" : nperf_debug, + "max_deviation" : nperf_max_dev + }) + if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence") + netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence") + netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel}) + netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) + netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu h1.get_interface("nic").set_mtu(mtu) @@ -274,6 +314,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv4_id", + "sctp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
if ipv in [ 'ipv6', 'both' ]: @@ -345,6 +410,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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): + result_sctp = perf_api.new_result("sctp_ipv6_id", + "sctp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_sctp.set_parameter(offload[0], offload[1]) + + result_sctp.add_tag(product_name) + if nperf_mode == "multi": + result_sctp.add_tag("multithreaded") + result_sctp.set_parameter("num_parallel", nperf_num_parallel) + + baseline = perf_api.get_baseline_of_result(result_sctp) + netperf_baseline_template(netperf_cli_sctp, baseline) + sctp_res_data = h2.run(netperf_cli_sctp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_sctp, sctp_res_data) + result_sctp.set_comment(pr_comment) + perf_api.save_result(result_sctp) + server_proc.intr()
#reset offload states
Scratch this one
Wed, Nov 09, 2016 at 07:26:59PM CET, jtluka@redhat.com wrote:
This patch adds SCTP_STREAM to all phase1 and phase2 tests. The default packet size is set to 16K because the netperf defaults to bigger value that's not commonly used.
Signed-off-by: Jan Tluka jtluka@redhat.com
recipes/regression_tests/phase1/3_vlans.py | 92 ++++++++++++ .../regression_tests/phase1/3_vlans_over_bond.py | 92 ++++++++++++ recipes/regression_tests/phase1/bonding_test.py | 88 ++++++++++++ recipes/regression_tests/phase1/simple_netperf.py | 90 ++++++++++++ .../phase1/virtual_bridge_2_vlans_over_bond.py | 92 ++++++++++++ .../phase1/virtual_bridge_vlan_in_guest.py | 90 ++++++++++++ .../phase1/virtual_bridge_vlan_in_host.py | 90 ++++++++++++ .../regression_tests/phase2/3_vlans_over_team.py | 92 ++++++++++++ recipes/regression_tests/phase2/team_test.py | 156 +++++++++++++++++++++ ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 92 ++++++++++++ .../phase2/virtual_ovs_bridge_vlan_in_guest.py | 90 ++++++++++++ .../phase2/virtual_ovs_bridge_vlan_in_host.py | 90 ++++++++++++ 12 files changed, 1154 insertions(+)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py index e4f1067..e0e8da0 100644 --- a/recipes/regression_tests/phase1/3_vlans.py +++ b/recipes/regression_tests/phase1/3_vlans.py @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -162,22 +164,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_vlan1.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_vlan1.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings: #apply offload setting @@ -284,6 +322,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -349,6 +414,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py index 342e105..79a125b 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_vlan1.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_vlan1.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings: #apply offload setting @@ -283,6 +321,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -348,6 +413,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py index 222613e..b3a96c1 100644 --- a/recipes/regression_tests/phase1/bonding_test.py +++ b/recipes/regression_tests/phase1/bonding_test.py @@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -171,22 +173,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : test_if1.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : test_if1.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -258,6 +296,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -321,6 +384,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py index 13996ca..9e7963a 100644 --- a/recipes/regression_tests/phase1/simple_netperf.py +++ b/recipes/regression_tests/phase1/simple_netperf.py @@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -130,6 +132,36 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_testiface.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_testiface.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
netperf_srv = ctl.get_module("Netperf", options={ "role" : "server", @@ -145,19 +177,25 @@ netperf_srv6 = ctl.get_module("Netperf", if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel" : nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel" : nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel" : nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel" : nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -230,6 +268,32 @@ for setting in offload_settings: netperf_result_template(result_udp, udp_res_data) result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -288,6 +352,32 @@ for setting in offload_settings: netperf_result_template(result_udp, udp_res_data) result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
# reset offload states 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 48142d7..284ea0e 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 @@ -47,6 +47,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" :
"-L %s" % (g3_guestnic.get_ip(0)),
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" :
"-L %s -6" % (g3_guestnic.get_ip(1)),
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing", options={ @@ -339,6 +381,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = g3.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -411,6 +478,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = g3.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states 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 eb23990..a637590 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py @@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -166,22 +168,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_vlan10.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_vlan10.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu h1.get_interface("nic").set_mtu(mtu) @@ -275,6 +315,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -344,6 +409,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states 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 695d322..21411e8 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py @@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -165,22 +167,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu h1.get_interface("nic").set_mtu(mtu) @@ -275,6 +315,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -344,6 +409,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py index fd16fe4..3f41d95 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_team.py +++ b/recipes/regression_tests/phase2/3_vlans_over_team.py @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_vlan1.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : m1_vlan1.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings: #apply offload setting @@ -283,6 +321,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -348,6 +413,33 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
srv_proc.intr()
#reset offload states diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py index 92a6169..0fa8bc2 100644 --- a/recipes/regression_tests/phase2/team_test.py +++ b/recipes/regression_tests/phase2/team_test.py @@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -170,22 +172,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : test_if1.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" : test_if1.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -261,6 +299,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
# 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server', "testmachine1")
result_sctp.set_parameter('netperf_client', "testmachine2")
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6)server_proc.intr()
@@ -327,6 +393,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
# 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server', "testmachine1")
result_sctp.set_parameter('netperf_client', "testmachine2")
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states @@ -366,6 +460,12 @@ netperf_cli_tcp6.update_options({"netperf_server" : test_if2.get_ip(1), netperf_cli_udp6.update_options({"netperf_server" : test_if2.get_ip(1), "netperf_opts" : p_opts6 })
+netperf_cli_sctp.update_options({"netperf_server" : test_if2.get_ip(0),
"netperf_opts" : p_opts})
+netperf_cli_sctp6.update_options({"netperf_server" : test_if2.get_ip(1),
"netperf_opts" : p_opts6})
for setting in offload_settings: dev_features = "" for offload in setting: @@ -438,6 +538,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
# 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server', "testmachine2")
result_sctp.set_parameter('netperf_client', "testmachine1")
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m1.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
if ipv in [ 'ipv6', 'both' ]: m2.run(ping_mod6)server_proc.intr()
@@ -504,6 +632,34 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) perf_api.save_result(result_udp)
# 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.set_parameter('netperf_server', "testmachine2")
result_sctp.set_parameter('netperf_client', "testmachine1")
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = m1.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states 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 cb8fa99..288ef1e 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 @@ -48,6 +48,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" :
"-L %s" % (g3_guestnic.get_ip(0)),
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" :
"-L %s -6" % (g3_guestnic.get_ip(1)),
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing", options={ @@ -339,6 +381,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = g3.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)server_proc.intr()
@@ -412,6 +479,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = g3.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states 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 07dbf4b..63bea22 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 @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -164,22 +166,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_vlan10.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_vlan10.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu h1.get_interface("nic").set_mtu(mtu) @@ -276,6 +316,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
if ipv in [ 'ipv6', 'both' ]: g1.run(ping_mod6)server_proc.intr()
@@ -346,6 +411,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states 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 07864a0..f375997 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 @@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size") pr_user_comment = ctl.get_alias("perfrepo_comment") offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
if offloads_alias is not None: offloads, offload_settings = parse_offloads(offloads_alias) else: @@ -163,22 +165,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf", "max_deviation" : nperf_max_dev })
+netperf_cli_sctp = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(0),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp6 = ctl.get_module("Netperf",
options={
"role" : "client",
"netperf_server" :
g1_guestnic.get_ip(1),
"duration" : netperf_duration,
"testname" : "SCTP_STREAM",
"confidence" : nperf_confidence,
"cpu_util" : nperf_cpu_util,
"runs" : nperf_max_runs,
"netperf_opts" : p_opts6,
"msg_size" : sctp_default_msg_size,
"debug" : nperf_debug,
"max_deviation" : nperf_max_dev
})
if nperf_mode == "multi": netperf_cli_tcp.unset_option("confidence") netperf_cli_udp.unset_option("confidence")
netperf_cli_sctp.unset_option("confidence") netperf_cli_tcp6.unset_option("confidence") netperf_cli_udp6.unset_option("confidence")
netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel}) netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None: netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp.update_options({"msg_size" : nperf_msg_size}) netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
- netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu h1.get_interface("nic").set_mtu(mtu) @@ -274,6 +314,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -345,6 +410,31 @@ for setting in offload_settings: result_udp.set_comment(pr_comment) 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):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
'kernel_release',
'redhat_release'])
for offload in setting:
result_sctp.set_parameter(offload[0], offload[1])
result_sctp.add_tag(product_name)
if nperf_mode == "multi":
result_sctp.add_tag("multithreaded")
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
netperf_baseline_template(netperf_cli_sctp, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_sctp, sctp_res_data)
result_sctp.set_comment(pr_comment)
perf_api.save_result(result_sctp)
server_proc.intr()
#reset offload states
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