Hi all,
for the past couple of weeks I've been going over the meeting recordings
we've had wrt the new Python API of LNST. I've been collecting
everything into a single file that I'm appending to this email. I'm
sending it here so that everyone can join the discussion before the
implementation itself begins. I'll warn you thougn... it's LONG :)
!!!NOTE it's not complete yet, I'm sending it now because we have an
upstream meeting planned for later today, namely Device/Interface API is
not complete.
The structure of the file is following:
1. commented pseudo code of how Test Modules will look like - they'll be
instantiated on the Controller and send ad-hoc to the slave where
they'll be executed --> no more synchronization on test start...
2. commented pseudo code of how Tasks will look like, they'll define
both the network requirements and the test execution as well.
3. short rough idea of how the tests/recipes will be executed.
4. 1st version of the API "specification"/documentation. Here I tried to
go through the current *API objects we currently have and make them more
"Pythonic", thinking of how they'll be used from a Task. I tried writing
it as class-method-attribute definitions with some documentation so
hopefully it makes some sense... Like I've said before,
Device/Interfaces are not complete so there's a lot missing there.
Please take a look and provide feedback. I'm sure there are other parts
in addition to Device/Interface APIs that are missing something so I'll
appreciate any help :).
================================================================================
new_api file:
1. test modules
class BaseTestModule:
def __init__(self, **kwargs):
#by defaults loads the params into self.params - no checks pseudocode:
for x in vars(self):
if isinstance(x, BaseType):
param_class = self.getattr(x)
try:
val = kwargs[x]
except KeyError:
if param_class.is_mandatory():
raise TestModuleError("Option x is mandatory")
self.setattr(x.params, param_class.construct(val))
del kwargs[x]
for x in kwargs.keys():
log.error("Undefined parameter x")
if len(kwargs):
raise TestModuleError("Undefined TestModule parameters")
def run():
#needs to be over-ridden - throw an exception to notify the test developer
class MyTest(BaseTestModule):
param = ParamType()
param2 = ParamType2()
param3 = Multiparam(ParamType())
#optional __init__
#def __init__(self, **kwargs):
#super(MyTest).__init__(kwargs)
#additional tester defined checks
def run():
#do my test
#parameters available in self.params
#in Task:
import lnst
#module lnst.modules will dynamically look for module classes in configured
#locations, similar to how we do it now
ping = lnst.modules.Ping(dst=m2.if1.ip[0], count=100, interval=0.1)
m1.run(ping)
================================================
2. Tasks:
class BaseTask(object):
def __init__(self):
#initialize instance specific requirements
self.requirements = Requirements()
for x in dir(self):
val = getattr(self, x)
setattr(self.requirements, x, val)
def test():
raise Exception("Method test MUST be defined.")
class MyTask(lnst.BaseTask):
#class-wide definition of requirements
m1 = HostSel(param="val", ...)
m1.if1 = IfaceSel(l2net="xyz", param="val", ...)
m2 = HostSel(param="val", ...)
m2.if1 = IfaceSel(l2net="xyz", param="val", ...)
def __init__(self, **kwargs):
super(self, lnst.BaseTask).__init__()
#do something with kwargs
#adjust instance specific requirements
self.requirements.m3 = HostSel(...)
def test():
self.matched.m1.run(Module)
self.matched.m1.run("command")
#or
def test(m1, m2):
m1.run(Module)
m2.run("command")
================================================
3. Running Tasks:
from MyTasks import MyTask
import lnst
task_instance = MyTask(params)
lnst(args)
lnst.run(task_instance)
OR
lnst-ctl -d run MyTask.py -- task_params
# looks for NAME class in the NAME.py file (MyTask in this case for which
# the condition "isinstance(NAME, BaseTask)" must be True
# could also run for all classes in the file where "isinstance(x, BaseTask)" is
# True. with the option to restrict to specific task class (or just run the
# first one?)... lnst-ctl rewritten to do the same as manually running the
# task from it's own python script
First do the second option - easier since we have this already, then refactor
the controller to create the lnst controller for the first option.
Aliases lose meaning - they're parameters passed to the MyTask __init__, when
using the lnst-ctl CLI, use "-- task_params"?? might not work for multiple tasks,
================================================
4. Tester facing API, inside the test() method:
Host objects available in self.matched.selector_name:
class Host: #HostAPI??? name can change
#attributes:
# dynamically filled object of Host attributes such as architecture and
# so on. Use example in test() would look like this:
# if host.params.arch == "x86":
# I separated this into the "params" object so I can overwrite its
# __getattr__ method and return None/UnknownParam exception for unknown
# parameters, and to avoid name conflicts with other attributes
params = object()
# dynamically filled object of NetDevice objects accessible directly as the
# object attributes:
# host.ifaces.eth0.set_ip(...)
# I separated this into the "ifaces" object to avoid name conflicts with
# other attributes
# creation of new NetDevices should be possible through simple assignement:
# m1.devs.new_team0 = TeamDevice(...)
# assignement of an incompatible Type or to an existing Device object will
# return an exception
# assignment of None? or del devs.new_team0 to deconfigure the device?
devs = object()
def run(what, bg=False, fail=False, timeout=60, path="", json=False, netns)
# will run "what" on the remote host
# "what" is either a Module object, or a string command that will be
# executed as a bash command
# "bg" when True, runs "what" on background - the run() call
# immediately returns, and "timeout" is ignored, the background
# process can be controlled through the returned Job object
# "fail" if True then the Job is expected to fail, and will be reported
# as PASSed if it does
# "timeout" in seconds, determines how long to block test execution for
# before killing the Job. Only when running in foreground
# "path" changes the current working directory to the specified path
# before "what" is executed and changes back after execution is
# finished.
# "tool" changes the current working directory to the directory of a
# speficied test_tool before "what" is executed and changes back
# after execution is finished.
# !!!!!!! this is from the current API and i'm not yet sure how we
# !!!!!!! want to handle those... so for now I'll keep it
# "json" if True will attempt to parse the returned stdout of the Job
# as json into a dictionary
# "netns" Job will be run in the specified network namespace
# Returns a Job object
def config(option, value)
# copied from old API, provides a shortcut for "echo $value # >/proc/or/sys/path"
# and returns the original value when the test is finished
def sync_resources(srcpath="", dstpath="", recursive=False)
# copies the specified file from the controller to the specified
# destination path, if recursive == True and srcpath refers to a
# directory it copies the entire directory
def {enable, disable}_service(service)
# copied from old API, enables or disables the specified service
def add_{bond, bridge,...}(params)
# this is how we can currently dynamically create net devices on the
# hosts. Even with the new assignment-based approach this could still,
# be usefull, though the method would need to be dynamically created to
# avoid useless work when adding a new netdev type. Something like:
# add_device("name", "Type", params) which would then do
# self.devs.name = TypeDevice(params) ??
def del_device(name)
# removes the specified device, probably easier (more logical?) to do
# this then "devs.name = None" and "del devs.name" would be unreliable
class Device: #DeviceAPI, InterfaceAPI? name can change...
# attributes:
# dynamically created Device attributes such as driver and so on. Use
# example in test() would look like this:
# if host.devs.eth0.driver == "ixgbe":
# achieved through rewriting of the __getattr__ method of the Device class
# should return None or throw UnknownParam exception for unknown parameters
# this should directly mirror the Device objects that are managed by the
# InterfaceManager on the Slave
# eg:
driver = something
mtu = something
ips = [IpAddress, ...]
class Job: #ProcessAPI? name can change...
#attributes:
# True if the Job finished, False if it's still running in the background
finished = bool
# contains the result data returned by the Job, None for bash commands
result = object
# contain the stdout and stderr generated by the job, None for Module Jobs
stdout = ""
stderr = ""
# simple True/False value indicating success/failure of the Job
passed = bool
def wait(timeout=0):
# for background jobs, will wait until the job finished
# "timeout" in seconds, determines how long to wait for. After timeout
# reached, nothing happens, status of the job can be checked with the
# "finished" attribute. If timeout=0, then wait forever.
def kill(signalnum=signal.SIGKILL):
# sends the specified signal to the process of the Job running in
# background
# "signalnum" the signal to be sent
2
9
25 Nov '16
All phase1 and phase2 tests now take optional alias nperf_protocols that
can be used to limit which netperf tests to run.
For example, if set to 'tcp udp', only TCP_STREAM and UDP_STREAM are run,
SCTP_STREAM will be skipped. The default value is all protocol tests, i.e.
TCP, UDP and SCTP.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 109 ++++----
recipes/regression_tests/phase1/3_vlans.xml | 1 +
.../phase1/3_vlans_over_active_backup_bond.xml | 1 +
.../regression_tests/phase1/3_vlans_over_bond.py | 109 ++++----
.../regression_tests/phase1/active_backup_bond.xml | 1 +
.../phase1/active_backup_double_bond.xml | 1 +
recipes/regression_tests/phase1/bonding_test.py | 101 ++++----
recipes/regression_tests/phase1/simple_netperf.py | 121 ++++-----
recipes/regression_tests/phase1/simple_netperf.xml | 1 +
...tual_bridge_2_vlans_over_active_backup_bond.xml | 1 +
.../phase1/virtual_bridge_2_vlans_over_bond.py | 140 ++++++-----
.../phase1/virtual_bridge_vlan_in_guest.py | 142 +++++------
.../phase1/virtual_bridge_vlan_in_guest.xml | 1 +
.../phase1/virtual_bridge_vlan_in_host.py | 142 +++++------
.../phase1/virtual_bridge_vlan_in_host.xml | 1 +
.../phase2/3_vlans_over_active_backup_team.xml | 1 +
.../regression_tests/phase2/3_vlans_over_team.py | 137 ++++++-----
.../phase2/active_backup_double_team.xml | 1 +
.../regression_tests/phase2/active_backup_team.xml | 1 +
.../active_backup_team_vs_active_backup_bond.xml | 1 +
recipes/regression_tests/phase2/team_test.py | 273 +++++++++++----------
...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 146 +++++------
..._ovs_bridge_2_vlans_over_active_backup_bond.xml | 1 +
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 146 +++++------
.../phase2/virtual_ovs_bridge_vlan_in_guest.xml | 1 +
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 145 +++++------
.../phase2/virtual_ovs_bridge_vlan_in_host.xml | 1 +
27 files changed, 902 insertions(+), 824 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index 6b6cfc1..0acff75 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.set_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.set_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/3_vlans.xml b/recipes/regression_tests/phase1/3_vlans.xml
index 3c56aad..fdc681f 100644
--- a/recipes/regression_tests/phase1/3_vlans.xml
+++ b/recipes/regression_tests/phase1/3_vlans.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="3_vlans.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
index 431202b..50a984e 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="3_vlans_over_active_backup_bond.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 198a4cc..a9705c0 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/active_backup_bond.xml b/recipes/regression_tests/phase1/active_backup_bond.xml
index ce2e610..ca65f54 100644
--- a/recipes/regression_tests/phase1/active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_bond.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/active_backup_double_bond.xml b/recipes/regression_tests/phase1/active_backup_double_bond.xml
index 5154504..e769ffb 100644
--- a/recipes/regression_tests/phase1/active_backup_double_bond.xml
+++ b/recipes/regression_tests/phase1/active_backup_double_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_double_bond.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index 9991205..711d6ae 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -41,6 +41,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -256,34 +257,35 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -312,8 +314,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -344,34 +347,35 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -400,8 +404,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index cc401f4..255341b 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -40,6 +40,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -220,33 +221,34 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter("num_parallel", nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -274,8 +276,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -304,33 +307,34 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter("num_parallel", nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -358,8 +362,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.xml b/recipes/regression_tests/phase1/simple_netperf.xml
index a202852..cd90233 100644
--- a/recipes/regression_tests/phase1/simple_netperf.xml
+++ b/recipes/regression_tests/phase1/simple_netperf.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2" />
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="simple_netperf.mapping" />
<alias name="net" value="192.168.101" />
<alias name="driver" value="ixgbe" />
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
index 9a2b3f4..a0d96e6 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_bridge_2_vlans_over_active_backup_bond.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
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 ad958a6..952eca5 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
@@ -46,6 +46,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -61,7 +62,6 @@ else:
pr_comment = generate_perfrepo_comment([h1, g1, g2, h2, g3, g4], pr_user_comment)
mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
h1_nic1 = h1.get_interface("nic1")
h1_nic2 = h1.get_interface("nic2")
@@ -326,37 +326,38 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -388,8 +389,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -423,38 +425,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=['kernel_release',
@@ -485,8 +488,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
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 c32845c..4cf725b 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -41,6 +41,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else:
pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10")
g1_vlan10 = g1.get_interface("vlan10")
@@ -258,38 +258,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
index dd33be1..22aedf4 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_bridge_vlan_in_guest.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
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 9901d2b..8306c99 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -41,6 +41,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else:
pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10")
g1_guestnic= g1.get_interface("guestnic")
@@ -258,38 +258,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
index 382d9c6..5a71d40 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_bridge_vlan_in_host.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
index 683675f..8e778f2 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
+++ b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="3_vlans_over_active_backup_team.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index a43a091..5e5af9f 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,37 +268,38 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -327,8 +329,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -359,37 +362,38 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -419,8 +423,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/active_backup_double_team.xml b/recipes/regression_tests/phase2/active_backup_double_team.xml
index 420992f..b4be042 100644
--- a/recipes/regression_tests/phase2/active_backup_double_team.xml
+++ b/recipes/regression_tests/phase2/active_backup_double_team.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_double_team.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team.xml b/recipes/regression_tests/phase2/active_backup_team.xml
index 7a1f059..7b332a0 100644
--- a/recipes/regression_tests/phase2/active_backup_team.xml
+++ b/recipes/regression_tests/phase2/active_backup_team.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_team.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
index 37e0d02..fca487f 100644
--- a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
+++ b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_team_vs_active_backup_bond.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index ee60488..027de98 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -40,6 +40,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,37 +256,38 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine1")
- result_tcp.set_parameter('netperf_client', "testmachine2")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine1")
+ result_tcp.set_parameter('netperf_client', "testmachine2")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -316,8 +318,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -349,37 +352,38 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine1")
- result_tcp.set_parameter('netperf_client', "testmachine2")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*5)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine1")
+ result_tcp.set_parameter('netperf_client', "testmachine2")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*5)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -410,8 +414,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
@@ -494,37 +499,38 @@ for setting in offload_settings:
server_proc = m2.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine2")
- result_tcp.set_parameter('netperf_client', "testmachine1")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m1.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine2")
+ result_tcp.set_parameter('netperf_client', "testmachine1")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m1.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -555,8 +561,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -588,37 +595,38 @@ for setting in offload_settings:
server_proc = m2.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine2")
- result_tcp.set_parameter('netperf_client', "testmachine1")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m1.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine2")
+ result_tcp.set_parameter('netperf_client', "testmachine1")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m1.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -649,8 +657,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
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 5cbdbd7..6d6743f 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
@@ -47,6 +47,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -324,39 +325,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -388,8 +390,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -413,6 +416,7 @@ for setting in offload_settings:
perf_api.save_result(result_sctp)
server_proc.intr()
+
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
g4.run(ping_mod62)
@@ -422,39 +426,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -486,8 +491,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
index 01c4291..8991be0 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="mtu" value="1500" />
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="virtual_ovs_bridge_2_vlans_over_active_backup_bond.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
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 84b0063..3eaf75c 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
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -257,39 +258,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -321,8 +323,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -346,45 +349,47 @@ for setting in offload_settings:
perf_api.save_result(result_sctp)
server_proc.intr()
+
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -416,8 +421,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
index 786b9d3..739450e 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_guest.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
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 52241d1..8af2f57 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
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,39 +256,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -319,8 +321,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -351,39 +354,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -415,8 +419,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len([val for val in setting if val[1] == 'off']) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
index 5f8b9e5..8c1de53 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_host.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
--
2.7.4
2
1
25 Nov '16
When running parallel netperf tests in phase1 and phase2 recipes it does not
make sense to run with improper qdisc like pfifo_fast. This patch sets
the qdisc to mq so that netperf results are appropriate.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 4 ++++
recipes/regression_tests/phase1/3_vlans_over_bond.py | 5 +++++
recipes/regression_tests/phase1/bonding_test.py | 15 +++++++++++++++
recipes/regression_tests/phase1/simple_netperf.py | 4 ++++
.../phase1/virtual_bridge_2_vlans_over_bond.py | 6 ++++++
.../phase1/virtual_bridge_vlan_in_guest.py | 4 ++++
.../phase1/virtual_bridge_vlan_in_host.py | 4 ++++
recipes/regression_tests/phase2/3_vlans_over_team.py | 5 +++++
recipes/regression_tests/phase2/team_test.py | 15 +++++++++++++++
.../virtual_ovs_bridge_2_vlans_over_active_backup_bond.py | 6 ++++++
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 4 ++++
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 4 ++++
12 files changed, 76 insertions(+)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index df1b3fa..6b6cfc1 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -209,6 +209,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy1.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_phy1.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 3a06fc1..198a4cc 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -210,6 +210,11 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy1.get_devname())
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy2.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_phy1.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index e075152..9991205 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -218,6 +218,21 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth1").get_devname())
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth2").get_devname())
+
+ if test_if2.get_type() == "bond":
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth1").get_devname())
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth2").get_devname())
+ else:
+ m2.run("tc qdisc replace dev %s root mq" %
+ test_if2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index 4a7f0d8..cc401f4 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -189,6 +189,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel" : nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_testiface.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_testiface.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 5baafab..ad958a6 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
@@ -234,6 +234,12 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic1.get_devname())
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic2.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic1.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 8c1ea70..c32845c 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -215,6 +215,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 5c0c7a0..9901d2b 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -214,6 +214,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index ec49100..a43a091 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -210,6 +210,11 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy1.get_devname())
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy2.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_phy1.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index 5bb03c2..ee60488 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -217,6 +217,21 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth1").get_devname())
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth2").get_devname())
+
+ if test_if2.get_type() in [ "team", "bond" ]:
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth1").get_devname())
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth2").get_devname())
+ else:
+ m2.run("tc qdisc replace dev %s root mq" %
+ test_if2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 c994d3e..5cbdbd7 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
@@ -234,6 +234,12 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic1.get_devname())
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic2.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic1.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 f6823b2..84b0063 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
@@ -213,6 +213,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 47e7b31..52241d1 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
@@ -212,6 +212,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
--
2.7.4
2
1
25 Nov '16
This patch adds SCTP_STREAM to all phase1 and phase2 tests. The default packet
size is set to 16K because the netperf defaults to bigger value that's not
commonly used.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 92 ++++++++++++
.../regression_tests/phase1/3_vlans_over_bond.py | 92 ++++++++++++
recipes/regression_tests/phase1/bonding_test.py | 88 ++++++++++++
recipes/regression_tests/phase1/simple_netperf.py | 90 ++++++++++++
.../phase1/virtual_bridge_2_vlans_over_bond.py | 92 ++++++++++++
.../phase1/virtual_bridge_vlan_in_guest.py | 90 ++++++++++++
.../phase1/virtual_bridge_vlan_in_host.py | 90 ++++++++++++
.../regression_tests/phase2/3_vlans_over_team.py | 92 ++++++++++++
recipes/regression_tests/phase2/team_test.py | 156 +++++++++++++++++++++
...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 92 ++++++++++++
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 90 ++++++++++++
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 90 ++++++++++++
12 files changed, 1154 insertions(+)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index e4f1067..df1b3fa 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -162,22 +164,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings:
#apply offload setting
@@ -284,6 +322,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -349,6 +414,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 342e105..3a06fc1 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings:
#apply offload setting
@@ -283,6 +321,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -348,6 +413,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index 222613e..e075152 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -171,22 +173,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -258,6 +296,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -321,6 +384,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index 13996ca..4a7f0d8 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -130,6 +132,36 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_testiface.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_testiface.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
netperf_srv = ctl.get_module("Netperf",
options={
"role" : "server",
@@ -145,19 +177,25 @@ netperf_srv6 = ctl.get_module("Netperf",
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel" : nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel" : nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel" : nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -230,6 +268,32 @@ for setting in offload_settings:
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -288,6 +352,32 @@ for setting in offload_settings:
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
# reset offload states
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
index 48142d7..5baafab 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
@@ -47,6 +47,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s" % (g3_guestnic.get_ip(0)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s -6" % (g3_guestnic.get_ip(1)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing",
options={
@@ -339,6 +381,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -411,6 +478,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
index eb23990..8c1ea70 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -166,22 +168,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -275,6 +315,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -344,6 +409,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
index 695d322..5c0c7a0 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -165,22 +167,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -275,6 +315,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -344,6 +409,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index fd16fe4..ec49100 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings:
#apply offload setting
@@ -283,6 +321,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -348,6 +413,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index 92a6169..5bb03c2 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -170,22 +172,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -261,6 +299,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine1")
+ result_sctp.set_parameter('netperf_client', "testmachine2")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
m1.run(ping_mod6)
@@ -327,6 +393,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine1")
+ result_sctp.set_parameter('netperf_client', "testmachine2")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
@@ -366,6 +460,12 @@ netperf_cli_tcp6.update_options({"netperf_server" : test_if2.get_ip(1),
netperf_cli_udp6.update_options({"netperf_server" : test_if2.get_ip(1),
"netperf_opts" : p_opts6 })
+netperf_cli_sctp.update_options({"netperf_server" : test_if2.get_ip(0),
+ "netperf_opts" : p_opts})
+
+netperf_cli_sctp6.update_options({"netperf_server" : test_if2.get_ip(1),
+ "netperf_opts" : p_opts6})
+
for setting in offload_settings:
dev_features = ""
for offload in setting:
@@ -438,6 +538,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine2")
+ result_sctp.set_parameter('netperf_client', "testmachine1")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m1.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
m2.run(ping_mod6)
@@ -504,6 +632,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine2")
+ result_sctp.set_parameter('netperf_client', "testmachine1")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m1.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
index cb8fa99..c994d3e 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
@@ -48,6 +48,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s" % (g3_guestnic.get_ip(0)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s -6" % (g3_guestnic.get_ip(1)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing",
options={
@@ -339,6 +381,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
@@ -412,6 +479,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
index 07dbf4b..f6823b2 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -164,22 +166,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -276,6 +316,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
@@ -346,6 +411,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
index 07864a0..47e7b31 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -163,22 +165,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -274,6 +314,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -345,6 +410,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len([val for val in setting if val[1] == 'off']) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
--
2.7.4
2
1
Python-perfrepo command line tool was renamed from perfrepo to perfrepo-cli.
This patch makes the same change in LNST TaskAPI.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
lnst/Controller/Task.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lnst/Controller/Task.py b/lnst/Controller/Task.py
index 6fd1946..e91409e 100644
--- a/lnst/Controller/Task.py
+++ b/lnst/Controller/Task.py
@@ -942,7 +942,7 @@ class PerfRepoAPI(object):
logging.debug("No mapping defined for hash '%s'" % h)
logging.debug("If you want to create a new report and set "\
"this result as the baseline run this command:")
- cmd = "perfrepo report create"
+ cmd = "perfrepo-cli report create"
cmd += " name REPORTNAME"
test = result.get_test()
--
2.7.4
2
1
18 Nov '16
All phase1 and phase2 tests now take optional alias nperf_protocols that
can be used to limit which netperf tests to run.
For example, if set to 'tcp udp', only TCP_STREAM and UDP_STREAM are run,
SCTP_STREAM will be skipped. The default value is all protocol tests, i.e.
TCP, UDP and SCTP.
This patch also removes the 'enable_udp_perf' alias from virtual bridge tests
since the new alias can be used in similar manner.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 109 +++++----
recipes/regression_tests/phase1/3_vlans.xml | 1 +
.../phase1/3_vlans_over_active_backup_bond.xml | 1 +
.../regression_tests/phase1/3_vlans_over_bond.py | 109 +++++----
.../regression_tests/phase1/active_backup_bond.xml | 1 +
.../phase1/active_backup_double_bond.xml | 1 +
recipes/regression_tests/phase1/bonding_test.py | 101 ++++----
recipes/regression_tests/phase1/simple_netperf.py | 121 +++++-----
recipes/regression_tests/phase1/simple_netperf.xml | 1 +
...tual_bridge_2_vlans_over_active_backup_bond.xml | 1 +
.../phase1/virtual_bridge_2_vlans_over_bond.py | 140 +++++------
.../phase1/virtual_bridge_vlan_in_guest.py | 142 +++++------
.../phase1/virtual_bridge_vlan_in_guest.xml | 1 +
.../phase1/virtual_bridge_vlan_in_host.py | 142 +++++------
.../phase1/virtual_bridge_vlan_in_host.xml | 1 +
.../phase2/3_vlans_over_active_backup_team.xml | 1 +
.../regression_tests/phase2/3_vlans_over_team.py | 137 ++++++-----
.../phase2/active_backup_double_team.xml | 1 +
.../regression_tests/phase2/active_backup_team.xml | 1 +
.../active_backup_team_vs_active_backup_bond.xml | 1 +
recipes/regression_tests/phase2/team_test.py | 268 +++++++++++----------
...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 146 +++++------
..._ovs_bridge_2_vlans_over_active_backup_bond.xml | 1 +
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 146 +++++------
.../phase2/virtual_ovs_bridge_vlan_in_guest.xml | 1 +
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 145 +++++------
.../phase2/virtual_ovs_bridge_vlan_in_host.xml | 1 +
27 files changed, 899 insertions(+), 822 deletions(-)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index 6e6611f..442dbdc 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.set_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.set_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/3_vlans.xml b/recipes/regression_tests/phase1/3_vlans.xml
index 3c56aad..fdc681f 100644
--- a/recipes/regression_tests/phase1/3_vlans.xml
+++ b/recipes/regression_tests/phase1/3_vlans.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="3_vlans.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
index 431202b..50a984e 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/3_vlans_over_active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="3_vlans_over_active_backup_bond.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 2e0685e..8fc8dd6 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,36 +268,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -327,8 +329,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -359,36 +362,37 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -419,8 +423,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/active_backup_bond.xml b/recipes/regression_tests/phase1/active_backup_bond.xml
index ce2e610..ca65f54 100644
--- a/recipes/regression_tests/phase1/active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_bond.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/active_backup_double_bond.xml b/recipes/regression_tests/phase1/active_backup_double_bond.xml
index 5154504..e769ffb 100644
--- a/recipes/regression_tests/phase1/active_backup_double_bond.xml
+++ b/recipes/regression_tests/phase1/active_backup_double_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_double_bond.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index 8b1dfc5..e08a4e5 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -41,6 +41,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -256,34 +257,35 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -312,8 +314,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -344,34 +347,35 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ 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)
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -400,8 +404,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index 272b57d..9ef7cf6 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -40,6 +40,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -220,33 +221,34 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter("num_parallel", nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -274,8 +276,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -304,33 +307,34 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter("num_parallel", nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
@@ -358,8 +362,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/simple_netperf.xml b/recipes/regression_tests/phase1/simple_netperf.xml
index a202852..cd90233 100644
--- a/recipes/regression_tests/phase1/simple_netperf.xml
+++ b/recipes/regression_tests/phase1/simple_netperf.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2" />
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="simple_netperf.mapping" />
<alias name="net" value="192.168.101" />
<alias name="driver" value="ixgbe" />
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
index 9a2b3f4..a0d96e6 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_active_backup_bond.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_bridge_2_vlans_over_active_backup_bond.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
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 ae8baf9..c8715e8 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
@@ -46,6 +46,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -61,7 +62,6 @@ else:
pr_comment = generate_perfrepo_comment([h1, g1, g2, h2, g3, g4], pr_user_comment)
mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
h1_nic1 = h1.get_interface("nic1")
h1_nic2 = h1.get_interface("nic2")
@@ -326,37 +326,38 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
# prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
@@ -388,8 +389,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -423,38 +425,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=['kernel_release',
@@ -485,8 +488,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
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 f769086..0cfdf23 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -41,6 +41,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else:
pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10")
g1_vlan10 = g1.get_interface("vlan10")
@@ -258,38 +258,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
index dd33be1..22aedf4 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_bridge_vlan_in_guest.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
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 9607132..9cebece 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -41,6 +41,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -57,7 +58,6 @@ else:
pr_comment = generate_perfrepo_comment([h1, g1, h2], pr_user_comment)
mtu = ctl.get_alias("mtu")
-enable_udp_perf = ctl.get_alias("enable_udp_perf")
h2_vlan10 = h2.get_interface("vlan10")
g1_guestnic= g1.get_interface("guestnic")
@@ -258,38 +258,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if enable_udp_perf is not None and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=['kernel_release',
@@ -320,8 +321,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -352,38 +354,39 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=['kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if enable_udp_perf and ("gro", "off") not in setting:
+ 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=['kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=['kernel_release',
@@ -414,8 +417,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
index 382d9c6..5a71d40 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_bridge_vlan_in_host.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
index 683675f..8e778f2 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
+++ b/recipes/regression_tests/phase2/3_vlans_over_active_backup_team.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="3_vlans_over_active_backup_team.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index 4824db7..0c58fdf 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -267,37 +268,38 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -327,8 +329,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -359,37 +362,38 @@ for setting in offload_settings:
srv_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
- result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_tcp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -419,8 +423,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/active_backup_double_team.xml b/recipes/regression_tests/phase2/active_backup_double_team.xml
index 420992f..b4be042 100644
--- a/recipes/regression_tests/phase2/active_backup_double_team.xml
+++ b/recipes/regression_tests/phase2/active_backup_double_team.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_double_team.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team.xml b/recipes/regression_tests/phase2/active_backup_team.xml
index 7a1f059..7b332a0 100644
--- a/recipes/regression_tests/phase2/active_backup_team.xml
+++ b/recipes/regression_tests/phase2/active_backup_team.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_team.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
index 37e0d02..fca487f 100644
--- a/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
+++ b/recipes/regression_tests/phase2/active_backup_team_vs_active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="active_backup_team_vs_active_backup_bond.mapping" />
<alias name="net" value="192.168.0"/>
<alias name="driver" value="ixgbe"/>
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index 25a2823..e953ac0 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -40,6 +40,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,37 +256,38 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine1")
- result_tcp.set_parameter('netperf_client', "testmachine2")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine1")
+ result_tcp.set_parameter('netperf_client', "testmachine2")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -316,8 +318,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -349,37 +352,38 @@ for setting in offload_settings:
server_proc = m1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine1")
- result_tcp.set_parameter('netperf_client', "testmachine2")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*5)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine1")
+ result_tcp.set_parameter('netperf_client', "testmachine2")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*5)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -494,37 +498,38 @@ for setting in offload_settings:
server_proc = m2.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine2")
- result_tcp.set_parameter('netperf_client', "testmachine1")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = m1.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine2")
+ result_tcp.set_parameter('netperf_client', "testmachine1")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = m1.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -555,8 +560,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -588,37 +594,38 @@ for setting in offload_settings:
server_proc = m2.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.set_parameter('netperf_server', "testmachine2")
- result_tcp.set_parameter('netperf_client', "testmachine1")
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = m1.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ if nperf_protocols.find("tcp") > -1:
+ # prepare PerfRepo result for tcp
+ result_tcp = perf_api.new_result("tcp_ipv6_id",
+ "tcp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.set_parameter('netperf_server', "testmachine2")
+ result_tcp.set_parameter('netperf_client', "testmachine1")
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = m1.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -649,8 +656,9 @@ for setting in offload_settings:
# prepare PerfRepo result for sctp
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
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 ccabb5b..0a5f6c3 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
@@ -47,6 +47,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -324,39 +325,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -388,8 +390,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -413,6 +416,7 @@ for setting in offload_settings:
perf_api.save_result(result_sctp)
server_proc.intr()
+
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
g4.run(ping_mod62)
@@ -422,39 +426,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = g3.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = g3.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -486,8 +491,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
index 01c4291..8991be0 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.xml
@@ -10,6 +10,7 @@
<alias name="mtu" value="1500" />
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mapping_file" value="virtual_ovs_bridge_2_vlans_over_active_backup_bond.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
<alias name="vlan10_tag" value="10"/>
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 8274601..dede110 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
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -257,39 +258,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -321,8 +323,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -346,45 +349,47 @@ for setting in offload_settings:
perf_api.save_result(result_sctp)
server_proc.intr()
+
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -416,8 +421,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
index 786b9d3..739450e 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_guest.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
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 f0fd8c1..6b07372 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
@@ -42,6 +42,7 @@ 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")
offloads_alias = ctl.get_alias("offloads")
+nperf_protocols = ctl.get_alias("nperf_protocols")
sctp_default_msg_size = "16K"
@@ -255,39 +256,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp
- result_tcp = perf_api.new_result("tcp_ipv4_id",
- "tcp_ipv4_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp
result_udp = perf_api.new_result("udp_ipv4_id",
"udp_ipv4_result",
hash_ignore=[
@@ -319,8 +321,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv4_id",
"sctp_ipv4_result",
hash_ignore=[
@@ -351,39 +354,40 @@ for setting in offload_settings:
server_proc = g1.run(netperf_srv6, bg=True)
ctl.wait(2)
- # prepare PerfRepo result for tcp ipv6
- result_tcp = perf_api.new_result("tcp_ipv6_id",
- "tcp_ipv6_result",
- hash_ignore=[
- 'kernel_release',
- 'redhat_release',
- r'guest\d+\.hostname',
- r'guest\d+\..*hwaddr',
- r'host\d+\..*tap\d*\.hwaddr',
- r'host\d+\..*tap\d*\.devname'])
- for offload in setting:
- result_tcp.set_parameter(offload[0], offload[1])
-
- if nperf_msg_size is not None:
- result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
-
- result_tcp.add_tag(product_name)
- if nperf_mode == "multi":
- result_tcp.add_tag("multithreaded")
- result_tcp.set_parameter('num_parallel', nperf_num_parallel)
-
- baseline = perf_api.get_baseline_of_result(result_tcp)
- netperf_baseline_template(netperf_cli_tcp6, baseline)
-
- tcp_res_data = h2.run(netperf_cli_tcp6,
- timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
-
- netperf_result_template(result_tcp, tcp_res_data)
- result_tcp.set_comment(pr_comment)
- perf_api.save_result(result_tcp)
-
- # prepare PerfRepo result for udp ipv6
- if ("gro", "off") not in setting:
+ 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=[
+ 'kernel_release',
+ 'redhat_release',
+ r'guest\d+\.hostname',
+ r'guest\d+\..*hwaddr',
+ r'host\d+\..*tap\d*\.hwaddr',
+ r'host\d+\..*tap\d*\.devname'])
+ for offload in setting:
+ result_tcp.set_parameter(offload[0], offload[1])
+
+ if nperf_msg_size is not None:
+ result_tcp.set_parameter("nperf_msg_size", nperf_msg_size)
+
+ result_tcp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_tcp.add_tag("multithreaded")
+ result_tcp.set_parameter('num_parallel', nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_tcp)
+ netperf_baseline_template(netperf_cli_tcp6, baseline)
+
+ tcp_res_data = h2.run(netperf_cli_tcp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_tcp, tcp_res_data)
+ result_tcp.set_comment(pr_comment)
+ perf_api.save_result(result_tcp)
+
+ if nperf_protocols.find("udp") > -1 and ("gro", "off") not in setting:
+ # prepare PerfRepo result for udp ipv6
result_udp = perf_api.new_result("udp_ipv6_id",
"udp_ipv6_result",
hash_ignore=[
@@ -415,8 +419,9 @@ for setting in offload_settings:
perf_api.save_result(result_udp)
# for SCTP only gso offload on/off
- if (len({val for val in setting if val[1] == 'off'}) == 0 or
- ('gso', 'off') in setting):
+ if (nperf_protocols.find("sctp") > -1 and
+ (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting)):
result_sctp = perf_api.new_result("sctp_ipv6_id",
"sctp_ipv6_result",
hash_ignore=[
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
index 5f8b9e5..8c1de53 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.xml
@@ -9,6 +9,7 @@
<alias name="nperf_num_parallel" value="2"/>
<alias name="nperf_debug" value="0"/>
<alias name="nperf_max_dev" value="20%"/>
+ <alias name="nperf_protocols" value="tcp udp sctp"/>
<alias name="mtu" value="1500" />
<alias name="mapping_file" value="virtual_ovs_bridge_vlan_in_host.mapping" />
<alias name="vlan10_net" value="192.168.10"/>
--
2.7.4
1
1
18 Nov '16
This patch adds SCTP_STREAM to all phase1 and phase2 tests. The default packet
size is set to 16K because the netperf defaults to bigger value that's not
commonly used.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 92 ++++++++++++
.../regression_tests/phase1/3_vlans_over_bond.py | 92 ++++++++++++
recipes/regression_tests/phase1/bonding_test.py | 88 ++++++++++++
recipes/regression_tests/phase1/simple_netperf.py | 90 ++++++++++++
.../phase1/virtual_bridge_2_vlans_over_bond.py | 92 ++++++++++++
.../phase1/virtual_bridge_vlan_in_guest.py | 90 ++++++++++++
.../phase1/virtual_bridge_vlan_in_host.py | 90 ++++++++++++
.../regression_tests/phase2/3_vlans_over_team.py | 92 ++++++++++++
recipes/regression_tests/phase2/team_test.py | 156 +++++++++++++++++++++
...l_ovs_bridge_2_vlans_over_active_backup_bond.py | 92 ++++++++++++
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 90 ++++++++++++
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 90 ++++++++++++
12 files changed, 1154 insertions(+)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index e4f1067..e0e8da0 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -162,22 +164,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings:
#apply offload setting
@@ -284,6 +322,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -349,6 +414,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 342e105..79a125b 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings:
#apply offload setting
@@ -283,6 +321,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -348,6 +413,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index 222613e..b3a96c1 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -171,22 +173,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -258,6 +296,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -321,6 +384,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index 13996ca..9e7963a 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -130,6 +132,36 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_testiface.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_testiface.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
netperf_srv = ctl.get_module("Netperf",
options={
"role" : "server",
@@ -145,19 +177,25 @@ netperf_srv6 = ctl.get_module("Netperf",
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel" : nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel" : nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel" : nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -230,6 +268,32 @@ for setting in offload_settings:
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -288,6 +352,32 @@ for setting in offload_settings:
netperf_result_template(result_udp, udp_res_data)
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
# reset offload states
diff --git a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
index 48142d7..284ea0e 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_2_vlans_over_bond.py
@@ -47,6 +47,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s" % (g3_guestnic.get_ip(0)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s -6" % (g3_guestnic.get_ip(1)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing",
options={
@@ -339,6 +381,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -411,6 +478,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
index eb23990..a637590 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -166,22 +168,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -275,6 +315,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -344,6 +409,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
index 695d322..21411e8 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -42,6 +42,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -165,22 +167,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
# configure mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -275,6 +315,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -344,6 +409,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index fd16fe4..3f41d95 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -163,22 +165,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : m1_vlan1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
for setting in offload_settings:
#apply offload setting
@@ -283,6 +321,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -348,6 +413,33 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server_on_vlan', vlans[0])
+ result_sctp.set_parameter('netperf_client_on_vlan', vlans[0])
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
srv_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index 92a6169..0fa8bc2 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -41,6 +41,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -170,22 +172,58 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" : test_if1.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ctl.wait(15)
@@ -261,6 +299,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine1")
+ result_sctp.set_parameter('netperf_client', "testmachine2")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
m1.run(ping_mod6)
@@ -327,6 +393,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine1")
+ result_sctp.set_parameter('netperf_client', "testmachine2")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
@@ -366,6 +460,12 @@ netperf_cli_tcp6.update_options({"netperf_server" : test_if2.get_ip(1),
netperf_cli_udp6.update_options({"netperf_server" : test_if2.get_ip(1),
"netperf_opts" : p_opts6 })
+netperf_cli_sctp.update_options({"netperf_server" : test_if2.get_ip(0),
+ "netperf_opts" : p_opts})
+
+netperf_cli_sctp6.update_options({"netperf_server" : test_if2.get_ip(1),
+ "netperf_opts" : p_opts6})
+
for setting in offload_settings:
dev_features = ""
for offload in setting:
@@ -438,6 +538,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine2")
+ result_sctp.set_parameter('netperf_client', "testmachine1")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m1.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
m2.run(ping_mod6)
@@ -504,6 +632,34 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # prepare PerfRepo result for sctp
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.set_parameter('netperf_server', "testmachine2")
+ result_sctp.set_parameter('netperf_client', "testmachine1")
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = m1.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
index cb8fa99..288ef1e 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_2_vlans_over_active_backup_bond.py
@@ -48,6 +48,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -183,22 +185,62 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s" % (g3_guestnic.get_ip(0)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" :
+ "-L %s -6" % (g3_guestnic.get_ip(1)),
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
ping_mod_bad = ctl.get_module("IcmpPing",
options={
@@ -339,6 +381,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
@@ -412,6 +479,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = g3.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
index 07dbf4b..63bea22 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_guest.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -164,22 +166,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_vlan10.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -276,6 +316,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
g1.run(ping_mod6)
@@ -346,6 +411,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
diff --git a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
index 07864a0..f375997 100644
--- a/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase2/virtual_ovs_bridge_vlan_in_host.py
@@ -43,6 +43,8 @@ nperf_msg_size = ctl.get_alias("nperf_msg_size")
pr_user_comment = ctl.get_alias("perfrepo_comment")
offloads_alias = ctl.get_alias("offloads")
+sctp_default_msg_size = "16K"
+
if offloads_alias is not None:
offloads, offload_settings = parse_offloads(offloads_alias)
else:
@@ -163,22 +165,60 @@ netperf_cli_udp6 = ctl.get_module("Netperf",
"max_deviation" : nperf_max_dev
})
+netperf_cli_sctp = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(0),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
+netperf_cli_sctp6 = ctl.get_module("Netperf",
+ options={
+ "role" : "client",
+ "netperf_server" :
+ g1_guestnic.get_ip(1),
+ "duration" : netperf_duration,
+ "testname" : "SCTP_STREAM",
+ "confidence" : nperf_confidence,
+ "cpu_util" : nperf_cpu_util,
+ "runs" : nperf_max_runs,
+ "netperf_opts" : p_opts6,
+ "msg_size" : sctp_default_msg_size,
+ "debug" : nperf_debug,
+ "max_deviation" : nperf_max_dev
+ })
+
if nperf_mode == "multi":
netperf_cli_tcp.unset_option("confidence")
netperf_cli_udp.unset_option("confidence")
+ netperf_cli_sctp.unset_option("confidence")
netperf_cli_tcp6.unset_option("confidence")
netperf_cli_udp6.unset_option("confidence")
+ netperf_cli_sctp6.unset_option("confidence")
netperf_cli_tcp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_tcp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
+ netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp6.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp.update_options({"msg_size" : nperf_msg_size})
+ netperf_cli_sctp6.update_options({"msg_size" : nperf_msg_size})
#set mtu
h1.get_interface("nic").set_mtu(mtu)
@@ -274,6 +314,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv4_id",
+ "sctp_ipv4_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
if ipv in [ 'ipv6', 'both' ]:
@@ -345,6 +410,31 @@ for setting in offload_settings:
result_udp.set_comment(pr_comment)
perf_api.save_result(result_udp)
+ # for SCTP only gso offload on/off
+ if (len({val for val in setting if val[1] == 'off'}) == 0 or
+ ('gso', 'off') in setting):
+ result_sctp = perf_api.new_result("sctp_ipv6_id",
+ "sctp_ipv6_result",
+ hash_ignore=[
+ 'kernel_release',
+ 'redhat_release'])
+ for offload in setting:
+ result_sctp.set_parameter(offload[0], offload[1])
+
+ result_sctp.add_tag(product_name)
+ if nperf_mode == "multi":
+ result_sctp.add_tag("multithreaded")
+ result_sctp.set_parameter("num_parallel", nperf_num_parallel)
+
+ baseline = perf_api.get_baseline_of_result(result_sctp)
+ netperf_baseline_template(netperf_cli_sctp, baseline)
+ sctp_res_data = h2.run(netperf_cli_sctp6,
+ timeout = (netperf_duration + nperf_reserve)*nperf_max_runs)
+
+ netperf_result_template(result_sctp, sctp_res_data)
+ result_sctp.set_comment(pr_comment)
+ perf_api.save_result(result_sctp)
+
server_proc.intr()
#reset offload states
--
2.7.4
1
1
When one want to add a new function to the slave, one needs to add it also
to the slave communicator (NetTestSlave), and to the controller side that
control it (Macine) and to Task, that controls it.
While some of this functions have logic, most of them are just calling a
function of an object that they holds, usually, with the same name.
Those function can, and I think they should, be manufactured in run time
for the following reasons:
* it shorten the code considerably (new code is 25% of the old one).
* it makes adding new function much shorter.
* it singles out the function that do have logic in them.
There are however some down sides to it:
* code is a bit harder to read at first.
* Inheriting function is a bit more tricky.
This is just a start and it can be expanded for:
* more classes with functions with this problem
* setter-getters without inner logic
* function with arguments with default values
I know that LNST is now in freeze and I don't know how much of it will be
relevant after it. But in case it is, I will be glad to hear your
opinions on it in the meantime.
Nogah Frankel (4):
Machine: Interface: create RPC calls functions in run time
Slave: NetTestSlave: SlaveMethods: create dev functions calls in run
time
Slave: NetTestSlave: SlaveMethods: create bridge function calls in run
time
Task: InterfaceAPI: create interface calls functions in run time
lnst/Controller/Machine.py | 106 ++++-----------
lnst/Controller/Task.py | 93 ++++---------
lnst/Slave/NetTestSlave.py | 326 +++++++++------------------------------------
3 files changed, 113 insertions(+), 412 deletions(-)
--
2.4.3
2
6
09 Nov '16
When running parallel netperf tests in phase1 and phase2 recipes it does not
make sense to run with improper qdisc like pfifo_fast. This patch sets
the qdisc to mq so that netperf results are appropriate.
Signed-off-by: Jan Tluka <jtluka(a)redhat.com>
---
recipes/regression_tests/phase1/3_vlans.py | 4 ++++
recipes/regression_tests/phase1/3_vlans_over_bond.py | 5 +++++
recipes/regression_tests/phase1/bonding_test.py | 15 +++++++++++++++
recipes/regression_tests/phase1/simple_netperf.py | 4 ++++
.../phase1/virtual_bridge_2_vlans_over_bond.py | 6 ++++++
.../phase1/virtual_bridge_vlan_in_guest.py | 4 ++++
.../phase1/virtual_bridge_vlan_in_host.py | 4 ++++
recipes/regression_tests/phase2/3_vlans_over_team.py | 5 +++++
recipes/regression_tests/phase2/team_test.py | 15 +++++++++++++++
.../virtual_ovs_bridge_2_vlans_over_active_backup_bond.py | 6 ++++++
.../phase2/virtual_ovs_bridge_vlan_in_guest.py | 4 ++++
.../phase2/virtual_ovs_bridge_vlan_in_host.py | 4 ++++
12 files changed, 76 insertions(+)
diff --git a/recipes/regression_tests/phase1/3_vlans.py b/recipes/regression_tests/phase1/3_vlans.py
index e0e8da0..6e6611f 100644
--- a/recipes/regression_tests/phase1/3_vlans.py
+++ b/recipes/regression_tests/phase1/3_vlans.py
@@ -209,6 +209,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy1.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_phy1.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase1/3_vlans_over_bond.py b/recipes/regression_tests/phase1/3_vlans_over_bond.py
index 79a125b..2e0685e 100644
--- a/recipes/regression_tests/phase1/3_vlans_over_bond.py
+++ b/recipes/regression_tests/phase1/3_vlans_over_bond.py
@@ -210,6 +210,11 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy1.get_devname())
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy2.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_phy1.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase1/bonding_test.py b/recipes/regression_tests/phase1/bonding_test.py
index b3a96c1..8b1dfc5 100644
--- a/recipes/regression_tests/phase1/bonding_test.py
+++ b/recipes/regression_tests/phase1/bonding_test.py
@@ -218,6 +218,21 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth1").get_devname())
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth2").get_devname())
+
+ if test_if2.get_type() == "bond":
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth1").get_devname())
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth2").get_devname())
+ else:
+ m2.run("tc qdisc replace dev %s root mq" %
+ test_if2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase1/simple_netperf.py b/recipes/regression_tests/phase1/simple_netperf.py
index 9e7963a..272b57d 100644
--- a/recipes/regression_tests/phase1/simple_netperf.py
+++ b/recipes/regression_tests/phase1/simple_netperf.py
@@ -189,6 +189,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel" : nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel" : nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_testiface.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_testiface.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 284ea0e..ae8baf9 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
@@ -234,6 +234,12 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic1.get_devname())
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic2.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic1.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 a637590..f769086 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_guest.py
@@ -215,6 +215,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 21411e8..9607132 100644
--- a/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
+++ b/recipes/regression_tests/phase1/virtual_bridge_vlan_in_host.py
@@ -214,6 +214,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase2/3_vlans_over_team.py b/recipes/regression_tests/phase2/3_vlans_over_team.py
index 3f41d95..4824db7 100644
--- a/recipes/regression_tests/phase2/3_vlans_over_team.py
+++ b/recipes/regression_tests/phase2/3_vlans_over_team.py
@@ -210,6 +210,11 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy1.get_devname())
+ m1.run("tc qdisc replace dev %s root mq" % m1_phy2.get_devname())
+ m2.run("tc qdisc replace dev %s root mq" % m2_phy1.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
diff --git a/recipes/regression_tests/phase2/team_test.py b/recipes/regression_tests/phase2/team_test.py
index 0fa8bc2..25a2823 100644
--- a/recipes/regression_tests/phase2/team_test.py
+++ b/recipes/regression_tests/phase2/team_test.py
@@ -217,6 +217,21 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth1").get_devname())
+ m1.run("tc qdisc replace dev %s root mq" %
+ m1.get_interface("eth2").get_devname())
+
+ if test_if2.get_type() in [ "team", "bond" ]:
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth1").get_devname())
+ m2.run("tc qdisc replace dev %s root mq" %
+ m2.get_interface("eth2").get_devname())
+ else:
+ m2.run("tc qdisc replace dev %s root mq" %
+ test_if2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 288ef1e..ccabb5b 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
@@ -234,6 +234,12 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic1.get_devname())
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic2.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic1.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic2.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 63bea22..8274601 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
@@ -213,6 +213,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_udp.update_options({"msg_size" : nperf_msg_size})
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 f375997..f0fd8c1 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
@@ -212,6 +212,10 @@ if nperf_mode == "multi":
netperf_cli_udp6.update_options({"num_parallel": nperf_num_parallel})
netperf_cli_sctp6.update_options({"num_parallel": nperf_num_parallel})
+ # we have to use multiqueue qdisc to get appropriate data
+ h1.run("tc qdisc replace dev %s root mq" % h1_nic.get_devname())
+ h2.run("tc qdisc replace dev %s root mq" % h2_nic.get_devname())
+
if nperf_msg_size is not None:
netperf_cli_tcp.update_options({"msg_size" : nperf_msg_size})
netperf_cli_tcp6.update_options({"msg_size" : nperf_msg_size})
--
2.7.4
1
0
03 Nov '16
From: Ondrej Lichtner <olichtne(a)redhat.com>
If define was a top level element (not a valid recipe) LNST would crash
with a nonsensical error message. This fix skips removing the element
and parsing should then fail because of schema validation.
Signed-off-by: Ondrej Lichtner <olichtne(a)redhat.com>
---
lnst/Controller/XmlTemplates.py | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/lnst/Controller/XmlTemplates.py b/lnst/Controller/XmlTemplates.py
index a1541db..b1bf9a1 100644
--- a/lnst/Controller/XmlTemplates.py
+++ b/lnst/Controller/XmlTemplates.py
@@ -337,7 +337,8 @@ class XmlTemplates:
value = etree.tostring(element, method="text").strip()
self.define_alias(name, value)
parent = element.getparent()
- parent.remove(element)
+ if parent is not None:
+ parent.remove(element)
return
self.add_namespace_level()
--
2.10.2
2
1