From: Ondrej Lichtner <olichtne(a)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(a)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"))
--
2.6.1