This patch adds new test to our regression_tests phase3. The topology
is the same as in phase1 simple_netperf test.
This test covers performance of ipsec over ethernet. Ping and netperf is run.
Covered are both tunnel and transport mode. All tests are done with esp, ah and
comp options set together. All combinations of cipher and hash functions listed
below are tested. Netperf message size is set to 1400 bytes by default.
ciphers: aes, des, des3_ede, cast5, blowfish, serpent, twofish
hash functions: hmac(md5), sha1, sha256
Signed-off-by: Kamil Jerabek <kjerabek(a)redhat.com>
---
Changes in
v2: * removed whitespaces and static thresholds
Changes in
v3: * default nperf_msg_size set to 16000
* added set mtu to nic
* msg_size added as result parameter to perfrepo
* repaired bad indentation
* default mtu set to 1500
* removed one fragmentation check
---
.../phase3/ipsec_esp_ah_comp.README | 98 ++++
.../regression_tests/phase3/ipsec_esp_ah_comp.py | 568 +++++++++++++++++++++
.../regression_tests/phase3/ipsec_esp_ah_comp.xml | 50 ++
3 files changed, 716 insertions(+)
create mode 100644 recipes/regression_tests/phase3/ipsec_esp_ah_comp.README
create mode 100644 recipes/regression_tests/phase3/ipsec_esp_ah_comp.py
create mode 100644 recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml
diff --git a/recipes/regression_tests/phase3/ipsec_esp_ah_comp.README b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.README
new file mode 100644
index 0000000..5246c33
--- /dev/null
+++ b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.README
@@ -0,0 +1,98 @@
+Topology:
+
+ switch
+ +------+
+ | |
+ | |
+ +-------------+ +-------------+
+ | | | |
+ | | | |
+ | +------+ |
+ | |
+ | |
+ +-+--+ +-+--+
++-------|eth1|------+ +-------|eth1|------+
+| +-+--+ | | +-+--+ |
+| | | |
+| | | |
+| | | |
+| | | |
+| | | |
+| host1 | | host2 |
+| | | |
+| | | |
+| | | |
++-------------------+ +-------------------+
+
+Number of hosts: 2
+Host #1 description:
+ One ethernet device configured with ip addresses:
+ 192.168.99.1/24
+ fc00:1::1/64
+
+Host #2 description:
+ One ethernet device configured with ip addresses:
+ 192.168.100.1/24
+ fc00:2::1/64
+
+Test name:
+ ipsec_esp_ah_comp.py
+Test description:
+ Ping:
+ + count: 10
+ + interval: 0.1s
+ + between ipsec encrypted ethernet interfaces expecting PASS
+ Ping6:
+ + count: 10
+ + interval: 0.1s
+ + between ipsec encrypted ethernet interfaces expecting PASS
+ Netperf:
+ + duration: 60s
+ + TCP_STREAM and UDP_STREAM
+ + ipv4 and ipv6
+ + between ipsec encrypted ethernet interfaces
+ IPsec
+ + tested with esp, ah, comp options together
+ + tested with all listed ciphers and hash functions
+ + ciphers
+ + aes
+ + des
+ + des3_ede
+ + cast5
+ + blowfish
+ + serpent
+ + twofish
+ + hash functions
+ + hmac(md5)
+ + sha1
+ + sha256
+
+PerfRepo integration:
+ First, preparation in PerfRepo is required - you need to create Test objects
+ through the web interface that properly describe the individual Netperf
+ tests that this recipe runs. Don't forget to also add appropriate metrics.
+ For these Netperf tests it's always:
+ * throughput
+ * throughput_min
+ * throughput_max
+ * throughput_deviation
+
+ After that, to enable support for PerfRepo you need to create the file
+ vxlan_remote.mapping and define the following id mappings:
+ tcp_ipv4_id -> to store ipv4 TCP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+ tcp_ipv6_id -> to store ipv6 TCP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+ udp_ipv4_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+ udp_ipv6_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+
+ To enable result comparison agains baselines you need to create a Report in
+ PerfRepo that will store the baseline. Set up the Report to only contain results
+ with the same hash tag and then add a new mapping to the mapping file, with
+ this format:
+ <some_hash> = <report_id>
+
+ The hash value is automatically generated during test execution and added
+ to each result stored in PerfRepo. To get the Report id you need to open
+ that report in our browser and find if in the URL.
+
+ When running this recipe you should also define the 'product_name' alias
+ (e.g. RHEL7) in order to tag the result object in PerfRepo.
diff --git a/recipes/regression_tests/phase3/ipsec_esp_ah_comp.py b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.py
new file mode 100644
index 0000000..9513ef4
--- /dev/null
+++ b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.py
@@ -0,0 +1,568 @@
+from lnst.Controller.Task import ctl
+from lnst.Controller.PerfRepoUtils import perfrepo_baseline_to_dict
+from lnst.Controller.PerfRepoUtils import netperf_result_template
+
+from lnst.RecipeCommon.ModuleWrap import ping, ping6, netperf
+from lnst.RecipeCommon.IRQ import pin_dev_irqs
+from lnst.RecipeCommon.PerfRepo import generate_perfrepo_comment
+import re
+
+# ---------------------------
+# ALGORITHM AND CIPHER CONFIG
+# ---------------------------
+
+ciphers = {}
+
+def generate_key(length):
+ key = "0x"
+ key = key + length * "0b"
+ return key
+
+ciphers['aes'] = generate_key(16)
+ciphers['des'] = generate_key(8)
+ciphers['des3_ede'] = generate_key(24)
+ciphers['cast5'] = generate_key(16)
+ciphers['blowfish'] = generate_key(56)
+ciphers['serpent'] = generate_key(32)
+ciphers['twofish'] = generate_key(16)
+
+hashes = {}
+
+hashes['hmac(md5)'] = generate_key(16)
+hashes['sha1'] = generate_key(16)
+hashes['sha256'] = generate_key(16)
+
+# these does not work on RHEL6.6
+#hashes['sha384'] = generate_key(16)
+#hashes['sha512'] = generate_key(16)
+
+# ------
+# SETUP
+# ------
+
+mapping_file = ctl.get_alias("mapping_file")
+perf_api = ctl.connect_PerfRepo(mapping_file)
+
+product_name = ctl.get_alias("product_name")
+
+m1 = ctl.get_host("machine1")
+m2 = ctl.get_host("machine2")
+
+m1.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf", "Custom"])
+m2.sync_resources(modules=["PacketAssert", "IcmpPing", "Icmp6Ping", "Netperf"])
+
+# ------
+# TESTS
+# ------
+
+ipv = ctl.get_alias("ipv")
+mtu = ctl.get_alias("mtu")
+netperf_duration = int(ctl.get_alias("netperf_duration"))
+nperf_reserve = int(ctl.get_alias("nperf_reserve"))
+nperf_confidence = ctl.get_alias("nperf_confidence")
+nperf_max_runs = int(ctl.get_alias("nperf_max_runs"))
+nperf_cpupin = ctl.get_alias("nperf_cpupin")
+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")
+ipsec_mode = ctl.get_alias("ipsec_mode")
+
+pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
+
+m1_if = m1.get_interface("eth")
+m2_if = m2.get_interface("eth")
+
+m1_if_name = m1_if.get_devname()
+m2_if_name = m2_if.get_devname()
+
+m1_if_addr = m1_if.get_ip()
+m2_if_addr = m2_if.get_ip()
+
+m1_if_addr6 = m1_if.get_ip(1)
+m2_if_addr6 = m2_if.get_ip(1)
+
+
+# add routing rulez ipv4
+# so the rtr knows where to send traffic destined to remote site
+m1.run("ip route add %s dev %s" % (m2_if_addr, m1_if_name))
+
+# so the rtr knows where to send traffic destined to remote site
+m2.run("ip route add %s dev %s" % (m1_if_addr, m2_if_name))
+
+# add routing rulez ipv6
+# so the rtr knows where to send traffic destined to remote site
+m1.run("ip route add %s dev %s" % (m2_if_addr6, m1_if_name))
+
+# so the rtr knows where to send traffic destined to remote site
+m2.run("ip route add %s dev %s" % (m1_if_addr6, m2_if_name))
+
+if nperf_msg_size is None:
+ nperf_msg_size = 1400
+
+if ipsec_mode is None:
+ ipsec_mode = "transport"
+
+res = m1.run("rpm -qa iproute", save_output=True)
+if (res.get_result()["res_data"]["stdout"].find("iproute-2") != -1):
+ m1_key="0x"
+else:
+ m1_key=""
+
+res = m2.run("rpm -qa iproute", save_output=True)
+if (res.get_result()["res_data"]["stdout"].find("iproute-2") != -1):
+ m2_key="0x"
+else:
+ m2_key=""
+
+if nperf_cpupin:
+ m1.run("service irqbalance stop")
+ m2.run("service irqbalance stop")
+
+ dev_list = [(m1, m1_phy), (m2, m2_phy)]
+
+ # this will pin devices irqs to cpu #0
+ for m, d in dev_list:
+ pin_dev_irqs(m, d, 0)
+
+nperf_opts = ""
+if nperf_cpupin and nperf_num_parallel == 1:
+ nperf_opts = " -T%s,%s" % (nperf_cpupin, nperf_cpupin)
+
+ctl.wait(15)
+
+def configure_ipsec(ciph_alg, ciph_key, hash_alg, hash_key, ip_version):
+ if ip_version == "ipv4":
+ m1_addr = m1_if_addr
+ m2_addr = m2_if_addr
+ else:
+ m1_addr = m1_if_addr6
+ m2_addr = m2_if_addr6
+
+ # configure policy and state
+ m1.run("ip xfrm policy flush")
+ m1.run("ip xfrm state flush")
+ m2.run("ip xfrm policy flush")
+ m2.run("ip xfrm state flush")
+
+ m1.run("ip xfrm policy add src %s dst %s dir out "\
+ "tmpl src %s dst %s proto comp spi 4 mode %s "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m1_addr, m2_addr,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode))
+ m1.run("ip xfrm policy add src %s dst %s dir in "\
+ "tmpl src %s dst %s proto comp spi 1 mode %s level use "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m2_addr, m1_addr,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode))
+
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 4 mode %s "\
+ "comp deflate"\
+ % (m1_addr, m2_addr, ipsec_mode))
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 1 mode %s "\
+ "comp deflate"\
+ % (m2_addr, m1_addr, ipsec_mode))
+
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m1_addr, m2_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m2_addr, m1_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"
+ % (m1_addr, m2_addr, ipsec_mode,
+ hash_alg, hash_key))
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"
+ % (m2_addr, m1_addr, ipsec_mode,
+ hash_alg, hash_key))
+
+
+ # second machine
+ m2.run("ip xfrm policy add src %s dst %s dir out "\
+ "tmpl src %s dst %s proto comp spi 1 mode %s "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m2_addr, m1_addr,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode))
+ m2.run("ip xfrm policy add src %s dst %s dir in "\
+ "tmpl src %s dst %s proto comp spi 4 mode %s level use "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m1_addr, m2_addr,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode))
+
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 4 mode %s "\
+ "comp deflate"\
+ % (m1_addr, m2_addr, ipsec_mode))
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 1 mode %s "\
+ "comp deflate"\
+ % (m2_addr, m1_addr, ipsec_mode))
+
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m1_addr, m2_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m2_addr, m1_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"\
+ % (m1_addr, m2_addr, ipsec_mode,
+ hash_alg, hash_key))
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"\
+ % (m2_addr, m1_addr, ipsec_mode,
+ hash_alg, hash_key))
+
+
+for ciph_alg, ciph_key in ciphers.iteritems():
+ for hash_alg, hash_key in hashes.iteritems():
+ if ipv in [ 'ipv4', 'both']:
+ configure_ipsec(ciph_alg, ciph_key, hash_alg, hash_key, "ipv4")
+ # ------
+ # TESTS
+ # ------
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ # ping + PacketAssert
+ assert_mod = ctl.get_module("PacketAssert",
+ options={
+ "interface": m2_if_name,
+ "filter": "ah",
+ "grep_for": [ "AH\(spi=0x00000003",
+ "ESP\(spi=0x00000002" ],
+ "min": 10
+ })
+
+ assert_proc = m2.run(assert_mod, bg=True)
+
+ ping_mod = ctl.get_module("IcmpPing",
+ options={
+ "addr": m2_if_addr,
+ "count": 10,
+ "interval": 0.1})
+
+ ctl.wait(2)
+
+ m1.run(ping_mod)
+
+ ctl.wait(2)
+
+ assert_proc.intr()
+
+ dump.intr()
+
+ m1.run("ip -s xfrm pol")
+ m1.run("ip -s xfrm state")
+
+ # ping test with bigger size to check compression is used
+ pkt_capture = m2.run("tcpdump -i %s ah" % m2_if_name,
+ save_output=True,
+ bg=True)
+ ctl.wait(3)
+ ping_mod.update_options({ "size": int(mtu) - 28 })
+ ping_mod.update_options({ "count": 1 })
+ m1.run(ping_mod)
+ ctl.wait(3)
+
+ pkt_capture.intr()
+
+ stdout = pkt_capture.get_result()["res_data"]["stdout"]
+
+ small_ping_fail=0
+ re_length = ".*length ([0-9]*)"
+ m = re.match(re_length, stdout)
+ if m:
+ pkt_len = int(m.group(1))
+ if pkt_len > (int(mtu) - 28)/2:
+ # failed
+ small_ping_fail=1
+ else:
+ small_ping_fail=1
+
+ comp_mod = ctl.get_module("Custom")
+ if small_ping_fail != 0:
+ comp_mod.update_options({ "fail": "Check of compression for bigger packets failed" })
+ else:
+ comp_mod.update_options({ "passed": "Check of compression for bigger packets passed" })
+
+ m1.run(comp_mod)
+
+ # fragmentation of packets bigger than mtu
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ ping_mod.update_options({ "size": 2*int(mtu) })
+ ping_mod.update_options({ "count": 10 })
+
+ m1.run(ping_mod)
+ dump.intr()
+
+ # 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('cipher_alg', ciph_alg)
+ result_tcp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+
+ tcp_res_data = netperf((m1, m1_if, 0, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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('cipher_alg', ciph_alg)
+ result_udp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, m1_if, 0, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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']:
+ configure_ipsec(ciph_alg, ciph_key, hash_alg, hash_key, "ipv6")
+ # ------
+ # TESTS
+ # ------
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ # ping + PacketAssert
+ assert_mod = ctl.get_module("PacketAssert",
+ options={
+ "interface": m2_if_name,
+ "filter": "ah",
+ "grep_for": [ "AH\(spi=0x00000003",
+ "ESP\(spi=0x00000002" ],
+ "min": 10
+ })
+
+ assert_proc = m2.run(assert_mod, bg=True)
+
+ ping_mod = ctl.get_module("Icmp6Ping",
+ options={
+ "addr": m2_if_addr6,
+ "count": 10,
+ "interval": 0.1})
+
+ ctl.wait(2)
+
+ m1.run(ping_mod)
+
+ ctl.wait(2)
+
+ assert_proc.intr()
+
+ dump.intr()
+
+ m1.run("ip -s xfrm pol")
+ m1.run("ip -s xfrm state")
+
+ # ping test with bigger size to check compression is used
+ pkt_capture = m2.run("tcpdump -i %s ah" % m2_if_name,
+ save_output=True,
+ bg=True)
+ ctl.wait(3)
+ ping_mod.update_options({ "size": int(mtu) - 28 })
+ ping_mod.update_options({ "count": 1 })
+ m1.run(ping_mod)
+ ctl.wait(3)
+
+ pkt_capture.intr()
+
+ stdout = pkt_capture.get_result()["res_data"]["stdout"]
+
+ small_ping_fail=0
+ re_length = ".*length ([0-9]*)"
+ m = re.match(re_length, stdout)
+ if m:
+ pkt_len = int(m.group(1))
+ if pkt_len > (int(mtu) - 28)/2:
+ # failed
+ small_ping_fail=1
+ else:
+ small_ping_fail=1
+
+ comp_mod = ctl.get_module("Custom")
+ if small_ping_fail != 0:
+ comp_mod.update_options({ "fail": "Check of compression for bigger packets failed" })
+ else:
+ comp_mod.update_options({ "passed": "Check of compression for bigger packets passed" })
+
+ m1.run(comp_mod)
+
+ # fragmentation of packets bigger than mtu
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ ping_mod.update_options({ "size": 2*int(mtu) })
+ ping_mod.update_options({ "count": 10 })
+
+ m1.run(ping_mod)
+ dump.intr()
+
+ # prepare PerfRepo result for tcp
+ 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('cipher_alg', ciph_alg)
+ result_tcp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+
+ tcp_res_data = netperf((m1, m1_if, 1, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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
+ 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('cipher_alg', ciph_alg)
+ result_udp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, m1_if, 1, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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 xfrm policy flush")
+m1.run("ip xfrm state flush")
+m2.run("ip xfrm policy flush")
+m2.run("ip xfrm state flush")
+
+if nperf_cpupin:
+ m1.run("service irqbalance start")
+ m2.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml
new file mode 100644
index 0000000..c7c8e68
--- /dev/null
+++ b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml
@@ -0,0 +1,50 @@
+<lnstrecipe>
+ <define>
+ <alias name="ipv" value="both" />
+ <alias name="mtu" value="1450" />
+ <alias name="netperf_duration" value="60" />
+ <alias name="nperf_reserve" value="20" />
+ <alias name="nperf_confidence" value="99,5" />
+ <alias name="nperf_max_runs" value="5"/>
+ <alias name="nperf_num_parallel" value="1"/>
+ <alias name="nperf_debug" value="0"/>
+ <alias name="nperf_max_dev" value="20%"/>
+ <alias name="mapping_file" value="ipsec_transport_esp_ah_comp.mapping"/>
+ <alias name="net_1" value="192.168.99"/>
+ <alias name="net6_1" value="fc00:1::"/>
+ <alias name="net_2" value="192.168.100"/>
+ <alias name="net6_2" value="fc00:2::"/>
+ <alias name="driver" value=""/>
+ </define>
+ <network>
+ <host id="machine1">
+ <interfaces>
+ <eth id="eth" label="localnet">
+ <params>
+ <param name="driver" value="{$driver}"/>
+ </params>
+ <addresses>
+ <address value="{$net_1}.1/24"/>
+ <address value="{$net6_1}1/64"/>
+ </addresses>
+ </eth>
+ </interfaces>
+ </host>
+ <host id="machine2">
+ <interfaces>
+ <eth id="eth" label="localnet">
+ <params>
+ <param name="driver" value="{$driver}"/>
+ </params>
+ <addresses>
+ <address value="{$net_2}.1/24"/>
+ <address value="{$net6_2}1/64"/>
+ </addresses>
+ </eth>
+ </interfaces>
+ </host>
+ </network>
+
+ <task python="ipsec_esp_ah_comp.py"/>
+
+</lnstrecipe>
--
2.5.5
1
0
Dear Customer,
Your parcel was successfully delivered January 10 to USPS Station, but our courier cound not contact you.
Please check delivery label attached!
Yours truly,
John Massey,
USPS Support Clerk.
1
0
12 Jan '17
From: Ondrej Lichtner <olichtne(a)redhat.com>
The HostAPI class should ignore unused interfaces (specified in slave
config but not matched to the current recipe run), unfortunatelly the
code assumed that these have a None id. This is incorrect as they get a
generated id in the form of "gen_%s_%d".
To fix this we should ignore interface objects that are instances of the
UnusedInterface class.
v2: inverted the condition
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
lnst/Controller/Task.py | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/lnst/Controller/Task.py b/lnst/Controller/Task.py
index e91409e..4f4a772 100644
--- a/lnst/Controller/Task.py
+++ b/lnst/Controller/Task.py
@@ -19,6 +19,7 @@ from lnst.Controller.XmlTemplates import XmlTemplateError
from lnst.Common.Path import Path
from lnst.Controller.PerfRepoMapping import PerfRepoMapping
from lnst.Common.Utils import Noop
+from lnst.Controller.Machine import UnusedInterface
try:
from perfrepo import PerfRepoRESTAPI
@@ -192,7 +193,7 @@ class HostAPI(object):
self._ifaces = {}
for interface in self._m.get_interfaces():
- if interface.get_id() is None:
+ if isinstance(interface, UnusedInterface):
continue
self._ifaces[interface.get_id()] = InterfaceAPI(interface, self)
--
2.11.0
2
1
extends omni output of netperf with these selectors:
LOCAL_SEND_THROUGHPUT - how many bytes were sent from client
REMOTE_RECV_THROUGHPUT - how many bytes were received on server
LOCAL_CPU_PEAK_UTIL - what was the highest percentage of CPU utilization
during the test on client
REMOTE_CPU_PEAK_UTIL - what was the highest percentage of CPU
utilization during the test on server
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
test_modules/Netperf.py | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/test_modules/Netperf.py b/test_modules/Netperf.py
index b01e460..5a0e989 100644
--- a/test_modules/Netperf.py
+++ b/test_modules/Netperf.py
@@ -134,7 +134,11 @@ class Netperf(TestGeneric):
# Print only relevant output
if self._is_omni():
- cmd += ' -- -k "THROUGHPUT, LOCAL_CPU_UTIL, REMOTE_CPU_UTIL, CONFIDENCE_LEVEL, THROUGHPUT_CONFID, LOCAL_SEND_SIZE, REMOTE_RECV_SIZE"'
+ cmd += ' -- -k "THROUGHPUT, LOCAL_CPU_UTIL, REMOTE_CPU_UTIL, '\
+ 'CONFIDENCE_LEVEL, THROUGHPUT_CONFID, LOCAL_SEND_SIZE, '\
+ 'REMOTE_RECV_SIZE, LOCAL_SEND_THROUGHPUT, '\
+ 'REMOTE_RECV_THROUGHPUT, LOCAL_CPU_PEAK_UTIL, '\
+ 'REMOTE_CPU_PEAK_UTIL"'
if self._testoptions:
if self._is_omni():
--
2.9.3
2
2
A typo caused that SCTP netperf mesurements were not compared to baselines.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 2 +-
recipes/regression_tests/phase1/3_vlans_over_bond.py | 2 +-
recipes/regression_tests/phase1/bonding_test.py | 2 +-
recipes/regression_tests/phase1/simple_netperf.py | 2 +-
recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py | 2 +-
recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py | 2 +-
recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py | 2 +-
recipes/regression_tests/phase2/3_vlans_over_team.py | 2 +-
recipes/regression_tests/phase2/team_test.py | 4 ++--
.../phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py | 2 +-
recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py | 2 +-
recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py | 2 +-
12 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index 0acff75..1d2cee8 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -442,7 +442,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index a9705c0..49f35a9 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -442,7 +442,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index 711d6ae..e293a79 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -421,7 +421,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index 255341b..7e30955 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -379,7 +379,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
index 952eca5..265d038 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
@@ -505,7 +505,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = g3.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
index 4cf725b..81e2cb9 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -434,7 +434,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
index 8306c99..c7cb984 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -434,7 +434,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index 5e5af9f..89af6a0 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -442,7 +442,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index 027de98..db327b3 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -433,7 +433,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
@@ -676,7 +676,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = m1.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
index 6d6743f..3c1fd39 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
@@ -508,7 +508,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = g3.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
index 3eaf75c..36f48a8 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
@@ -438,7 +438,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
index 8af2f57..1d473c7 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
@@ -436,7 +436,7 @@ for setting in offload_settings:
result_sctp.set_parameter("num_parallel", nperf_num_parallel)
baseline = perf_api.get_baseline_of_result(result_sctp)
- netperf_baseline_template(netperf_cli_sctp, baseline)
+ netperf_baseline_template(netperf_cli_sctp6, baseline)
sctp_res_data = h2.run(netperf_cli_sctp6,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
--
2.7.4
1
1
From: Ondrej Lichtner <olichtne(a)redhat.com>
The HostAPI class should ignore unused interfaces (specified in slave
config but not matched to the current recipe run), unfortunatelly the
code assumed that these have a None id. This is incorrect as they get a
generated id in the form of "gen_%s_%d".
To fix this we should ignore interface objects that are instances of the
UnusedInterface class.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
lnst/Controller/Task.py | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/lnst/Controller/Task.py b/lnst/Controller/Task.py
index e91409e..8121746 100644
--- a/lnst/Controller/Task.py
+++ b/lnst/Controller/Task.py
@@ -19,6 +19,7 @@ from lnst.Controller.XmlTemplates import XmlTemplateError
from lnst.Common.Path import Path
from lnst.Controller.PerfRepoMapping import PerfRepoMapping
from lnst.Common.Utils import Noop
+from lnst.Controller.Machine import UnusedInterface
try:
from perfrepo import PerfRepoRESTAPI
@@ -192,7 +193,7 @@ class HostAPI(object):
self._ifaces = {}
for interface in self._m.get_interfaces():
- if interface.get_id() is None:
+ if not isinstance(interface, UnusedInterface):
continue
self._ifaces[interface.get_id()] = InterfaceAPI(interface, self)
--
2.11.0
2
1
This patch adds new test to our regression_tests phase3. The topology
is the same as in phase1 simple_netperf test.
This test covers performance of ipsec over ethernet. Ping and netperf is run.
Covered are both tunnel and transport mode. All tests are done with esp, ah and
comp options set together. All combinations of cipher and hash functions listed
below are tested. Netperf message size is set to 1400 bytes by default.
ciphers: aes, des, des3_ede, cast5, blowfish, serpent, twofish
hash functions: hmac(md5), sha1, sha256
Signed-off-by: Kamil Jerabek <kjerabek(a)redhat.com>
---
Changes in
v2: * removed whitespaces and static thresholds
---
.../phase3/ipsec_esp_ah_comp.README | 98 ++++
.../regression_tests/phase3/ipsec_esp_ah_comp.py | 568 +++++++++++++++++++++
.../regression_tests/phase3/ipsec_esp_ah_comp.xml | 50 ++
3 files changed, 716 insertions(+)
create mode 100644 recipes/regression_tests/phase3/ipsec_esp_ah_comp.README
create mode 100644 recipes/regression_tests/phase3/ipsec_esp_ah_comp.py
create mode 100644 recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml
diff --git a/recipes/regression_tests/phase3/ipsec_esp_ah_comp.README b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.README
new file mode 100644
index 0000000..5246c33
--- /dev/null
+++ b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.README
@@ -0,0 +1,98 @@
+Topology:
+
+ switch
+ +------+
+ | |
+ | |
+ +-------------+ +-------------+
+ | | | |
+ | | | |
+ | +------+ |
+ | |
+ | |
+ +-+--+ +-+--+
++-------|eth1|------+ +-------|eth1|------+
+| +-+--+ | | +-+--+ |
+| | | |
+| | | |
+| | | |
+| | | |
+| | | |
+| host1 | | host2 |
+| | | |
+| | | |
+| | | |
++-------------------+ +-------------------+
+
+Number of hosts: 2
+Host #1 description:
+ One ethernet device configured with ip addresses:
+ 192.168.99.1/24
+ fc00:1::1/64
+
+Host #2 description:
+ One ethernet device configured with ip addresses:
+ 192.168.100.1/24
+ fc00:2::1/64
+
+Test name:
+ ipsec_esp_ah_comp.py
+Test description:
+ Ping:
+ + count: 10
+ + interval: 0.1s
+ + between ipsec encrypted ethernet interfaces expecting PASS
+ Ping6:
+ + count: 10
+ + interval: 0.1s
+ + between ipsec encrypted ethernet interfaces expecting PASS
+ Netperf:
+ + duration: 60s
+ + TCP_STREAM and UDP_STREAM
+ + ipv4 and ipv6
+ + between ipsec encrypted ethernet interfaces
+ IPsec
+ + tested with esp, ah, comp options together
+ + tested with all listed ciphers and hash functions
+ + ciphers
+ + aes
+ + des
+ + des3_ede
+ + cast5
+ + blowfish
+ + serpent
+ + twofish
+ + hash functions
+ + hmac(md5)
+ + sha1
+ + sha256
+
+PerfRepo integration:
+ First, preparation in PerfRepo is required - you need to create Test objects
+ through the web interface that properly describe the individual Netperf
+ tests that this recipe runs. Don't forget to also add appropriate metrics.
+ For these Netperf tests it's always:
+ * throughput
+ * throughput_min
+ * throughput_max
+ * throughput_deviation
+
+ After that, to enable support for PerfRepo you need to create the file
+ vxlan_remote.mapping and define the following id mappings:
+ tcp_ipv4_id -> to store ipv4 TCP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+ tcp_ipv6_id -> to store ipv6 TCP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+ udp_ipv4_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+ udp_ipv6_id -> to store ipv4 UDP_STREAM Netperf test results, maps to TestUid of a PerfRepo Test object
+
+ To enable result comparison agains baselines you need to create a Report in
+ PerfRepo that will store the baseline. Set up the Report to only contain results
+ with the same hash tag and then add a new mapping to the mapping file, with
+ this format:
+ <some_hash> = <report_id>
+
+ The hash value is automatically generated during test execution and added
+ to each result stored in PerfRepo. To get the Report id you need to open
+ that report in our browser and find if in the URL.
+
+ When running this recipe you should also define the 'product_name' alias
+ (e.g. RHEL7) in order to tag the result object in PerfRepo.
diff --git a/recipes/regression_tests/phase3/ipsec_esp_ah_comp.py b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.py
new file mode 100644
index 0000000..9513ef4
--- /dev/null
+++ b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.py
@@ -0,0 +1,568 @@
+from lnst.Controller.Task import ctl
+from lnst.Controller.PerfRepoUtils import perfrepo_baseline_to_dict
+from lnst.Controller.PerfRepoUtils import netperf_result_template
+
+from lnst.RecipeCommon.ModuleWrap import ping, ping6, netperf
+from lnst.RecipeCommon.IRQ import pin_dev_irqs
+from lnst.RecipeCommon.PerfRepo import generate_perfrepo_comment
+import re
+
+# ---------------------------
+# ALGORITHM AND CIPHER CONFIG
+# ---------------------------
+
+ciphers = {}
+
+def generate_key(length):
+ key = "0x"
+ key = key + length * "0b"
+ return key
+
+ciphers['aes'] = generate_key(16)
+ciphers['des'] = generate_key(8)
+ciphers['des3_ede'] = generate_key(24)
+ciphers['cast5'] = generate_key(16)
+ciphers['blowfish'] = generate_key(56)
+ciphers['serpent'] = generate_key(32)
+ciphers['twofish'] = generate_key(16)
+
+hashes = {}
+
+hashes['hmac(md5)'] = generate_key(16)
+hashes['sha1'] = generate_key(16)
+hashes['sha256'] = generate_key(16)
+
+# these does not work on RHEL6.6
+#hashes['sha384'] = generate_key(16)
+#hashes['sha512'] = generate_key(16)
+
+# ------
+# SETUP
+# ------
+
+mapping_file = ctl.get_alias("mapping_file")
+perf_api = ctl.connect_PerfRepo(mapping_file)
+
+product_name = ctl.get_alias("product_name")
+
+m1 = ctl.get_host("machine1")
+m2 = ctl.get_host("machine2")
+
+m1.sync_resources(modules=["IcmpPing", "Icmp6Ping", "Netperf", "Custom"])
+m2.sync_resources(modules=["PacketAssert", "IcmpPing", "Icmp6Ping", "Netperf"])
+
+# ------
+# TESTS
+# ------
+
+ipv = ctl.get_alias("ipv")
+mtu = ctl.get_alias("mtu")
+netperf_duration = int(ctl.get_alias("netperf_duration"))
+nperf_reserve = int(ctl.get_alias("nperf_reserve"))
+nperf_confidence = ctl.get_alias("nperf_confidence")
+nperf_max_runs = int(ctl.get_alias("nperf_max_runs"))
+nperf_cpupin = ctl.get_alias("nperf_cpupin")
+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")
+ipsec_mode = ctl.get_alias("ipsec_mode")
+
+pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
+
+m1_if = m1.get_interface("eth")
+m2_if = m2.get_interface("eth")
+
+m1_if_name = m1_if.get_devname()
+m2_if_name = m2_if.get_devname()
+
+m1_if_addr = m1_if.get_ip()
+m2_if_addr = m2_if.get_ip()
+
+m1_if_addr6 = m1_if.get_ip(1)
+m2_if_addr6 = m2_if.get_ip(1)
+
+
+# add routing rulez ipv4
+# so the rtr knows where to send traffic destined to remote site
+m1.run("ip route add %s dev %s" % (m2_if_addr, m1_if_name))
+
+# so the rtr knows where to send traffic destined to remote site
+m2.run("ip route add %s dev %s" % (m1_if_addr, m2_if_name))
+
+# add routing rulez ipv6
+# so the rtr knows where to send traffic destined to remote site
+m1.run("ip route add %s dev %s" % (m2_if_addr6, m1_if_name))
+
+# so the rtr knows where to send traffic destined to remote site
+m2.run("ip route add %s dev %s" % (m1_if_addr6, m2_if_name))
+
+if nperf_msg_size is None:
+ nperf_msg_size = 1400
+
+if ipsec_mode is None:
+ ipsec_mode = "transport"
+
+res = m1.run("rpm -qa iproute", save_output=True)
+if (res.get_result()["res_data"]["stdout"].find("iproute-2") != -1):
+ m1_key="0x"
+else:
+ m1_key=""
+
+res = m2.run("rpm -qa iproute", save_output=True)
+if (res.get_result()["res_data"]["stdout"].find("iproute-2") != -1):
+ m2_key="0x"
+else:
+ m2_key=""
+
+if nperf_cpupin:
+ m1.run("service irqbalance stop")
+ m2.run("service irqbalance stop")
+
+ dev_list = [(m1, m1_phy), (m2, m2_phy)]
+
+ # this will pin devices irqs to cpu #0
+ for m, d in dev_list:
+ pin_dev_irqs(m, d, 0)
+
+nperf_opts = ""
+if nperf_cpupin and nperf_num_parallel == 1:
+ nperf_opts = " -T%s,%s" % (nperf_cpupin, nperf_cpupin)
+
+ctl.wait(15)
+
+def configure_ipsec(ciph_alg, ciph_key, hash_alg, hash_key, ip_version):
+ if ip_version == "ipv4":
+ m1_addr = m1_if_addr
+ m2_addr = m2_if_addr
+ else:
+ m1_addr = m1_if_addr6
+ m2_addr = m2_if_addr6
+
+ # configure policy and state
+ m1.run("ip xfrm policy flush")
+ m1.run("ip xfrm state flush")
+ m2.run("ip xfrm policy flush")
+ m2.run("ip xfrm state flush")
+
+ m1.run("ip xfrm policy add src %s dst %s dir out "\
+ "tmpl src %s dst %s proto comp spi 4 mode %s "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m1_addr, m2_addr,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode))
+ m1.run("ip xfrm policy add src %s dst %s dir in "\
+ "tmpl src %s dst %s proto comp spi 1 mode %s level use "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m2_addr, m1_addr,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode))
+
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 4 mode %s "\
+ "comp deflate"\
+ % (m1_addr, m2_addr, ipsec_mode))
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 1 mode %s "\
+ "comp deflate"\
+ % (m2_addr, m1_addr, ipsec_mode))
+
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m1_addr, m2_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m2_addr, m1_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"
+ % (m1_addr, m2_addr, ipsec_mode,
+ hash_alg, hash_key))
+ m1.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"
+ % (m2_addr, m1_addr, ipsec_mode,
+ hash_alg, hash_key))
+
+
+ # second machine
+ m2.run("ip xfrm policy add src %s dst %s dir out "\
+ "tmpl src %s dst %s proto comp spi 1 mode %s "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m2_addr, m1_addr,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode,
+ m2_addr, m1_addr, ipsec_mode))
+ m2.run("ip xfrm policy add src %s dst %s dir in "\
+ "tmpl src %s dst %s proto comp spi 4 mode %s level use "\
+ "tmpl src %s dst %s proto esp spi 2 mode %s "\
+ "tmpl src %s dst %s proto ah spi 3 mode %s"
+ % (m1_addr, m2_addr,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode,
+ m1_addr, m2_addr, ipsec_mode))
+
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 4 mode %s "\
+ "comp deflate"\
+ % (m1_addr, m2_addr, ipsec_mode))
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto comp spi 1 mode %s "\
+ "comp deflate"\
+ % (m2_addr, m1_addr, ipsec_mode))
+
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m1_addr, m2_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto esp spi 2 mode %s "\
+ "enc '%s' %s"\
+ % (m2_addr, m1_addr, ipsec_mode,
+ ciph_alg, ciph_key))
+
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"\
+ % (m1_addr, m2_addr, ipsec_mode,
+ hash_alg, hash_key))
+ m2.run("ip xfrm state add "\
+ "src %s dst %s proto ah spi 3 mode %s "\
+ "auth '%s' %s"\
+ % (m2_addr, m1_addr, ipsec_mode,
+ hash_alg, hash_key))
+
+
+for ciph_alg, ciph_key in ciphers.iteritems():
+ for hash_alg, hash_key in hashes.iteritems():
+ if ipv in [ 'ipv4', 'both']:
+ configure_ipsec(ciph_alg, ciph_key, hash_alg, hash_key, "ipv4")
+ # ------
+ # TESTS
+ # ------
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ # ping + PacketAssert
+ assert_mod = ctl.get_module("PacketAssert",
+ options={
+ "interface": m2_if_name,
+ "filter": "ah",
+ "grep_for": [ "AH\(spi=0x00000003",
+ "ESP\(spi=0x00000002" ],
+ "min": 10
+ })
+
+ assert_proc = m2.run(assert_mod, bg=True)
+
+ ping_mod = ctl.get_module("IcmpPing",
+ options={
+ "addr": m2_if_addr,
+ "count": 10,
+ "interval": 0.1})
+
+ ctl.wait(2)
+
+ m1.run(ping_mod)
+
+ ctl.wait(2)
+
+ assert_proc.intr()
+
+ dump.intr()
+
+ m1.run("ip -s xfrm pol")
+ m1.run("ip -s xfrm state")
+
+ # ping test with bigger size to check compression is used
+ pkt_capture = m2.run("tcpdump -i %s ah" % m2_if_name,
+ save_output=True,
+ bg=True)
+ ctl.wait(3)
+ ping_mod.update_options({ "size": int(mtu) - 28 })
+ ping_mod.update_options({ "count": 1 })
+ m1.run(ping_mod)
+ ctl.wait(3)
+
+ pkt_capture.intr()
+
+ stdout = pkt_capture.get_result()["res_data"]["stdout"]
+
+ small_ping_fail=0
+ re_length = ".*length ([0-9]*)"
+ m = re.match(re_length, stdout)
+ if m:
+ pkt_len = int(m.group(1))
+ if pkt_len > (int(mtu) - 28)/2:
+ # failed
+ small_ping_fail=1
+ else:
+ small_ping_fail=1
+
+ comp_mod = ctl.get_module("Custom")
+ if small_ping_fail != 0:
+ comp_mod.update_options({ "fail": "Check of compression for bigger packets failed" })
+ else:
+ comp_mod.update_options({ "passed": "Check of compression for bigger packets passed" })
+
+ m1.run(comp_mod)
+
+ # fragmentation of packets bigger than mtu
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ ping_mod.update_options({ "size": 2*int(mtu) })
+ ping_mod.update_options({ "count": 10 })
+
+ m1.run(ping_mod)
+ dump.intr()
+
+ # 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('cipher_alg', ciph_alg)
+ result_tcp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+
+ tcp_res_data = netperf((m1, m1_if, 0, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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('cipher_alg', ciph_alg)
+ result_udp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, m1_if, 0, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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']:
+ configure_ipsec(ciph_alg, ciph_key, hash_alg, hash_key, "ipv6")
+ # ------
+ # TESTS
+ # ------
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ # ping + PacketAssert
+ assert_mod = ctl.get_module("PacketAssert",
+ options={
+ "interface": m2_if_name,
+ "filter": "ah",
+ "grep_for": [ "AH\(spi=0x00000003",
+ "ESP\(spi=0x00000002" ],
+ "min": 10
+ })
+
+ assert_proc = m2.run(assert_mod, bg=True)
+
+ ping_mod = ctl.get_module("Icmp6Ping",
+ options={
+ "addr": m2_if_addr6,
+ "count": 10,
+ "interval": 0.1})
+
+ ctl.wait(2)
+
+ m1.run(ping_mod)
+
+ ctl.wait(2)
+
+ assert_proc.intr()
+
+ dump.intr()
+
+ m1.run("ip -s xfrm pol")
+ m1.run("ip -s xfrm state")
+
+ # ping test with bigger size to check compression is used
+ pkt_capture = m2.run("tcpdump -i %s ah" % m2_if_name,
+ save_output=True,
+ bg=True)
+ ctl.wait(3)
+ ping_mod.update_options({ "size": int(mtu) - 28 })
+ ping_mod.update_options({ "count": 1 })
+ m1.run(ping_mod)
+ ctl.wait(3)
+
+ pkt_capture.intr()
+
+ stdout = pkt_capture.get_result()["res_data"]["stdout"]
+
+ small_ping_fail=0
+ re_length = ".*length ([0-9]*)"
+ m = re.match(re_length, stdout)
+ if m:
+ pkt_len = int(m.group(1))
+ if pkt_len > (int(mtu) - 28)/2:
+ # failed
+ small_ping_fail=1
+ else:
+ small_ping_fail=1
+
+ comp_mod = ctl.get_module("Custom")
+ if small_ping_fail != 0:
+ comp_mod.update_options({ "fail": "Check of compression for bigger packets failed" })
+ else:
+ comp_mod.update_options({ "passed": "Check of compression for bigger packets passed" })
+
+ m1.run(comp_mod)
+
+ # fragmentation of packets bigger than mtu
+ dump = m1.run("tcpdump -i %s -nn -vv" % m1_if_name, bg=True)
+
+ ping_mod.update_options({ "size": 2*int(mtu) })
+ ping_mod.update_options({ "count": 10 })
+
+ m1.run(ping_mod)
+ dump.intr()
+
+ # prepare PerfRepo result for tcp
+ 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('cipher_alg', ciph_alg)
+ result_tcp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+
+ tcp_res_data = netperf((m1, m1_if, 1, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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
+ 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('cipher_alg', ciph_alg)
+ result_udp.set_parameter('hash_alg', hash_alg)
+
+ baseline = perf_api.get_baseline_of_result(result_udp)
+ baseline = perfrepo_baseline_to_dict(baseline)
+
+ udp_res_data = netperf((m1, m1_if, 1, {"scope": 0}),
+ (m2, m2_if, 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,
+ "msg_size" : nperf_msg_size,
+ "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 xfrm policy flush")
+m1.run("ip xfrm state flush")
+m2.run("ip xfrm policy flush")
+m2.run("ip xfrm state flush")
+
+if nperf_cpupin:
+ m1.run("service irqbalance start")
+ m2.run("service irqbalance start")
diff --git a/recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml
new file mode 100644
index 0000000..c7c8e68
--- /dev/null
+++ b/recipes/regression_tests/phase3/ipsec_esp_ah_comp.xml
@@ -0,0 +1,50 @@
+<lnstrecipe>
+ <define>
+ <alias name="ipv" value="both" />
+ <alias name="mtu" value="1450" />
+ <alias name="netperf_duration" value="60" />
+ <alias name="nperf_reserve" value="20" />
+ <alias name="nperf_confidence" value="99,5" />
+ <alias name="nperf_max_runs" value="5"/>
+ <alias name="nperf_num_parallel" value="1"/>
+ <alias name="nperf_debug" value="0"/>
+ <alias name="nperf_max_dev" value="20%"/>
+ <alias name="mapping_file" value="ipsec_transport_esp_ah_comp.mapping"/>
+ <alias name="net_1" value="192.168.99"/>
+ <alias name="net6_1" value="fc00:1::"/>
+ <alias name="net_2" value="192.168.100"/>
+ <alias name="net6_2" value="fc00:2::"/>
+ <alias name="driver" value=""/>
+ </define>
+ <network>
+ <host id="machine1">
+ <interfaces>
+ <eth id="eth" label="localnet">
+ <params>
+ <param name="driver" value="{$driver}"/>
+ </params>
+ <addresses>
+ <address value="{$net_1}.1/24"/>
+ <address value="{$net6_1}1/64"/>
+ </addresses>
+ </eth>
+ </interfaces>
+ </host>
+ <host id="machine2">
+ <interfaces>
+ <eth id="eth" label="localnet">
+ <params>
+ <param name="driver" value="{$driver}"/>
+ </params>
+ <addresses>
+ <address value="{$net_2}.1/24"/>
+ <address value="{$net6_2}1/64"/>
+ </addresses>
+ </eth>
+ </interfaces>
+ </host>
+ </network>
+
+ <task python="ipsec_esp_ah_comp.py"/>
+
+</lnstrecipe>
--
2.5.5
2
3
[PATCH v3 1/2] regression-tests: add nperf_protocols alias to all phase3 tests
by Jiri Prochazka 12 Jan '17
by Jiri Prochazka 12 Jan '17
12 Jan '17
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
1
1
[PATCH v2 1/2] regression-tests: add nperf_protocols alias to all phase3 tests
by Jiri Prochazka 11 Jan '17
by Jiri Prochazka 11 Jan '17
11 Jan '17
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
1
2
08 Jan '17
Alias nperf_msg_Size was missing in all of phase3 recipes, this patch adds it and
also reduces repeated code a bit - client_opts are defined once and only
updated before every netperf executions.
Signed-off-by: Jiri Prochazka <jprochaz(a)redhat.com>
---
.../regression_tests/phase3/2_virt_ovs_vxlan.py | 80 +++++++++++-----------
.../regression_tests/phase3/novirt_ovs_vxlan.py | 80 +++++++++++-----------
recipes/regression_tests/phase3/simple_macsec.py | 80 +++++++++++-----------
recipes/regression_tests/phase3/vxlan_multicast.py | 80 +++++++++++-----------
recipes/regression_tests/phase3/vxlan_remote.py | 80 +++++++++++-----------
5 files changed, 200 insertions(+), 200 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..cc1a0a8 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")
pr_comment = generate_perfrepo_comment([guest1, guest2, guest3, guest4],
@@ -124,6 +125,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
@@ -142,20 +156,16 @@ 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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -178,20 +188,16 @@ 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"
+
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,
+ client_opts, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -214,20 +220,17 @@ 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,
+ client_opts, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -250,20 +253,17 @@ 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,
+ 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/novirt_ovs_vxlan.py b/recipes/regression_tests/phase3/novirt_ovs_vxlan.py
index 5419ad9..b283543 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")
pr_comment = generate_perfrepo_comment([h1, h2], pr_user_comment)
@@ -73,6 +74,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)
@@ -89,21 +103,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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -122,21 +132,17 @@ 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_tcp.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"] = "TCP_STREAM"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -157,21 +163,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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -190,21 +193,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_tcp.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, 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 b16214b..440e976 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")
pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
@@ -118,6 +119,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)
@@ -145,21 +159,17 @@ 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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -179,21 +189,17 @@ for setting in encryption_settings:
result_udp.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_udp)
baseline = perfrepo_baseline_to_dict(baseline)
+ client_opts["testname"] = "UDP_STREAM"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -221,21 +227,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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -255,21 +258,18 @@ for setting in encryption_settings:
result_udp.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_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, 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_multicast.py b/recipes/regression_tests/phase3/vxlan_multicast.py
index 0c29977..d333480 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")
pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
@@ -97,6 +98,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' ]:
# prepare PerfRepo result for tcp
@@ -114,21 +128,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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -150,21 +160,17 @@ 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_tcp.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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -187,21 +193,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((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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -223,21 +226,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_tcp.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, 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, 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 12050d9..cf88444 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")
pr_comment = generate_perfrepo_comment([m1, m2], pr_user_comment)
@@ -66,6 +67,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}),
@@ -85,21 +99,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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -118,21 +128,17 @@ 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_tcp.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"
+
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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
@@ -156,21 +162,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((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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_tcp, tcp_res_data)
@@ -189,21 +192,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((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, baseline = baseline,
timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
netperf_result_template(result_udp, udp_res_data)
--
2.9.3
1
2