11:49 a.m.
All phase3 tests now take optional alias nperf_protocols that
can be used to limit which netperf tests to run.
For example, if set to 'udp', only UDP_STREAM.
The default value is all protocol tests for phase3, i.e. TCP and UDP.
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
.../regression_tests/phase3/2_virt_ovs_vxlan.py | 282 ++++++++++----------
.../regression_tests/phase3/2_virt_ovs_vxlan.xml | 1 +
.../regression_tests/phase3/novirt_ovs_vxlan.py | 265 ++++++++++---------
.../regression_tests/phase3/novirt_ovs_vxlan.xml | 1 +
recipes/regression_tests/phase3/simple_macsec.py | 273 +++++++++----------
recipes/regression_tests/phase3/simple_macsec.xml | 1 +
recipes/regression_tests/phase3/vxlan_multicast.py | 289 +++++++++++----------
.../regression_tests/phase3/vxlan_multicast.xml | 1 +
recipes/regression_tests/phase3/vxlan_remote.py | 263 ++++++++++---------
recipes/regression_tests/phase3/vxlan_remote.xml | 1 +
10 files changed, 702 insertions(+), 675 deletions(-)
diff --git a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
index 5ebaacc..17cc0ce 100644
--- a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
+++ b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
@@ -44,6 +44,7 @@ nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
pr_user_comment = ctl.get_alias("perfrepo_comment")
+nperf_protocols = ctl.get_alias("nperf_protocols")
pr_comment = generate_perfrepo_comment([guest1, guest2, guest3, guest4],
pr_user_comment)
@@ -127,148 +128,149 @@ if ipv in ['ipv6', 'both']:
if ipv in [ 'ipv4', 'both' ]:
# prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_host\d+\.hostname',
- r'test_host\d+\..*hwaddr',
- r'machine_h\d+\..*ovs\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.devname'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts": nperf_opts,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_host\d+\.hostname',
- r'test_host\d+\..*hwaddr',
- r'machine_h\d+\..*ovs\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.devname'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts": nperf_opts,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_host\d+\.hostname',
+ r'test_host\d+\..*hwaddr',
+ r'machine_h\d+\..*ovs\d*\.hwaddr',
+ r'machine_h\d+\..*tap\d*\.hwaddr',
+
r'machine_h\d+\..*tap\d*\.devname'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts": nperf_opts,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_host\d+\.hostname',
+ r'test_host\d+\..*hwaddr',
+ r'machine_h\d+\..*ovs\d*\.hwaddr',
+ r'machine_h\d+\..*tap\d*\.hwaddr',
+
r'machine_h\d+\..*tap\d*\.devname'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
+ udp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
+ client_opts = client_opts, baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if ipv in [ 'ipv6', 'both' ]:
# prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_host\d+\.hostname',
- r'test_host\d+\..*hwaddr',
- r'machine_h\d+\..*ovs\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.devname'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts" : nperf_opts +
"-6",
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- #prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_host\d+\.hostname',
- r'test_host\d+\..*hwaddr',
- r'machine_h\d+\..*ovs\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.hwaddr',
- r'machine_h\d+\..*tap\d*\.devname'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts" : nperf_opts +
"-6",
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_host\d+\.hostname',
+ r'test_host\d+\..*hwaddr',
+ r'machine_h\d+\..*ovs\d*\.hwaddr',
+ r'machine_h\d+\..*tap\d*\.hwaddr',
+
r'machine_h\d+\..*tap\d*\.devname'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts" : nperf_opts +
"-6",
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ #prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_host\d+\.hostname',
+ r'test_host\d+\..*hwaddr',
+ r'machine_h\d+\..*ovs\d*\.hwaddr',
+ r'machine_h\d+\..*tap\d*\.hwaddr',
+
r'machine_h\d+\..*tap\d*\.devname'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts" : nperf_opts +
"-6",
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if nperf_cpupin:
host1.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.xml
b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.xml
index 2861acb..3d131b8 100644
--- a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.xml
+++ b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="1"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp"/>
<alias name="mapping_file"
value="2_virt_ovs_vxlan.mapping" />
<alias name="net" value="192.168.2"/>
<alias name="vxlan_net" value="192.168.100"/>
diff --git a/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
index 5419ad9..e2998e2 100644
--- a/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
+++ b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
@@ -38,6 +38,7 @@ nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
pr_user_comment = ctl.get_alias("perfrepo_comment")
+nperf_protocols = ctl.get_alias("nperf_protocols")
pr_comment = generate_perfrepo_comment([h1, h2], pr_user_comment)
@@ -77,139 +78,143 @@ if ipv in [ 'ipv6', 'both' ]:
if ipv in [ 'ipv4', 'both' ]:
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'interface_ovs\d+\.hwaddr'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
- (h2, h2_nic, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'interface_ovs\d+\.hwaddr'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
- (h2, h2_nic, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'interface_ovs\d+\.hwaddr'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
+ (h2, h2_nic, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'interface_ovs\d+\.hwaddr'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
+ (h2, h2_nic, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if ipv in [ 'ipv6', 'both' ]:
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'interface_ovs\d+\.hwaddr'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
- (h2, h2_nic, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'interface_ovs\d+\.hwaddr'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
- (h2, h2_nic, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'interface_ovs\d+\.hwaddr'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
+ (h2, h2_nic, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts" : nperf_opts +
"-6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'interface_ovs\d+\.hwaddr'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
+ (h2, h2_nic, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts" : nperf_opts +
"-6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if nperf_cpupin:
h1.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/novirt_ovs_vxlan.xml
b/recipes/regression_tests/phase3/novirt_ovs_vxlan.xml
index bf2d387..9764d50 100644
--- a/recipes/regression_tests/phase3/novirt_ovs_vxlan.xml
+++ b/recipes/regression_tests/phase3/novirt_ovs_vxlan.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="1"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp"/>
<alias name="mapping_file"
value="novirt_ovs_vxlan.mapping" />
<alias name="net" value="192.168.2"/>
<alias name="vxlan_net" value="192.168.100"/>
diff --git a/recipes/regression_tests/phase3/simple_macsec.py
b/recipes/regression_tests/phase3/simple_macsec.py
index b16214b..013e852 100644
--- a/recipes/regression_tests/phase3/simple_macsec.py
+++ b/recipes/regression_tests/phase3/simple_macsec.py
@@ -37,6 +37,7 @@ nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
pr_user_comment = ctl.get_alias("perfrepo_comment")
+nperf_protocols = ctl.get_alias("nperf_protocols")
pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
@@ -132,73 +133,75 @@ for setting in encryption_settings:
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- result_tcp.set_parameter('encryption', setting)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
- (m2, m2_tif, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- result_udp.set_parameter('encryption', setting)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
- (m2, m2_tif, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ result_tcp.set_parameter('encryption', setting)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+ (m2, m2_tif, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" :
nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation":
nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ result_udp.set_parameter('encryption', setting)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+ (m2, m2_tif, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" :
nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation":
nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if ipv in [ 'ipv6', 'both' ]:
@@ -208,73 +211,75 @@ for setting in encryption_settings:
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- result_tcp.set_parameter('encryption', setting)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
- (m2, m2_tif, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
" -6"},
- baseline = baseline,
- timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- result_udp.set_parameter('encryption', setting)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
- (m2, m2_tif, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
- timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ result_tcp.set_parameter('encryption', setting)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
+ (m2, m2_tif, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" :
nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation":
nperf_max_dev,
+ "netperf_opts" : nperf_opts +
" -6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ result_udp.set_parameter('encryption', setting)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
+ (m2, m2_tif, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" :
nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation":
nperf_max_dev,
+ "netperf_opts" : nperf_opts +
"-6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
m1.run("ip link delete %s" % msec_tif_name)
diff --git a/recipes/regression_tests/phase3/simple_macsec.xml
b/recipes/regression_tests/phase3/simple_macsec.xml
index 2209af6..0ef80a5 100644
--- a/recipes/regression_tests/phase3/simple_macsec.xml
+++ b/recipes/regression_tests/phase3/simple_macsec.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="1" />
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp"/>
<alias name="mapping_file" value="simple_macsec.mapping"
/>
<alias name="net" value="192.168.0" />
<alias name="driver" value=""/>
diff --git a/recipes/regression_tests/phase3/vxlan_multicast.py
b/recipes/regression_tests/phase3/vxlan_multicast.py
index 0c29977..02050ce 100644
--- a/recipes/regression_tests/phase3/vxlan_multicast.py
+++ b/recipes/regression_tests/phase3/vxlan_multicast.py
@@ -39,6 +39,7 @@ nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
pr_user_comment = ctl.get_alias("perfrepo_comment")
+nperf_protocols = ctl.get_alias("nperf_protocols")
pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
@@ -99,150 +100,154 @@ for i in ipv6_pings:
ctl.wait(2)
if ipv in [ 'ipv4', 'both' ]:
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
-
r'testmachine\d+\.interface_tap\d+.hwaddr',
- r'guest\d+\.hostname',
- r'guest\d+\.interface_eth\d+\.hwaddr',
- r'test_if\.hwaddr'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
-
r'testmachine\d+\.interface_tap\d+.hwaddr',
- r'guest\d+\.hostname',
- r'guest\d+\.interface_eth\d+\.hwaddr',
- r'test_if\.hwaddr'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+
r'testmachine\d+\.interface_tap\d+.hwaddr',
+ r'guest\d+\.hostname',
+
r'guest\d+\.interface_eth\d+\.hwaddr',
+ r'test_if\.hwaddr'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
+ (m2, test_if2, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+
r'testmachine\d+\.interface_tap\d+.hwaddr',
+ r'guest\d+\.hostname',
+
r'guest\d+\.interface_eth\d+\.hwaddr',
+ r'test_if\.hwaddr'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
+ (m2, test_if2, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if ipv in [ 'ipv6', 'both' ]:
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
-
r'testmachine\d+\.interface_tap\d+.hwaddr',
- r'guest\d+\.hostname',
- r'guest\d+\.interface_eth\d+\.hwaddr',
- r'test_if\.hwaddr'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts + "
-6"},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
-
r'testmachine\d+\.interface_tap\d+.hwaddr',
- r'guest\d+\.hostname',
- r'guest\d+\.interface_eth\d+\.hwaddr',
- r'test_if\.hwaddr'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+
r'testmachine\d+\.interface_tap\d+.hwaddr',
+ r'guest\d+\.hostname',
+
r'guest\d+\.interface_eth\d+\.hwaddr',
+ r'test_if\.hwaddr'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
+ (m2, test_if2, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts" : nperf_opts +
" -6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+
r'testmachine\d+\.interface_tap\d+.hwaddr',
+ r'guest\d+\.hostname',
+
r'guest\d+\.interface_eth\d+\.hwaddr',
+ r'test_if\.hwaddr'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
+ (m2, test_if2, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts" : nperf_opts +
"-6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if nperf_cpupin:
m1.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/vxlan_multicast.xml
b/recipes/regression_tests/phase3/vxlan_multicast.xml
index 5021652..715a19c 100644
--- a/recipes/regression_tests/phase3/vxlan_multicast.xml
+++ b/recipes/regression_tests/phase3/vxlan_multicast.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="1"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp"/>
<alias name="mapping_file" value="vxlan_multicast.mapping"
/>
<alias name="net" value="192.168.0"/>
<alias name="vxlan_net" value="192.168.100"/>
diff --git a/recipes/regression_tests/phase3/vxlan_remote.py
b/recipes/regression_tests/phase3/vxlan_remote.py
index 12050d9..0ec0e86 100644
--- a/recipes/regression_tests/phase3/vxlan_remote.py
+++ b/recipes/regression_tests/phase3/vxlan_remote.py
@@ -38,6 +38,7 @@ nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
pr_user_comment = ctl.get_alias("perfrepo_comment")
+nperf_protocols = ctl.get_alias("nperf_protocols")
pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
@@ -74,141 +75,145 @@ if ipv in [ 'ipv4', 'both' ]:
ctl.wait(2)
# prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_if\.hwaddr'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- result_udp = perf_api.new_result("udp_ipv4_id",
- "udp_ipv4_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_if\.hwaddr'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ result_tcp = perf_api.new_result("tcp_ipv4_id",
+ "tcp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_if\.hwaddr'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
+ (m2, test_if2, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp
+ result_udp = perf_api.new_result("udp_ipv4_id",
+ "udp_ipv4_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_if\.hwaddr'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
+ (m2, test_if2, 0, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts": nperf_opts},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if ipv in [ 'ipv6', 'both' ]:
ping6((m1, test_if1, 1, {"scope": 0}),
(m2, test_if2, 1, {"scope": 0}),
options=ping_opts)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_if\.hwaddr'])
- result_tcp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts + "
-6"},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- result_udp = perf_api.new_result("udp_ipv6_id",
- "udp_ipv6_result",
- hash_ignore=[
- r'kernel_release',
- r'redhat_release',
- r'test_if\.hwaddr'])
- result_udp.add_tag(product_name)
- if nperf_num_parallel > 1:
- result_udp.add_tag("multithreaded")
- result_udp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_udp)
- baseline = perfrepo_baseline_to_dict(baseline)
-
- udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" : "UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" : nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_udp, udp_res_data)
- result_udp.set_comment(pr_comment)
- perf_api.save_result(result_udp)
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp ipv6
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_if\.hwaddr'])
+ result_tcp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
+ (m2, test_if2, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts" : nperf_opts +
" -6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1:
+ # prepare PerfRepo result for udp ipv6
+ result_udp = perf_api.new_result("udp_ipv6_id",
+ "udp_ipv6_result",
+ hash_ignore=[
+ r'kernel_release',
+ r'redhat_release',
+ r'test_if\.hwaddr'])
+ result_udp.add_tag(product_name)
+ if nperf_num_parallel > 1:
+ result_udp.add_tag("multithreaded")
+ result_udp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
+ (m2, test_if2, 1, {"scope": 0}),
+ client_opts={"duration" : netperf_duration,
+ "testname" :
"UDP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" :
nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev,
+ "netperf_opts" : nperf_opts +
"-6"},
+ baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_udp, udp_res_data)
+ result_udp.set_comment(pr_comment)
+ perf_api.save_result(result_udp)
if nperf_cpupin:
m1.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/vxlan_remote.xml
b/recipes/regression_tests/phase3/vxlan_remote.xml
index 824c839..3d290f0 100644
--- a/recipes/regression_tests/phase3/vxlan_remote.xml
+++ b/recipes/regression_tests/phase3/vxlan_remote.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="1"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp"/>
<alias name="mapping_file" value="vxlan_remote.mapping"
/>
<alias name="net" value="192.168.0"/>
<alias name="vxlan_net" value="192.168.100"/>
--
2.9.3
11:49 a.m.
New subject: [PATCH v2 2/2] regression-tests: add nperf_msg_size alias to all phase3 tests
This patch adds nperf_msg_size alias to all phase3 tests.
Changes in v2:
* Rebased patch which adds nperf_protocols alias to phase3 recipes
* Fixed bug which caused to run only IPv4 TCP_STREAM all the time
* Fixed bugs where result_tcp was used instead of result_udp
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
.../regression_tests/phase3/2_virt_ovs_vxlan.py | 69 ++++++++-------
.../regression_tests/phase3/novirt_ovs_vxlan.py | 82 +++++++++---------
recipes/regression_tests/phase3/simple_macsec.py | 85 ++++++++++---------
recipes/regression_tests/phase3/vxlan_multicast.py | 98 +++++++++++-----------
recipes/regression_tests/phase3/vxlan_remote.py | 98 +++++++++++-----------
5 files changed, 221 insertions(+), 211 deletions(-)
diff --git a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
index 17cc0ce..9c583ff 100644
--- a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
+++ b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
@@ -43,6 +43,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
+nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
nperf_protocols = ctl.get_alias("nperf_protocols")
@@ -125,6 +126,19 @@ if ipv in ['ipv6', 'both']:
(guest4, g4_nic, 1, {"scope": 0}),
options=ping_opts, expect="fail")
+client_opts = {"duration" : netperf_duration,
+ "testname" : "TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" : nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts": nperf_opts,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev}
+
+if nperf_msg_size is not None:
+ client_opts["msg_size"] = nperf_msg_size
+
if ipv in [ 'ipv4', 'both' ]:
# prepare PerfRepo result for tcp
@@ -144,20 +158,17 @@ if ipv in [ 'ipv4', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
tcp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts": nperf_opts,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -215,21 +226,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
tcp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts" : nperf_opts +
"-6",
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
- timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+ client_opts = client_opts, baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
result_tcp.set_comment(pr_comment)
@@ -252,21 +260,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
udp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "netperf_opts" : nperf_opts +
"-6",
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev},
- baseline = baseline,
- timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
+ client_opts = client_opts, baseline = baseline,
+ timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
diff --git a/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
index e2998e2..e8d12e4 100644
--- a/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
+++ b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
@@ -37,6 +37,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
+nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
nperf_protocols = ctl.get_alias("nperf_protocols")
@@ -74,6 +75,19 @@ if ipv in [ 'ipv6', 'both' ]:
(h2, h2_nic, 1, {"scope": 0}),
options=ping_opts)
+client_opts = {"duration" : netperf_duration,
+ "testname" : "TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" : nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts": nperf_opts,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev}
+
+if nperf_msg_size is not None:
+ client_opts["msg_size"] = nperf_msg_size
+
#netperfs
if ipv in [ 'ipv4', 'both' ]:
ctl.wait(2)
@@ -91,21 +105,18 @@ if ipv in [ 'ipv4', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
tcp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
(h2, h2_nic, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -125,21 +136,18 @@ if ipv in [ 'ipv4', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
udp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
(h2, h2_nic, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -161,21 +169,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
(h2, h2_nic, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -195,21 +200,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
(h2, h2_nic, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
diff --git a/recipes/regression_tests/phase3/simple_macsec.py
b/recipes/regression_tests/phase3/simple_macsec.py
index 013e852..668dae2 100644
--- a/recipes/regression_tests/phase3/simple_macsec.py
+++ b/recipes/regression_tests/phase3/simple_macsec.py
@@ -36,6 +36,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
+nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
nperf_protocols = ctl.get_alias("nperf_protocols")
@@ -119,6 +120,19 @@ ping((m1, m1_phy, 0, {"scope": 0}),
ctl.wait(2)
+client_opts = {"duration" : netperf_duration,
+ "testname" : "TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" : nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts": nperf_opts,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev}
+
+if nperf_msg_size is not None:
+ client_opts["msg_size"] = nperf_msg_size
+
for setting in encryption_settings:
#macsec setup
macsecSetup(setting)
@@ -132,7 +146,6 @@ for setting in encryption_settings:
ctl.wait(2)
-
if nperf_protocols.find("tcp") > -1:
# prepare PerfRepo result for tcp
result_tcp = perf_api.new_result("tcp_ipv4_id",
@@ -147,21 +160,18 @@ for setting in encryption_settings:
result_tcp.set_parameter('encryption', setting)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
(m2, m2_tif, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" :
nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation":
nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -182,28 +192,24 @@ for setting in encryption_settings:
result_udp.set_parameter('encryption', setting)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
(m2, m2_tif, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" :
nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation":
nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
-
if ipv in [ 'ipv6', 'both' ]:
ping6((m1, m1_tif, 1, {"scope": 0}),
(m2, m2_tif, 1, {"scope": 0}),
@@ -225,21 +231,18 @@ for setting in encryption_settings:
result_tcp.set_parameter('encryption', setting)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "6"
+
tcp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
(m2, m2_tif, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" :
nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation":
nperf_max_dev,
- "netperf_opts" : nperf_opts +
" -6"},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -260,28 +263,24 @@ for setting in encryption_settings:
result_udp.set_parameter('encryption', setting)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "6"
+
udp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
(m2, m2_tif, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" :
nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation":
nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
-
m1.run("ip link delete %s" % msec_tif_name)
m2.run("ip link delete %s" % msec_tif_name)
diff --git a/recipes/regression_tests/phase3/vxlan_multicast.py
b/recipes/regression_tests/phase3/vxlan_multicast.py
index 02050ce..714439a 100644
--- a/recipes/regression_tests/phase3/vxlan_multicast.py
+++ b/recipes/regression_tests/phase3/vxlan_multicast.py
@@ -38,6 +38,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
+nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
nperf_protocols = ctl.get_alias("nperf_protocols")
@@ -98,6 +99,19 @@ for x in ipv6_endpoints:
for i in ipv6_pings:
i.wait()
+client_opts = {"duration" : netperf_duration,
+ "testname" : "TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" : nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts": nperf_opts,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev}
+
+if nperf_msg_size is not None:
+ client_opts["msg_size"] = nperf_msg_size
+
ctl.wait(2)
if ipv in [ 'ipv4', 'both' ]:
if nperf_protocols.find("tcp") > -1:
@@ -116,21 +130,18 @@ if ipv in [ 'ipv4', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
- tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
+ tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+ (m2, m2_tif, 0, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -153,21 +164,18 @@ if ipv in [ 'ipv4', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
- udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
+ udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+ (m2, m2_tif, 0, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -191,21 +199,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
- tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
" -6"},
- baseline = baseline,
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
+ tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
+ (h2, h2_nic, 1, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -228,21 +233,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
- udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
+ udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
+ (h2, h2_nic, 1, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
diff --git a/recipes/regression_tests/phase3/vxlan_remote.py
b/recipes/regression_tests/phase3/vxlan_remote.py
index 0ec0e86..7606814 100644
--- a/recipes/regression_tests/phase3/vxlan_remote.py
+++ b/recipes/regression_tests/phase3/vxlan_remote.py
@@ -37,6 +37,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
nperf_debug = ctl.get_alias("nperf_debug")
nperf_max_dev = ctl.get_alias("nperf_max_dev")
+nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
nperf_protocols = ctl.get_alias("nperf_protocols")
@@ -67,6 +68,19 @@ ctl.wait(15)
ping_opts = {"count": 100, "interval": 0.1}
+client_opts = {"duration" : netperf_duration,
+ "testname" : "TCP_STREAM",
+ "confidence" : nperf_confidence,
+ "num_parallel" : nperf_num_parallel,
+ "cpu_util" : nperf_cpu_util,
+ "runs": nperf_max_runs,
+ "netperf_opts": nperf_opts,
+ "debug": nperf_debug,
+ "max_deviation": nperf_max_dev}
+
+if nperf_msg_size is not None:
+ client_opts["msg_size"] = nperf_msg_size
+
if ipv in [ 'ipv4', 'both' ]:
ping((m1, test_if1, 0, {"scope": 0}),
(m2, test_if2, 0, {"scope": 0}),
@@ -87,21 +101,18 @@ if ipv in [ 'ipv4', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
- tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
+ tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+ (m2, m2_tif, 0, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -121,21 +132,18 @@ if ipv in [ 'ipv4', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
- udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
- (m2, test_if2, 0, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts": nperf_opts},
- baseline = baseline,
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts
+
+ udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
+ (m2, m2_tif, 0, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -160,21 +168,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_tcp.add_tag("multithreaded")
result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_tcp)
baseline = perfrepo_baseline_to_dict(baseline)
- tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"TCP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
" -6"},
- baseline = baseline,
+ client_opts["testname"] = "TCP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
+ tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
+ (h2, h2_nic, 1, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -194,21 +199,18 @@ if ipv in [ 'ipv6', 'both' ]:
result_udp.add_tag("multithreaded")
result_udp.set_parameter('num_parallel', nperf_num_parallel)
+ if nperf_msg_size is not None:
+ result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
+
baseline = perf_api.get_baseline_of_result(result_udp)
baseline = perfrepo_baseline_to_dict(baseline)
- udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
- (m2, test_if2, 1, {"scope": 0}),
- client_opts={"duration" : netperf_duration,
- "testname" :
"UDP_STREAM",
- "confidence" : nperf_confidence,
- "num_parallel" :
nperf_num_parallel,
- "cpu_util" : nperf_cpu_util,
- "runs": nperf_max_runs,
- "debug": nperf_debug,
- "max_deviation": nperf_max_dev,
- "netperf_opts" : nperf_opts +
"-6"},
- baseline = baseline,
+ client_opts["testname"] = "UDP_STREAM"
+ client_opts["netperf_opts"] = nperf_opts + "-6"
+
+ udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
+ (h2, h2_nic, 1, {"scope": 0}),
+ client_opts = client_opts, baseline = baseline,
timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
--
2.9.3
11:50 a.m.
New subject: [PATCH v2 2/2] regression-tests: add nperf_msg_size alias to all
phase3 tests
This patchset is for review only now, test Beaker job has been
submitted for testing it.
2017-01-11 18:49 GMT+01:00 Jiri Prochazka <jprochaz(a)redhat.com>:
> This patch adds nperf_msg_size alias to all phase3 tests.
>
> Changes in v2:
> * Rebased patch which adds nperf_protocols alias to phase3 recipes
> * Fixed bug which caused to run only IPv4 TCP_STREAM all the time
> * Fixed bugs where result_tcp was used instead of result_udp
>
>
> Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
> ---
> .../regression_tests/phase3/2_virt_ovs_vxlan.py | 69 ++++++++-------
> .../regression_tests/phase3/novirt_ovs_vxlan.py | 82 +++++++++---------
> recipes/regression_tests/phase3/simple_macsec.py | 85 ++++++++++---------
> recipes/regression_tests/phase3/vxlan_multicast.py | 98 +++++++++++-----------
> recipes/regression_tests/phase3/vxlan_remote.py | 98 +++++++++++-----------
> 5 files changed, 221 insertions(+), 211 deletions(-)
>
> diff --git a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
> index 17cc0ce..9c583ff 100644
> --- a/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
> +++ b/recipes/regression_tests/phase3/2_virt_ovs_vxlan.py
> @@ -43,6 +43,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
> nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
> nperf_debug = ctl.get_alias("nperf_debug")
> nperf_max_dev = ctl.get_alias("nperf_max_dev")
> +nperf_msg_size = ctl.get_alias("nperf_msg_size")
> pr_user_comment = ctl.get_alias("perfrepo_comment")
> nperf_protocols = ctl.get_alias("nperf_protocols")
>
> @@ -125,6 +126,19 @@ if ipv in ['ipv6', 'both']:
> (guest4, g4_nic, 1, {"scope": 0}),
> options=ping_opts, expect="fail")
>
> +client_opts = {"duration" : netperf_duration,
> + "testname" : "TCP_STREAM",
> + "confidence" : nperf_confidence,
> + "num_parallel" : nperf_num_parallel,
> + "cpu_util" : nperf_cpu_util,
> + "runs": nperf_max_runs,
> + "netperf_opts": nperf_opts,
> + "debug": nperf_debug,
> + "max_deviation": nperf_max_dev}
> +
> +if nperf_msg_size is not None:
> + client_opts["msg_size"] = nperf_msg_size
> +
>
> if ipv in [ 'ipv4', 'both' ]:
> # prepare PerfRepo result for tcp
> @@ -144,20 +158,17 @@ if ipv in [ 'ipv4', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> tcp_res_data = netperf((guest1, g1_nic, 0), (guest3, g3_nic, 0),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "netperf_opts": nperf_opts,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -215,21 +226,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> tcp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "netperf_opts" : nperf_opts +
"-6",
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev},
> - baseline = baseline,
> - timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
> + client_opts = client_opts, baseline = baseline,
> + timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> result_tcp.set_comment(pr_comment)
> @@ -252,21 +260,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> udp_res_data = netperf((guest1, g1_nic, 1), (guest3, g3_nic, 1),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "netperf_opts" : nperf_opts +
"-6",
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev},
> - baseline = baseline,
> - timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
> + client_opts = client_opts, baseline = baseline,
> + timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> result_udp.set_comment(pr_comment)
> diff --git a/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
> index e2998e2..e8d12e4 100644
> --- a/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
> +++ b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
> @@ -37,6 +37,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
> nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
> nperf_debug = ctl.get_alias("nperf_debug")
> nperf_max_dev = ctl.get_alias("nperf_max_dev")
> +nperf_msg_size = ctl.get_alias("nperf_msg_size")
> pr_user_comment = ctl.get_alias("perfrepo_comment")
> nperf_protocols = ctl.get_alias("nperf_protocols")
>
> @@ -74,6 +75,19 @@ if ipv in [ 'ipv6', 'both' ]:
> (h2, h2_nic, 1, {"scope": 0}),
> options=ping_opts)
>
> +client_opts = {"duration" : netperf_duration,
> + "testname" : "TCP_STREAM",
> + "confidence" : nperf_confidence,
> + "num_parallel" : nperf_num_parallel,
> + "cpu_util" : nperf_cpu_util,
> + "runs": nperf_max_runs,
> + "netperf_opts": nperf_opts,
> + "debug": nperf_debug,
> + "max_deviation": nperf_max_dev}
> +
> +if nperf_msg_size is not None:
> + client_opts["msg_size"] = nperf_msg_size
> +
> #netperfs
> if ipv in [ 'ipv4', 'both' ]:
> ctl.wait(2)
> @@ -91,21 +105,18 @@ if ipv in [ 'ipv4', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> tcp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
> (h2, h2_nic, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts": nperf_opts},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -125,21 +136,18 @@ if ipv in [ 'ipv4', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> udp_res_data = netperf((h1, h1_nic, 0, {"scope": 0}),
> (h2, h2_nic, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts": nperf_opts},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> @@ -161,21 +169,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
> (h2, h2_nic, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" : nperf_opts +
"-6"},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -195,21 +200,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
> (h2, h2_nic, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" : nperf_opts +
"-6"},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> diff --git a/recipes/regression_tests/phase3/simple_macsec.py
b/recipes/regression_tests/phase3/simple_macsec.py
> index 013e852..668dae2 100644
> --- a/recipes/regression_tests/phase3/simple_macsec.py
> +++ b/recipes/regression_tests/phase3/simple_macsec.py
> @@ -36,6 +36,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
> nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
> nperf_debug = ctl.get_alias("nperf_debug")
> nperf_max_dev = ctl.get_alias("nperf_max_dev")
> +nperf_msg_size = ctl.get_alias("nperf_msg_size")
> pr_user_comment = ctl.get_alias("perfrepo_comment")
> nperf_protocols = ctl.get_alias("nperf_protocols")
>
> @@ -119,6 +120,19 @@ ping((m1, m1_phy, 0, {"scope": 0}),
>
> ctl.wait(2)
>
> +client_opts = {"duration" : netperf_duration,
> + "testname" : "TCP_STREAM",
> + "confidence" : nperf_confidence,
> + "num_parallel" : nperf_num_parallel,
> + "cpu_util" : nperf_cpu_util,
> + "runs": nperf_max_runs,
> + "netperf_opts": nperf_opts,
> + "debug": nperf_debug,
> + "max_deviation": nperf_max_dev}
> +
> +if nperf_msg_size is not None:
> + client_opts["msg_size"] = nperf_msg_size
> +
> for setting in encryption_settings:
> #macsec setup
> macsecSetup(setting)
> @@ -132,7 +146,6 @@ for setting in encryption_settings:
>
> ctl.wait(2)
>
> -
> if nperf_protocols.find("tcp") > -1:
> # prepare PerfRepo result for tcp
> result_tcp = perf_api.new_result("tcp_ipv4_id",
> @@ -147,21 +160,18 @@ for setting in encryption_settings:
>
> result_tcp.set_parameter('encryption', setting)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size",
nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
> (m2, m2_tif, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" :
nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts":
nperf_opts},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -182,28 +192,24 @@ for setting in encryption_settings:
>
> result_udp.set_parameter('encryption', setting)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size",
nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
> (m2, m2_tif, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" :
nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts":
nperf_opts},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> result_udp.set_comment(pr_comment)
> perf_api.save_result(result_udp)
>
> -
> if ipv in [ 'ipv6', 'both' ]:
> ping6((m1, m1_tif, 1, {"scope": 0}),
> (m2, m2_tif, 1, {"scope": 0}),
> @@ -225,21 +231,18 @@ for setting in encryption_settings:
>
> result_tcp.set_parameter('encryption', setting)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size",
nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "6"
> +
> tcp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
> (m2, m2_tif, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" :
nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" :
nperf_opts + " -6"},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -260,28 +263,24 @@ for setting in encryption_settings:
>
> result_udp.set_parameter('encryption', setting)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size",
nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "6"
> +
> udp_res_data = netperf((m1, m1_tif, 1, {"scope": 0}),
> (m2, m2_tif, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" :
nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" :
nperf_opts + "-6"},
> - baseline = baseline,
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> result_udp.set_comment(pr_comment)
> perf_api.save_result(result_udp)
>
> -
> m1.run("ip link delete %s" % msec_tif_name)
> m2.run("ip link delete %s" % msec_tif_name)
>
> diff --git a/recipes/regression_tests/phase3/vxlan_multicast.py
b/recipes/regression_tests/phase3/vxlan_multicast.py
> index 02050ce..714439a 100644
> --- a/recipes/regression_tests/phase3/vxlan_multicast.py
> +++ b/recipes/regression_tests/phase3/vxlan_multicast.py
> @@ -38,6 +38,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
> nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
> nperf_debug = ctl.get_alias("nperf_debug")
> nperf_max_dev = ctl.get_alias("nperf_max_dev")
> +nperf_msg_size = ctl.get_alias("nperf_msg_size")
> pr_user_comment = ctl.get_alias("perfrepo_comment")
> nperf_protocols = ctl.get_alias("nperf_protocols")
>
> @@ -98,6 +99,19 @@ for x in ipv6_endpoints:
> for i in ipv6_pings:
> i.wait()
>
> +client_opts = {"duration" : netperf_duration,
> + "testname" : "TCP_STREAM",
> + "confidence" : nperf_confidence,
> + "num_parallel" : nperf_num_parallel,
> + "cpu_util" : nperf_cpu_util,
> + "runs": nperf_max_runs,
> + "netperf_opts": nperf_opts,
> + "debug": nperf_debug,
> + "max_deviation": nperf_max_dev}
> +
> +if nperf_msg_size is not None:
> + client_opts["msg_size"] = nperf_msg_size
> +
> ctl.wait(2)
> if ipv in [ 'ipv4', 'both' ]:
> if nperf_protocols.find("tcp") > -1:
> @@ -116,21 +130,18 @@ if ipv in [ 'ipv4', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
> - (m2, test_if2, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts": nperf_opts},
> - baseline = baseline,
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> + tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
> + (m2, m2_tif, 0, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -153,21 +164,18 @@ if ipv in [ 'ipv4', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
> - (m2, test_if2, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts": nperf_opts},
> - baseline = baseline,
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> + udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
> + (m2, m2_tif, 0, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> @@ -191,21 +199,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
> - (m2, test_if2, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" : nperf_opts +
" -6"},
> - baseline = baseline,
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> + tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
> + (h2, h2_nic, 1, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -228,21 +233,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
> - (m2, test_if2, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" : nperf_opts +
"-6"},
> - baseline = baseline,
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> + udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
> + (h2, h2_nic, 1, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> diff --git a/recipes/regression_tests/phase3/vxlan_remote.py
b/recipes/regression_tests/phase3/vxlan_remote.py
> index 0ec0e86..7606814 100644
> --- a/recipes/regression_tests/phase3/vxlan_remote.py
> +++ b/recipes/regression_tests/phase3/vxlan_remote.py
> @@ -37,6 +37,7 @@ nperf_cpu_util = ctl.get_alias("nperf_cpu_util")
> nperf_num_parallel = int(ctl.get_alias("nperf_num_parallel"))
> nperf_debug = ctl.get_alias("nperf_debug")
> nperf_max_dev = ctl.get_alias("nperf_max_dev")
> +nperf_msg_size = ctl.get_alias("nperf_msg_size")
> pr_user_comment = ctl.get_alias("perfrepo_comment")
> nperf_protocols = ctl.get_alias("nperf_protocols")
>
> @@ -67,6 +68,19 @@ ctl.wait(15)
>
> ping_opts = {"count": 100, "interval": 0.1}
>
> +client_opts = {"duration" : netperf_duration,
> + "testname" : "TCP_STREAM",
> + "confidence" : nperf_confidence,
> + "num_parallel" : nperf_num_parallel,
> + "cpu_util" : nperf_cpu_util,
> + "runs": nperf_max_runs,
> + "netperf_opts": nperf_opts,
> + "debug": nperf_debug,
> + "max_deviation": nperf_max_dev}
> +
> +if nperf_msg_size is not None:
> + client_opts["msg_size"] = nperf_msg_size
> +
> if ipv in [ 'ipv4', 'both' ]:
> ping((m1, test_if1, 0, {"scope": 0}),
> (m2, test_if2, 0, {"scope": 0}),
> @@ -87,21 +101,18 @@ if ipv in [ 'ipv4', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - tcp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
> - (m2, test_if2, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts": nperf_opts},
> - baseline = baseline,
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> + tcp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
> + (m2, m2_tif, 0, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -121,21 +132,18 @@ if ipv in [ 'ipv4', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - udp_res_data = netperf((m1, test_if1, 0, {"scope": 0}),
> - (m2, test_if2, 0, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts": nperf_opts},
> - baseline = baseline,
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts
> +
> + udp_res_data = netperf((m1, m1_tif, 0, {"scope": 0}),
> + (m2, m2_tif, 0, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> @@ -160,21 +168,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_tcp.add_tag("multithreaded")
> result_tcp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_tcp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - tcp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
> - (m2, test_if2, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"TCP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" : nperf_opts +
" -6"},
> - baseline = baseline,
> + client_opts["testname"] = "TCP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> + tcp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
> + (h2, h2_nic, 1, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_tcp, tcp_res_data)
> @@ -194,21 +199,18 @@ if ipv in [ 'ipv6', 'both' ]:
> result_udp.add_tag("multithreaded")
> result_udp.set_parameter('num_parallel', nperf_num_parallel)
>
> + if nperf_msg_size is not None:
> + result_udp.set_parameter("nperf_msg_size", nperf_msg_size)
> +
> baseline = perf_api.get_baseline_of_result(result_udp)
> baseline = perfrepo_baseline_to_dict(baseline)
>
> - udp_res_data = netperf((m1, test_if1, 1, {"scope": 0}),
> - (m2, test_if2, 1, {"scope": 0}),
> - client_opts={"duration" :
netperf_duration,
> - "testname" :
"UDP_STREAM",
> - "confidence" :
nperf_confidence,
> - "num_parallel" :
nperf_num_parallel,
> - "cpu_util" : nperf_cpu_util,
> - "runs": nperf_max_runs,
> - "debug": nperf_debug,
> - "max_deviation":
nperf_max_dev,
> - "netperf_opts" : nperf_opts +
"-6"},
> - baseline = baseline,
> + client_opts["testname"] = "UDP_STREAM"
> + client_opts["netperf_opts"] = nperf_opts + "-6"
> +
> + udp_res_data = netperf((h1, h1_nic, 1, {"scope": 0}),
> + (h2, h2_nic, 1, {"scope": 0}),
> + client_opts = client_opts, baseline = baseline,
> timeout = (netperf_duration +
nperf_reserve)*nperf_max_runs)
>
> netperf_result_template(result_udp, udp_res_data)
> --
> 2.9.3
>
2663
days inactive
2663
days old
lnst-developers@lists.fedorahosted.org
2 comments
1 participants
participants (1)
-
Jiri Prochazka