[PATCH] recipes: add SCTP_STREAM netperf tests to regression tests

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(a)redhat.com&gt; --- 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 -- 2.7.4