From: Ondrej Lichtner olichtne@redhat.com
This patch changes which offload combinations we test. Previously we would test gso, gro and tso in both on and off states - 6 combinations, and since all the offloads are on by default this means that 3 of those combinations were identical (gro=on; gso=on; tso=on) resulting in 2 useless tests.
From now on we will only be testing some specific combinations, for now
we have: * gro=on + gso=on + tso=on + tx=on + rx=on * gro=off + gso=on + tso=on + tx=on + rx=on * gro=on + gso=off + tso=off + tx=on + rx=on * gro=on + gso=on + tso=off + tx=off + rx=on * gro=on + gso=on + tso=on + tx=on + rx=off
This should halve the test time compared to before. Unfortunately this patch will change all the hashes generated for PerfRepo results.
Signed-off-by: Ondrej Lichtner olichtne@redhat.com --- recipes/regression_tests/phase1/3_vlans.py | 224 ++++++----- .../regression_tests/phase1/3_vlans_over_bond.py | 231 ++++++----- recipes/regression_tests/phase1/bonding_test.py | 203 +++++----- .../phase1/virtual_bridge_2_vlans_over_bond.py | 197 ++++++---- .../phase1/virtual_bridge_vlan_in_guest.py | 166 ++++---- .../phase1/virtual_bridge_vlan_in_host.py | 165 ++++---- .../regression_tests/phase2/3_vlans_over_team.py | 229 ++++++----- recipes/regression_tests/phase2/team_test.py | 427 +++++++++++---------- ...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 235 +++++++----- .../phase2/virtual_ovs_bridge_vlan_in_guest.py | 203 +++++----- .../phase2/virtual_ovs_bridge_vlan_in_host.py | 205 +++++----- 11 files changed, 1358 insertions(+), 1127 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py index 3fdf60c..2007dc4 100644 --- a/recipes/regression_tests/phase1/3_vlans.py +++ b/recipes/regression_tests/phase1/3_vlans.py @@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # ------
vlans = ["vlan10", "vlan20", "vlan30"] -offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") mtu = ctl.get_alias("mtu") @@ -120,111 +125,115 @@ for vlan1 in vlans: if vlan1 == vlan2: # These tests should pass # Ping between same VLANs - for offload in offloads: - for state in ["off", "on"]: - # Offload setup + for setting in offload_settings: + for offload in setting: m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"), - offload, state)) + offload[0], offload[1])) m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - # Ping test - m1.run(ping_mod) - - # Netperf test (both TCP and UDP) - srv_proc = m1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = m2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - srv_proc.intr() - - if ipv in [ 'ipv6', 'both' ]: - # Ping test - m1.run(ping_mod6) - - # Netperf test (both TCP and UDP) - srv_proc = m1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - result_tcp.set_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - result_udp.set_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - srv_proc.intr() + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + # Ping test + m1.run(ping_mod) + + # Netperf test (both TCP and UDP) + srv_proc = m1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr() + + if ipv in [ 'ipv6', 'both' ]: + # Ping test + m1.run(ping_mod6) + + # Netperf test (both TCP and UDP) + srv_proc = m1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.set_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.set_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
# These tests should fail # Ping across different VLAN @@ -234,3 +243,10 @@ for vlan1 in vlans:
if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6, expect="fail") + +#reset offload states +for offload in offloads: + m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"), + offload, "on")) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"), + offload, "on")) diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py index d96a44f..79c4b4d 100644 --- a/recipes/regression_tests/phase1/3_vlans_over_bond.py +++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py @@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # ------
vlans = ["vlan10", "vlan20", "vlan30"] -offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") mtu = ctl.get_alias("mtu") @@ -120,114 +125,119 @@ for vlan1 in vlans: if vlan1 == vlan2: # These tests should pass # Ping between same VLANs - for offload in offloads: - for state in ["off", "on"]: - # Offload setup + for setting in offload_settings: + #apply offload setting + for offload in setting: m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"), - offload, state)) + offload[0], offload[1])) m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"), - offload, state)) + offload[0], offload[1])) m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - # Ping test - m1.run(ping_mod) - - # Netperf test (both TCP and UDP) - srv_proc = m1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = m2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - srv_proc.intr() - - if ipv in [ 'ipv6', 'both' ]: - # Ping test - m1.run(ping_mod6) - - # Netperf test (both TCP and UDP) - srv_proc = m1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - srv_proc.intr() + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + # Ping test + m1.run(ping_mod) + + # Netperf test (both TCP and UDP) + srv_proc = m1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr() + + if ipv in [ 'ipv6', 'both' ]: + # Ping test + m1.run(ping_mod6) + + # Netperf test (both TCP and UDP) + srv_proc = m1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr()
# These tests should fail # Ping across different VLAN @@ -237,3 +247,12 @@ for vlan1 in vlans:
if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6, expect="fail") + +#reset offload states +for offload in offloads: + m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"), + offload, "on")) + m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"), + offload, "on")) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"), + offload, "on")) diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py index ffbfc55..18659d1 100644 --- a/recipes/regression_tests/phase1/bonding_test.py +++ b/recipes/regression_tests/phase1/bonding_test.py @@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["tso", "gro", "gso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") mtu = ctl.get_alias("mtu") @@ -111,96 +116,108 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
ctl.wait(15)
+for setting in offload_settings: + for offload in setting: + m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), + offload[0], offload[1])) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + m1.run(ping_mod) + + server_proc = m1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + + if ipv in [ 'ipv6', 'both' ]: + m1.run(ping_mod6) + + server_proc = m1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + +#reset offload states for offload in offloads: - for state in ["off", "on"]: - m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload, - state)) - m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload, - state)) - if ipv in [ 'ipv4', 'both' ]: - m1.run(ping_mod) - - server_proc = m1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = m2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() - - if ipv in [ 'ipv6', 'both' ]: - m1.run(ping_mod6) - - server_proc = m1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() + m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), + offload, "on")) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), + offload, "on")) 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 5b0cb2b..ed2de32 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 @@ -30,7 +30,12 @@ g4.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") netperf_duration = int(ctl.get_alias("netperf_duration")) @@ -187,120 +192,144 @@ g4.get_interface("guestnic").set_mtu(mtu)
ctl.wait(15)
-for offload in offloads: - for state in ["off", "on"]: +for setting in offload_settings: + for offload in setting: h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"), - offload, state)) + offload[0], offload[1])) h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"), - offload, state)) + offload[0], offload[1])) g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - g1.run(ping_mod) - g4.run(ping_mod2) - g1.run(ping_mod_bad, expect="fail") - g3.run(ping_mod_bad2, expect="fail") - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + g1.run(ping_mod) + g4.run(ping_mod2) + g1.run(ping_mod_bad, expect="fail") + g3.run(ping_mod_bad2, expect="fail") + + server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + if enable_udp_perf is not None: + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline)
- tcp_res_data = g3.run(netperf_cli_tcp, + udp_res_data = g3.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- if enable_udp_perf is not None: - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) + server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) + if ipv in [ 'ipv6', 'both' ]: + g1.run(ping_mod6) + g4.run(ping_mod62) + g1.run(ping_mod6_bad, expect="fail") + g3.run(ping_mod6_bad2, expect="fail")
- udp_res_data = g3.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2)
- netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name)
- server_proc.intr() + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- if ipv in [ 'ipv6', 'both' ]: - g1.run(ping_mod6) - g4.run(ping_mod62) - g1.run(ping_mod6_bad, expect="fail") - g3.run(ping_mod6_bad2, expect="fail") + tcp_res_data = g3.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", + # prepare PerfRepo result for udp ipv6 + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- tcp_res_data = g3.run(netperf_cli_tcp6, + udp_res_data = g3.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None: - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- udp_res_data = g3.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + server_proc.intr()
- netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() +#reset offload states +for offload in offloads: + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"), + offload, "on")) + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"), + offload, "on")) + g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), + offload, "on")) + g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"), + offload, "on")) + g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"), + offload, "on")) + g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"), + offload, "on")) 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 f0b2c65..b762f8c 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py @@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") netperf_duration = int(ctl.get_alias("netperf_duration")) @@ -122,105 +127,118 @@ h2.get_interface("nic").set_mtu(mtu)
ctl.wait(15)
-for offload in offloads: - for state in ["off", "on"]: +for setting in offload_settings: + for offload in setting: g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), - offload, state)) - - if ipv in [ 'ipv4', 'both' ]: - g1.run(ping_mod) - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + g1.run(ping_mod) + + server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp, + udp_res_data = h2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- # prepare PerfRepo result for udp - if enable_udp_perf is not None: - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) + server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) + if ipv in [ 'ipv6', 'both' ]: + g1.run(ping_mod6)
- udp_res_data = h2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2)
- netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name)
- server_proc.intr() + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- if ipv in [ 'ipv6', 'both' ]: - g1.run(ping_mod6) + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", + # prepare PerfRepo result for udp ipv6 + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp6, + udp_res_data = h2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- # prepare PerfRepo result for udp ipv6 - if enable_udp_perf is not None: - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) + server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = h2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() +#reset offload states +for offload in offloads: + g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), + offload, "on")) + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), + offload, "on")) 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 fa64aba..4c1a454 100644 --- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py +++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py @@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") netperf_duration = int(ctl.get_alias("netperf_duration")) @@ -123,104 +128,118 @@ h2.get_interface("vlan10").set_mtu(mtu)
ctl.wait(15)
-for offload in offloads: - for state in ["off", "on"]: +for setting in offload_settings: + for offload in setting: g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - g1.run(ping_mod) - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + g1.run(ping_mod) + + server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + if enable_udp_perf is not None: + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp, + udp_res_data = h2.run(netperf_cli_udp, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- # prepare PerfRepo result for udp - if enable_udp_perf is not None: - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) + server_proc.intr()
- baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) + if ipv in [ 'ipv6', 'both' ]: + g1.run(ping_mod6)
- udp_res_data = h2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2)
- netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=['kernel_release', + 'redhat_release', + r'guest\d+.hostname', + r'guest\d+..*hwaddr']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name)
- server_proc.intr() + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline)
- if ipv in [ 'ipv6', 'both' ]: - g1.run(ping_mod6) + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp)
- # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", + # prepare PerfRepo result for udp ipv6 + if enable_udp_perf: + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", hash_ignore=['kernel_release', 'redhat_release', r'guest\d+.hostname', r'guest\d+..*hwaddr']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name)
- baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline)
- tcp_res_data = h2.run(netperf_cli_tcp6, + udp_res_data = h2.run(netperf_cli_udp6, timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
- netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - if enable_udp_perf: - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=['kernel_release', - 'redhat_release', - r'guest\d+.hostname', - r'guest\d+..*hwaddr']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp)
- baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) + server_proc.intr()
- udp_res_data = h2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() +#reset offload states +for offload in offloads: + g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), + offload, "on")) + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), + offload, "on")) diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py index 905674d..77298a2 100644 --- a/recipes/regression_tests/phase2/3_vlans_over_team.py +++ b/recipes/regression_tests/phase2/3_vlans_over_team.py @@ -23,7 +23,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # ------
vlans = ["vlan10", "vlan20", "vlan30"] -offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") mtu = ctl.get_alias("mtu") @@ -121,114 +126,117 @@ for vlan1 in vlans: if vlan1 == vlan2: # These tests should pass # Ping between same VLANs - for offload in offloads: - for state in ["off", "on"]: - # Offload setup + for setting in offload_settings: + for offload in setting: m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"), - offload, state)) + offload[0], offload[1])) m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"), - offload, state)) + offload[0], offload[1])) m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"), - offload, state)) - - if ipv in [ 'ipv4', 'both' ]: - # Ping test - m1.run(ping_mod) - - # Netperf test (both TCP and UDP) - srv_proc = m1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = m2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - srv_proc.intr() - - if ipv in [ 'ipv6', 'both' ]: - m1.run(ping_mod6) - - # Netperf test (both TCP and UDP) - srv_proc = m1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server_on_vlan', vlan1) - result_tcp.set_parameter('netperf_client_on_vlan', vlan2) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server_on_vlan', vlan1) - result_udp.set_parameter('netperf_client_on_vlan', vlan2) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - srv_proc.intr() + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + # Ping test + m1.run(ping_mod) + + # Netperf test (both TCP and UDP) + srv_proc = m1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr() + + if ipv in [ 'ipv6', 'both' ]: + m1.run(ping_mod6) + + # Netperf test (both TCP and UDP) + srv_proc = m1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server_on_vlan', vlan1) + result_tcp.set_parameter('netperf_client_on_vlan', vlan2) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server_on_vlan', vlan1) + result_udp.set_parameter('netperf_client_on_vlan', vlan2) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + srv_proc.intr() # These tests should fail # Ping across different VLAN else: @@ -237,3 +245,12 @@ for vlan1 in vlans:
if ipv in [ 'ipv6', 'both' ]: m1.run(ping_mod6, expect="fail") + +#reset offload states +for offload in offloads: + m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth1"), + offload, "on")) + m1.run("ethtool -K %s %s %s" % (m1.get_devname("eth2"), + offload, "on")) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("eth1"), + offload, "on")) diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py index e974ec2..8ebb5cf 100644 --- a/recipes/regression_tests/phase2/team_test.py +++ b/recipes/regression_tests/phase2/team_test.py @@ -22,7 +22,12 @@ m2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["tso", "gro", "gso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") mtu = ctl.get_alias("mtu") @@ -111,106 +116,118 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
ctl.wait(15)
+for setting in offload_settings: + for offload in setting: + m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), + offload[0], offload[1])) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + m1.run(ping_mod) + + server_proc = m1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server', "testmachine1") + result_tcp.set_parameter('netperf_client', "testmachine2") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server', "testmachine1") + result_udp.set_parameter('netperf_client', "testmachine2") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: + m1.run(ping_mod6) + + server_proc = m1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server', "testmachine1") + result_tcp.set_parameter('netperf_client', "testmachine2") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*5) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server', "testmachine1") + result_udp.set_parameter('netperf_client', "testmachine2") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*5) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + +#reset offload states for offload in offloads: - for state in ["off", "on"]: - m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload, - state)) - m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload, - state)) - if ipv in [ 'ipv4', 'both' ]: - m1.run(ping_mod) - - server_proc = m1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine1") - result_tcp.set_parameter('netperf_client', "testmachine2") - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine1") - result_udp.set_parameter('netperf_client', "testmachine2") - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = m2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() - if ipv in [ 'ipv6', 'both' ]: - m1.run(ping_mod6) - - server_proc = m1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine1") - result_tcp.set_parameter('netperf_client', "testmachine2") - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*5) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine1") - result_udp.set_parameter('netperf_client', "testmachine2") - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = m2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*5) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() + m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), + offload, "on")) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), + offload, "on"))
ping_mod.update_options({"addr" : m1.get_ip("test_if", 0), @@ -235,103 +252,115 @@ netperf_cli_tcp6.update_options({"netperf_server" : m2.get_ip("test_if", 1), netperf_cli_udp6.update_options({"netperf_server" : m2.get_ip("test_if", 1), "netperf_opts" : "-i %s -L %s -6" % (nperf_max_runs, m1.get_ip("test_if", 1))})
+for setting in offload_settings: + for offload in setting: + m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), + offload[0], offload[1])) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + m2.run(ping_mod) + + server_proc = m2.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server', "testmachine2") + result_tcp.set_parameter('netperf_client', "testmachine1") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = m1.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server', "testmachine2") + result_udp.set_parameter('netperf_client', "testmachine1") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = m1.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: + m2.run(ping_mod6) + + server_proc = m2.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.set_parameter('netperf_server', "testmachine2") + result_tcp.set_parameter('netperf_client', "testmachine1") + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = m1.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.set_parameter('netperf_server', "testmachine2") + result_udp.set_parameter('netperf_client', "testmachine1") + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = m1.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + +#reset offload states for offload in offloads: - for state in ["off", "on"]: - m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), offload, - state)) - m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), offload, - state)) - if ipv in [ 'ipv4', 'both' ]: - m2.run(ping_mod) - - server_proc = m2.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine2") - result_tcp.set_parameter('netperf_client', "testmachine1") - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = m1.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine2") - result_udp.set_parameter('netperf_client', "testmachine1") - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = m1.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() - if ipv in [ 'ipv6', 'both' ]: - m2.run(ping_mod6) - - server_proc = m2.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.set_parameter('netperf_server', "testmachine2") - result_tcp.set_parameter('netperf_client', "testmachine1") - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = m1.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.set_parameter('netperf_server', "testmachine2") - result_udp.set_parameter('netperf_client', "testmachine1") - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = m1.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() + m1.run("ethtool -K %s %s %s" % (m1.get_devname("test_if"), + offload, "on")) + m2.run("ethtool -K %s %s %s" % (m2.get_devname("test_if"), + offload, "on")) 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 6ba9541..1c1aad7 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 @@ -30,7 +30,12 @@ g4.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") netperf_duration = int(ctl.get_alias("netperf_duration")) @@ -164,113 +169,137 @@ ping_mod6_bad2 = ctl.get_module("Icmp6Ping",
ctl.wait(15)
-for offload in offloads: - for state in ["off", "on"]: +for setting in offload_settings: + for offload in setting: h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"), - offload, state)) + offload[0], offload[1])) h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"), - offload, state)) + offload[0], offload[1])) g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - g1.run(ping_mod) - g4.run(ping_mod2) - g1.run(ping_mod_bad, expect="fail") - g3.run(ping_mod_bad2, expect="fail") - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = g3.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = g3.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() - if ipv in [ 'ipv6', 'both' ]: - g1.run(ping_mod6) - g4.run(ping_mod62) - g1.run(ping_mod6_bad, expect="fail") - g3.run(ping_mod6_bad2, expect="fail") - - server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = g3.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = g3.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + g1.run(ping_mod) + g4.run(ping_mod2) + g1.run(ping_mod_bad, expect="fail") + g3.run(ping_mod_bad2, expect="fail") + + server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = g3.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: + g1.run(ping_mod6) + g4.run(ping_mod62) + g1.run(ping_mod6_bad, expect="fail") + g3.run(ping_mod6_bad2, expect="fail") + + server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = g3.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = g3.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + +#reset offload states +for offload in offloads: + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic1"), + offload, "on")) + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic2"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic1"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic2"), + offload, "on")) + g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), + offload, "on")) + g2.run("ethtool -K %s %s %s" % (g2.get_devname("guestnic"), + offload, "on")) + g3.run("ethtool -K %s %s %s" % (g3.get_devname("guestnic"), + offload, "on")) + g4.run("ethtool -K %s %s %s" % (g4.get_devname("guestnic"), + offload, "on")) 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 3a09ec0..598c31b 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 @@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") netperf_duration = int(ctl.get_alias("netperf_duration")) @@ -109,97 +114,111 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
ctl.wait(15)
-for offload in offloads: - for state in ["off", "on"]: +for setting in offload_settings: + for offload in setting: h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), - offload, state)) + offload[0], offload[1])) g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - g1.run(ping_mod) - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = h2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() - if ipv in [ 'ipv6', 'both' ]: - g1.run(ping_mod6) - - server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = h2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + g1.run(ping_mod) + + server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = h2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + if ipv in [ 'ipv6', 'both' ]: + g1.run(ping_mod6) + + server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = h2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + +#reset offload states +for offload in offloads: + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), + offload, "on")) + g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), + offload, "on")) 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 6e1cc74..9c2fd5d 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 @@ -24,7 +24,12 @@ h2.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf"]) # TESTS # ------
-offloads = ["gso", "gro", "tso"] +offloads = ["gro", "gso", "tso", "rx", "tx"] +offload_settings = [ [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "off"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "off"), ("tso", "off"), ("tx", "on"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "off"), ("tx", "off"), ("rx", "on")], + [("gro", "on"), ("gso", "on"), ("tso", "on"), ("tx", "on"), ("rx", "off")]]
ipv = ctl.get_alias("ipv") netperf_duration = int(ctl.get_alias("netperf_duration")) @@ -108,98 +113,112 @@ netperf_cli_udp6 = ctl.get_module("Netperf", }) ctl.wait(15)
-for offload in offloads: - for state in ["off", "on"]: +for setting in offload_settings: + for offload in setting: h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), - offload, state)) + offload[0], offload[1])) g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), - offload, state)) + offload[0], offload[1])) h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), - offload, state)) - if ipv in [ 'ipv4', 'both' ]: - g1.run(ping_mod) - - server_proc = g1.run(netperf_srv, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp - result_tcp = perf_api.new_result("tcp_ipv4_id", - "tcp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp - result_udp = perf_api.new_result("udp_ipv4_id", - "udp_ipv4_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp, baseline) - - udp_res_data = h2.run(netperf_cli_udp, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() - - if ipv in [ 'ipv6', 'both' ]: - g1.run(ping_mod6) - - server_proc = g1.run(netperf_srv6, bg=True) - ctl.wait(2) - - # prepare PerfRepo result for tcp ipv6 - result_tcp = perf_api.new_result("tcp_ipv6_id", - "tcp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_tcp.set_parameter(offload, state) - result_tcp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_tcp) - netperf_baseline_template(netperf_cli_tcp6, baseline) - - tcp_res_data = h2.run(netperf_cli_tcp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_tcp, tcp_res_data) - perf_api.save_result(result_tcp) - - # prepare PerfRepo result for udp ipv6 - result_udp = perf_api.new_result("udp_ipv6_id", - "udp_ipv6_result", - hash_ignore=[ - 'kernel_release', - 'redhat_release']) - result_udp.set_parameter(offload, state) - result_udp.add_tag(product_name) - - baseline = perf_api.get_baseline_of_result(result_udp) - netperf_baseline_template(netperf_cli_udp6, baseline) - - udp_res_data = h2.run(netperf_cli_udp6, - timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) - - netperf_result_template(result_udp, udp_res_data) - perf_api.save_result(result_udp) - - server_proc.intr() + offload[0], offload[1])) + + if ipv in [ 'ipv4', 'both' ]: + g1.run(ping_mod) + + server_proc = g1.run(netperf_srv, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp + result_tcp = perf_api.new_result("tcp_ipv4_id", + "tcp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp + result_udp = perf_api.new_result("udp_ipv4_id", + "udp_ipv4_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp, baseline) + + udp_res_data = h2.run(netperf_cli_udp, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + + if ipv in [ 'ipv6', 'both' ]: + g1.run(ping_mod6) + + server_proc = g1.run(netperf_srv6, bg=True) + ctl.wait(2) + + # prepare PerfRepo result for tcp ipv6 + result_tcp = perf_api.new_result("tcp_ipv6_id", + "tcp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_tcp.set_parameter(offload[0], offload[1]) + result_tcp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_tcp) + netperf_baseline_template(netperf_cli_tcp6, baseline) + + tcp_res_data = h2.run(netperf_cli_tcp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_tcp, tcp_res_data) + perf_api.save_result(result_tcp) + + # prepare PerfRepo result for udp ipv6 + result_udp = perf_api.new_result("udp_ipv6_id", + "udp_ipv6_result", + hash_ignore=[ + 'kernel_release', + 'redhat_release']) + for offload in setting: + result_udp.set_parameter(offload[0], offload[1]) + result_udp.add_tag(product_name) + + baseline = perf_api.get_baseline_of_result(result_udp) + netperf_baseline_template(netperf_cli_udp6, baseline) + + udp_res_data = h2.run(netperf_cli_udp6, + timeout = (netperf_duration + nperf_reserve)*nperf_max_runs) + + netperf_result_template(result_udp, udp_res_data) + perf_api.save_result(result_udp) + + server_proc.intr() + +#reset offload states +for offload in offloads: + h1.run("ethtool -K %s %s %s" % (h1.get_devname("nic"), + offload, "on")) + g1.run("ethtool -K %s %s %s" % (g1.get_devname("guestnic"), + offload, "on")) + h2.run("ethtool -K %s %s %s" % (h2.get_devname("nic"), + offload, "on"))