class CoalescingHWConfigMixin(BaseHWConfigMixin):
adaptive_rx_coalescing = BoolParam(mandatory=False)
adaptive_tx_coalescing = BoolParam(mandatory=False)
@property
def coalescing_hw_config_dev_list(self):
return []
def hw_config(self, config):
super().hw_config(config)
self._configure_dev_attribute(
config,
self.coalescing_hw_config_dev_list,
"adaptive_rx_coalescing",
getattr(self.params, "adaptive_rx_coalescing", None),
)
self._configure_dev_attribute(
config,
self.coalescing_hw_config_dev_list,
"adaptive_tx_coalescing",
getattr(self.params, "adaptive_tx_coalescing", None),
)
def describe_hw_config(self, config):
desc = super().describe_hw_config(config)
desc.extend(
self._describe_dev_attribute(config, "adaptive_rx_coalescing")
)
desc.extend(
self._describe_dev_attribute(config, "adaptive_tx_coalescing")
)
return desc
class CoalescingHWConfigMixin(BaseHWConfigMixin):
"""
This class is an extension to the :any:`BaseEnrtRecipe` class that enables
adaptive coalescing configuration on the devices defined by
:attr:`coalescing_hw_config_dev_list` property.
:param adaptive_tx_coalescing:
(optional test parameter) boolean to enable/disable TX adaptive
coalescing on the devices
:param adaptive_rx_coalescing:
(optional test parameter) boolean to enable/disable RX adaptive
coalescing on the devices
"""
adaptive_rx_coalescing = BoolParam(mandatory=False)
adaptive_tx_coalescing = BoolParam(mandatory=False)
@property
def coalescing_hw_config_dev_list(self):
"""
The value of this property is a list of devices for which the
adaptive coalescing features should be configured. It has to be
defined by a derived class.
"""
return []
def hw_config(self, config):
super().hw_config(config)
for param in ["adaptive_rx_coalescing", "adaptive_tx_coalescing"]:
param_value = getattr(self.params, param, None)
if param_value is not None:
self._configure_dev_attribute(
config, self.coalescing_hw_config_dev_list, param,
param_value)
def hw_deconfig(self, config):
for feature in ['adaptive_rx_coalescing', 'adaptive_tx_coalescing']:
self._deconfigure_dev_attribute(
config,
self.coalescing_hw_config_dev_list,
feature,
)
super().hw_deconfig(config)
def describe_hw_config(self, config):
desc = super().describe_hw_config(config)
for param in ["adaptive_rx_coalescing", "adaptive_tx_coalescing"]:
desc.extend(self._describe_dev_attribute(config, param))
return desc
class PauseFramesHWConfigMixin(BaseHWConfigMixin):
"""
This class is an extension to the :any:`BaseEnrtRecipe` class to configure
the Ethernet pause frames on the devices defined by
the :attr:`pause_frames_dev_list` property.
"""
rx_pause_frames = BoolParam(mandatory=False)
tx_pause_frames = BoolParam(mandatory=False)
@property
def pause_frames_dev_list(self):
"""
The value of this property is a list of devices for which the pause
frames should be configured. It has to be defined by a derived class.
"""
return []
def hw_config(self, config):
super().hw_config(config)
for param in ["rx_pause_frames", "tx_pause_frames"]:
param_value = getattr(self.params, param, None)
if param_value is not None:
self._configure_dev_attribute(
config,
self.pause_frames_dev_list,
param,
param_value
)
def hw_deconfig(self, config):
for param in ["rx_pause_frames", "tx_pause_frames"]:
self._deconfigure_dev_attribute(
config,
self.pause_frames_dev_list,
param
)
super().hw_deconfig(config)
def describe_hw_config(self, config):
desc = super().describe_hw_config(config)
for param in ["rx_pause_frames", "tx_pause_frames"]:
desc.extend(
self._describe_dev_attribute(config, param)
)
return desc
class IperfServer(IperfBase):
bind = IpParam()
port = IntParam()
cpu_bind = IntParam()
opts = StrParam()
oneoff = BoolParam(default=False)
_role = "server"
def _compose_cmd(self):
bind = ""
port = ""
if "bind" in self.params:
bind = "-B {}".format(self.params.bind)
if "port" in self.params:
port = "-p {}".format(self.params.port)
if "cpu_bind" in self.params:
cpu = "-A {:d}".format(self.params.cpu_bind)
else:
cpu = ""
if "oneoff" in self.params and self.params.oneoff:
oneoff = "-1"
cmd = "iperf3 -s {bind} -J {port} {cpu} {oneoff} {opts}".format(
bind=bind,
port=port,
cpu=cpu,
oneoff=oneoff,
opts=self.params.opts if "opts" in self.params else "")
return cmd
class DropCachesPerfTestMixin(BasePerfTestIterationTweakMixin):
"""
This mixin class is an extension to the :any:`BaseEnrtRecipe` class that can
be used to drop vm caches before running each iteration of the performance
measurements.
:param drop_caches:
(optional test parameter) a boolean, if set to True, the memory caches
are dropped otherwise the mixin has no effect
"""
drop_caches = BoolParam(default=False)
def generate_perf_test_iteration_tweak_description(self, perf_config):
description = super().generate_perf_test_iteration_tweak_description(
perf_config)
if self.params.drop_caches:
for host in self.matched:
description.append(
"dropped vm caches before iteration on host {}".format(
host.hostid))
else:
description.append("skipped dropping vm caches before iteration")
return description
def apply_perf_test_iteration_tweak(self, perf_config):
super().apply_perf_test_iteration_tweak(perf_config)
if self.params.drop_caches:
for host in self.matched:
host.run("echo 1 > /proc/sys/vm/drop_caches")
def remove_perf_test_iteration_tweak(self, perf_config):
super().remove_perf_test_iteration_tweak(perf_config)
class PerfReversibleFlowMixin(object):
""" Mixin class for reversing the performance test flows
This only really makes sense for recipes that have asymmetric endpoints.
For example:
SimpleNetworkRecipe is symmetrical since both endpoints are of the same type
(both plain interfaces).
TeamRecipe is asymmetrical because one endpoint is a team device and the
other is a plain interface.
So TeamRecipe could use this mixin to indicate that is can be reversed.
This can be controlled by the perf_reverse parameter:
:param perf_reverse:
Parameter used by the :any:`generate_flow_combinations` generator. To
specify that the flow of traffic between the endpoints should be reversed.
:type perf_reverse: :any:`BoolParam` (default False)
"""
perf_reverse = BoolParam(default=False)
def _create_perf_flow(self, perf_test, client_nic, client_bind, server_nic,
server_bind, msg_size) -> PerfFlow:
if self.params.perf_reverse:
return super()._create_perf_flow(perf_test, server_nic,
server_bind, client_nic,
client_bind, msg_size)
else:
return super()._create_perf_flow(perf_test, client_nic,
client_bind, server_nic,
server_bind, msg_size)
class DoubleTeamRecipe(CommonHWSubConfigMixin, OffloadSubConfigMixin,
BaseEnrtRecipe):
host1 = HostReq()
host1.eth0 = DeviceReq(label="tnet", driver=RecipeParam("driver"))
host1.eth1 = DeviceReq(label="tnet", driver=RecipeParam("driver"))
host2 = HostReq()
host2.eth0 = DeviceReq(label="tnet", driver=RecipeParam("driver"))
host2.eth1 = DeviceReq(label="tnet", driver=RecipeParam("driver"))
offload_combinations = Param(default=(
dict(gro="on", gso="on", tso="on", tx="on"),
dict(gro="off", gso="on", tso="on", tx="on"),
dict(gro="on", gso="off", tso="off", tx="on"),
dict(gro="on", gso="on", tso="off", tx="off")))
perf_reverse = BoolParam(default=True)
runner_name = StrParam(mandatory=True)
def test_wide_configuration(self):
host1, host2 = self.matched.host1, self.matched.host2
net_addr_1 = "192.168.10"
net_addr6_1 = "fc00:0:0:1"
for i, host in enumerate([host1, host2]):
#The config argument needs to be used with a team device
#normally (e.g to specify the runner mode), but it is not used
#here due to a bug in the TeamDevice module
host.team0 = TeamDevice()
for dev in [host.eth0, host.eth1]:
dev.down()
host.team0.slave_add(dev)
host.team0.ip_add(ipaddress(net_addr_1 + "." + str(i+1) +
"/24"))
host.team0.ip_add(ipaddress(net_addr6_1 + "::" + str(i+1) +
"/64"))
for dev in [host.eth0, host.eth1, host.team0]:
dev.up()
configuration = super().test_wide_configuration()
configuration.test_wide_devices = [host1.team0, host2.team0]
self.wait_tentative_ips(configuration.test_wide_devices)
return configuration
def generate_test_wide_description(self, config):
host1, host2 = self.matched.host1, self.matched.host2
desc = super().generate_test_wide_description(config)
desc += [
"\n".join([
"Configured {}.{}.ips = {}".format(
dev.host.hostid, dev.name, dev.ips
)
for dev in config.test_wide_devices
]),
"\n".join([
"Configured {}.{}.slaves = {}".format(
dev.host.hostid, dev.name,
['.'.join([dev.host.hostid, slave.name])
for slave in dev.slaves]
)
for dev in config.test_wide_devices
]),
"\n".join([
"Configured {}.{}.runner_name = {}".format(
dev.host.hostid, dev.name, dev.config
)
for dev in config.test_wide_devices
])
]
return desc
def test_wide_deconfiguration(self, config):
del config.test_wide_devices
super().test_wide_deconfiguration(config)
def generate_ping_endpoints(self, config):
return [(self.matched.host1.team0, self.matched.host2.team0),
(self.matched.host2.team0, self.matched.host1.team0)]
def generate_perf_endpoints(self, config):
return [(self.matched.host1.team0, self.matched.host2.team0),
(self.matched.host2.team0, self.matched.host1.team0)]
def wait_tentative_ips(self, devices):
def condition():
return all(
[not ip.is_tentative for dev in devices for ip in dev.ips]
)
self.ctl.wait_for_condition(condition, timeout=5)
@property
def offload_nics(self):
return [self.matched.host1.team0, self.matched.host2.team0]
@property
def mtu_hw_config_dev_list(self):
return [self.matched.host1.team0, self.matched.host2.team0]
@property
def coalescing_hw_config_dev_list(self):
host1, host2 = self.matched.host1, self.matched.host2
return [host1.eth0, host1.eth1, host2.eth0, host2.eth1]
@property
def dev_interrupt_hw_config_dev_list(self):
host1, host2 = self.matched.host1, self.matched.host2
return [host1.eth0, host1.eth1, host2.eth0, host2.eth1]
@property
def parallel_stream_qdisc_hw_config_dev_list(self):
host1, host2 = self.matched.host1, self.matched.host2
return [host1.eth0, host1.eth1, host2.eth0, host2.eth1]
class BaseEnrtRecipe(SctpFirewallPerfTestMixin, BaseSubConfigMixin,
PingTestAndEvaluate, PerfRecipe):
"""Base Recipe class for the ENRT recipe package
This class defines the shared *test* method defining the common test
procedure in a very generic way. This common test procedure involves a
single main *test_wide* configuration that is different for every specific
scenario. After the main configuration there is usually a loop of several
minor *sub* configrations types that can take different values to slightly
change the tested use cases.
Finally, for each combination of a **test_wide** + **sub** configuration we
do a several ping connection test and several performance measurement tests.
**test_wide** and **sub** configurations are implemented with **context
manager** methods which ensure that if any exceptions are raised (for
example because of a bug in the recipe) that deconfiguration is called.
Both **test_wide** and **sub** configurations are to be implemented in
different classes, the BaseEnrtRecipe class only defines the common API and
the base versions of the relevant methods.
Test wide configuration is implemented via the following methods:
* :any:`test_wide_configuration`
* :any:`test_wide_deconfiguration`
* :any:`generate_test_wide_description`
Sub configurations are **mixed into** classes defining the specific
scenario that is being tested. Various sub configurations are implemented as
individual Python **Mixin** classes in the
:any:`ConfigMixins<config_mixins>` package. These make use of Pythons
collaborative inheritance by calling the `super` function in a specific way.
The "machinery" for that is defined in the :any:`BaseSubConfigMixin` class.
It is then used in this class from the `test` method loop.
:param driver:
The driver parameter is used to modify the hw network requirements,
specifically to request Devices using the specified driver. This is
common enough in the Enrt recipes that it can be part of the Base class.
:type driver: :any:`StrParam` (default "ixgbe")
:param ip_versions:
Parameter that determines which IP protocol versions will be tested.
:type ip_versions: Tuple[Str] (default ("ipv4", "ipv6"))
:param ping_parallel:
Parameter used by the :any:`generate_ping_configurations` generator.
Tells the generator method to create :any:`PingConf` objects that will
be run in parallel.
:type ping_parallel: :any:`BoolParam` (default False)
:param ping_bidirect:
Parameter used by the :any:`generate_ping_configurations` generator.
Tells the generator method to create :any:`PingConf` objects for both
directions between the ping endpoints.
:type ping_bidirect: :any:`BoolParam` (default False)
:param ping_count:
Parameter used by the :any:`generate_ping_configurations` generator.
Tells the generator how many pings should be sent for each ping test.
:type ping_count: :any:`IntParam` (default 100)
:param ping_interval:
Parameter used by the :any:`generate_ping_configurations` generator.
Tells the generator how fast should the pings be sent in each ping test.
:type ping_interval: :any:`FloatParam` (default 0.2)
:param ping_psize:
Parameter used by the :any:`generate_ping_configurations` generator.
Tells the generator how big should the pings packets be in each ping
test.
:type ping_psize: :any:`IntParam` (default None)
:param perf_tests:
Parameter used by the :any:`generate_flow_combinations` generator.
Tells the generator what types of network flow measurements to generate
perf test configurations for.
:type perf_tests: Tuple[str] (default ("tcp_stream", "udp_stream",
"sctp_stream"))
:param perf_tool_cpu:
Parameter used by the :any:`generate_flow_combinations` generator. To
indicate that the flow measurement should be pinned to a specific CPU
core.
:type perf_tool_cpu: :any:`IntParam` (optional parameter)
:param perf_duration:
Parameter used by the :any:`generate_perf_configurations` generator. To
specify the duration of the performance measurements, in seconds.
:type perf_duration: :any:`IntParam` (default 60)
:param perf_iterations:
Parameter used by the :any:`generate_perf_configurations` generator. To
specify how many times should each performance measurement be repeated
to generate cumulative results which can be statistically analyzed.
:type perf_iterations: :any:`IntParam` (default 5)
:param perf_parallel_streams:
Parameter used by the :any:`generate_flow_combinations` generator. To
specify how many parallel streams of the same network flow should be
measured at the same time.
:type perf_parallel_streams: :any:`IntParam` (default 1)
:param perf_msg_sizes:
Parameter used by the :any:`generate_flow_combinations` generator. To
specify what different message sizes (in bytes) used generated for the
network flow should be tested - each message size resulting in a
separate performance measurement.
:type perf_msg_sizes: List[Int] (default [123])
:param net_perf_tool:
Parameter used by the :any:`generate_perf_configurations` generator to
create a PerfRecipeConf object.
Specifies a network flow measurement class that accepts :any:`PerfFlow`
objects and can be used to measure those specified flows
:type net_perf_tool: :any:`BaseFlowMeasurement` (default
IperfFlowMeasurement)
:param cpu_perf_tool:
Parameter used by the :any:`generate_perf_configurations` generator to
create a PerfRecipeConf object.
Specifies a cpu measurement class that can be used to measure CPU
utilization on specified hosts.
:type cpu_perf_tool: :any:`BaseCPUMeasurement` (default StatCPUMeasurement)
"""
driver = StrParam(default="ixgbe")
#common test parameters
ip_versions = Param(default=("ipv4", "ipv6"))
#common ping test params
ping_parallel = BoolParam(default=False)
ping_bidirect = BoolParam(default=False)
ping_count = IntParam(default=100)
ping_interval = FloatParam(default=0.2)
ping_psize = IntParam(default=56)
#common perf test params
perf_tests = Param(default=("tcp_stream", "udp_stream", "sctp_stream"))
perf_tool_cpu = IntParam(mandatory=False)
perf_duration = IntParam(default=60)
perf_iterations = IntParam(default=5)
perf_parallel_streams = IntParam(default=1)
perf_msg_sizes = ListParam(default=[123])
net_perf_tool = Param(default=IperfFlowMeasurement)
cpu_perf_tool = Param(default=StatCPUMeasurement)
def test(self):
"""Main test loop shared by all the Enrt recipes
The test loop involves a single application of a **test_wide**
configuration, then a loop over multiple **sub** configurations that
involves:
* creating the combined sub configuration of all available SubConfig
Mixin classes via :any:`generate_sub_configurations`
* applying the generated sub configuration via the :any:`_sub_context`
context manager method
* running tests
* removing the current sub configuration via the :any:`_sub_context`
context manager method
"""
with self._test_wide_context() as main_config:
for sub_config in self.generate_sub_configurations(main_config):
with self._sub_context(sub_config) as recipe_config:
self.do_tests(recipe_config)
@contextmanager
def _test_wide_context(self):
config = self.test_wide_configuration()
self.describe_test_wide_configuration(config)
try:
yield config
finally:
self.test_wide_deconfiguration(config)
def test_wide_configuration(self):
"""Creates an empty :any:`EnrtConfiguration` object
This is again used in potential collaborative inheritance design that
may potentially be useful for Enrt recipes. Derived classes will each
individually add their own values to the instance created here. This way
the complete test wide configuration is tracked in a single object.
:return: returns a config object that tracks the applied configuration
that can be used during testing to inspect the current state and
make test decisions based on it.
:rtype: :any:`EnrtConfiguration`
Example::
class Derived:
def test_wide_configuration():
config = super().test_wide_configuration()
# ... configure something
config.something = what_was_configured
return config
"""
return EnrtConfiguration()
def test_wide_deconfiguration(self, config):
"""Base deconfiguration method.
In the base class this should maybe only check if there's any leftover
configuration and warn about it. In derived classes this can be
overriden to take care of deconfiguring what was configured in the
respective test_wide_configuration method.
Example::
class Derived:
def test_wide_deconfiguration(config):
# ... deconfigure something
del config.something #cleanup tracking
return super().test_wide_deconfiguration()
"""
#TODO check if anything is still applied and throw exception?
return
def describe_test_wide_configuration(self, config):
"""Describes the current test wide configuration
Creates a new result object that contains the description of the full
test wide configuration applied by all the
:any:`test_wide_configuration` methods in the class hierarchy.
The description needs to be generated by the
:any:`generate_test_wide_description` method. Additionally the
description contains the state of all the parameters and their values
passed to the recipe class instance during initialization.
"""
description = self.generate_test_wide_description(config)
self.add_result(
True, "Summary of used Recipe parameters:\n{}".format(
pprint.pformat(self.params._to_dict())))
self.add_result(True, "\n".join(description))
def generate_test_wide_description(self, config):
"""Generates the test wide configuration description
Another class inteded to be used with the collaborative version of the
`super` method to cumulatively desribe the full test wide configuration
that was applied through multiple classes.
The base class version of this method creates the initial list of
strings containing just the header line. Each string added to this list
will later be printed on its own line.
:return: list of strings, each representing a single line
:rtype: List[str]
Example::
class Derived:
def generate_sub_configuration_description(config):
desc = super().generate_sub_configuration_description(config)
desc.append("Configured something: {}".format(config.something))
return desc
"""
return [
"Testwide configuration for recipe {} description:".format(
self.__class__.__name__)
]
@contextmanager
def _sub_context(self, config):
self.apply_sub_configuration(config)
self.describe_sub_configuration(config)
try:
yield config
finally:
self.remove_sub_configuration(config)
def describe_sub_configuration(self, config):
description = self.generate_sub_configuration_description(config)
self.add_result(True, "\n".join(description))
def do_tests(self, recipe_config):
"""Entry point for actual tests
The common scenario is to do ping and performance tests, however the
method can be overriden to add more tests if needed.
"""
self.do_ping_tests(recipe_config)
self.do_perf_tests(recipe_config)
def do_ping_tests(self, recipe_config):
"""Ping testing loop
Loops over all various ping configurations generated by the
:any:`generate_ping_configurations` method, then uses the PingRecipe
methods to execute, report and evaluate the results.
"""
for ping_configs in self.generate_ping_configurations(recipe_config):
result = self.ping_test(ping_configs)
self.ping_report_and_evaluate(result)
def describe_perf_test_tweak(self, perf_config):
description = self.generate_perf_test_tweak_description(perf_config)
self.add_result(True, "\n".join(description))
def do_perf_tests(self, recipe_config):
"""Performance testing loop
Loops over all various perf configurations generated by the
:any:`generate_perf_configurations` method, then uses the PerfRecipe
methods to execute, report and evaluate the results.
"""
for perf_config in self.generate_perf_configurations(recipe_config):
self.apply_perf_test_tweak(perf_config)
self.describe_perf_test_tweak(perf_config)
try:
result = self.perf_test(perf_config)
self.perf_report_and_evaluate(result)
finally:
self.remove_perf_test_tweak(perf_config)
def generate_ping_configurations(self, config):
"""Base ping test configuration generator
The generator loops over all endpoint pairs to test ping between
(generated by the :any:`generate_ping_endpoints` method) then over all
the selected :any:`ip_versions` and finally over all the IP addresses
that fit those criteria.
:return: list of Ping configurations to test in parallel
:rtype: List[:any:`PingConf`]
"""
for endpoints in self.generate_ping_endpoints(config):
for ipv in self.params.ip_versions:
if ipv == "ipv6" and not endpoints.reachable:
continue
ip_filter = {}
if ipv == "ipv4":
ip_filter.update(family=AF_INET)
elif ipv == "ipv6":
ip_filter.update(family=AF_INET6)
ip_filter.update(is_link_local=False)
endpoint1, endpoint2 = endpoints.endpoints
endpoint1_ips = endpoint1.ips_filter(**ip_filter)
endpoint2_ips = endpoint2.ips_filter(**ip_filter)
if len(endpoint1_ips) != len(endpoint2_ips):
raise LnstError(
"Source/destination ip lists are of different size.")
ping_conf_list = []
for src_addr, dst_addr in zip(endpoint1_ips, endpoint2_ips):
pconf = PingConf(
client=endpoint1.netns,
client_bind=src_addr,
destination=endpoint2.netns,
destination_address=dst_addr,
count=self.params.ping_count,
interval=self.params.ping_interval,
size=self.params.ping_psize,
)
ping_evaluators = self.generate_ping_evaluators(
pconf, endpoints)
pconf.register_evaluators(ping_evaluators)
ping_conf_list.append(pconf)
if self.params.ping_bidirect:
ping_conf_list.append(self._create_reverse_ping(pconf))
if not self.params.ping_parallel:
break
yield ping_conf_list
def generate_ping_endpoints(self, config):
"""Generator for ping endpoints
To be overriden by a derived class.
:return: list of device pairs
:rtype: List[Tuple[:any:`Device`, :any:`Device`]]
"""
return []
def generate_ping_evaluators(self, pconf, endpoints):
return [RatePingEvaluator(min_rate=50)]
def generate_perf_configurations(self, config):
"""Base perf test configuration generator
The generator loops over all flow combinations to measure performance
for (generated by the :any:`generate_flow_combinations` method). In
addition to that during each flow combination measurement we add CPU
utilization measurement to run on the background.
Finally for each generated perf test configuration we register
measurement evaluators based on the :any:`cpu_perf_evaluators` and
:any:`net_perf_evaluators` properties.
:return: list of Perf test configurations
:rtype: List[:any:`PerfRecipeConf`]
"""
for flows in self.generate_flow_combinations(config):
perf_recipe_conf = dict(
recipe_config=config,
flows=flows,
)
flows_measurement = self.params.net_perf_tool(
flows, perf_recipe_conf)
cpu_measurement_hosts = set()
for flow in flows:
cpu_measurement_hosts.add(flow.generator)
cpu_measurement_hosts.add(flow.receiver)
cpu_measurement = self.params.cpu_perf_tool(
cpu_measurement_hosts,
perf_recipe_conf,
)
perf_conf = PerfRecipeConf(
measurements=[cpu_measurement, flows_measurement],
iterations=self.params.perf_iterations,
)
perf_conf.register_evaluators(cpu_measurement,
self.cpu_perf_evaluators)
perf_conf.register_evaluators(flows_measurement,
self.net_perf_evaluators)
yield perf_conf
def generate_flow_combinations(self, config):
"""Base flow combination generator
The generator loops over all endpoint pairs to test performance between
(generated by the :any:`generate_perf_endpoints` method) then over all
the selected :any:`ip_versions` and uses the first IP address fitting
these criteria. Then the generator loops over the selected performance
tests as selected via :any:`perf_tests`, then message sizes from
:any:`msg_sizes`.
:return: list of Flow combinations to measure in parallel
:rtype: List[:any:`PerfFlow`]
"""
for client_nic, server_nic in self.generate_perf_endpoints(config):
for ipv in self.params.ip_versions:
ip_filter = {}
if ipv == "ipv4":
ip_filter.update(family=AF_INET)
elif ipv == "ipv6":
ip_filter.update(family=AF_INET6)
ip_filter.update(is_link_local=False)
client_bind = client_nic.ips_filter(**ip_filter)[0]
server_bind = server_nic.ips_filter(**ip_filter)[0]
for perf_test in self.params.perf_tests:
for size in self.params.perf_msg_sizes:
yield [
self._create_perf_flow(
perf_test,
client_nic,
client_bind,
server_nic,
server_bind,
size,
)
]
def _create_perf_flow(self, perf_test, client_nic, client_bind, server_nic,
server_bind, msg_size) -> PerfFlow:
"""
Wrapper to create a PerfFlow. Mixins that want to change this behavior (for example, to reverse the direction)
can override this method as an alternative to overriding :any:`generate_flow_combinations`
"""
cpupin = self.params.perf_tool_cpu if "perf_tool_cpu" in self.params else None
return PerfFlow(
type=perf_test,
generator=client_nic.netns,
generator_bind=client_bind,
generator_nic=client_nic,
receiver=server_nic.netns,
receiver_bind=server_bind,
receiver_nic=server_nic,
msg_size=msg_size,
duration=self.params.perf_duration,
parallel_streams=self.params.perf_parallel_streams,
cpupin=cpupin,
)
def generate_perf_endpoints(self, config):
"""Generator for perf endpoints
To be overriden by a derived class.
:return: list of device pairs
:rtype: List[Tuple[:any:`Device`, :any:`Device`]]
"""
return []
@property
def cpu_perf_evaluators(self):
"""CPU measurement evaluators
To be overriden by a derived class. Returns the list of evaluators to
use for CPU utilization measurement evaluation.
:return: a list of cpu evaluator objects
:rtype: List[BaseEvaluator]
"""
return []
@property
def net_perf_evaluators(self):
"""Network flow measurement evaluators
To be overriden bby a derived class. Returns the list of evaluators to
use for Network flow measurement evaluation.
:return: a list of flow evaluator objects
:rtype: List[BaseEvaluator]
"""
return [NonzeroFlowEvaluator()]
def wait_tentative_ips(self, devices):
def condition():
return all(
[not ip.is_tentative for dev in devices for ip in dev.ips])
self.ctl.wait_for_condition(condition, timeout=5)
def _create_reverse_ping(self, pconf):
return PingConf(
client=pconf.destination,
client_bind=pconf.destination_address,
destination=pconf.client,
destination_address=pconf.client_bind,
count=pconf.ping_count,
interval=pconf.ping_interval,
size=pconf.ping_psize,
)
class PacketAssert(BaseTestModule):
interface = DeviceParam(mandatory=True)
p_filter = StrParam(default="")
grep_for = ListParam(default=[])
promiscuous = BoolParam(default=False)
_grep_exprs = []
_p_recv = 0
def _prepare_grep_exprs(self):
for expr in self.params.grep_for:
if expr is not None:
self._grep_exprs.append(expr)
def _compose_cmd(self):
cmd = "tcpdump"
if not self.params.promiscuous:
cmd += " -p"
iface = self.params.interface.name
filt = self.params.p_filter
cmd += ' -nn -i %s "%s"' % (iface, filt)
return cmd
def _check_line(self, line):
if line != "":
for exp in self._grep_exprs:
if not re.search(exp, line):
return
self._p_recv += 1
def run(self):
self._res_data = {}
if not is_installed("tcpdump"):
self._res_data["msg"] = "tcpdump is not installed on this machine!"
logging.error(self._res_data["msg"])
return False
self._prepare_grep_exprs()
cmd = self._compose_cmd()
logging.debug("compiled command: {}".format(cmd))
packet_assert_process = subprocess.Popen(
cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True,
)
try:
self.wait_for_interrupt()
except:
raise LnstError("Could not handle interrupt properly.")
stdout, stderr = packet_assert_process.communicate()
stdout = stdout.decode()
stderr = stderr.decode()
self._res_data["stderr"] = stderr
# tcpdump always reports information to stderr, there may be actual
# errors but also just generic debug information
logging.debug(self._res_data["stderr"])
for line in stdout.split("\n"):
self._check_line(line)
logging.debug("Capturing finised. Received %d packets." % self._p_recv)
self._res_data["p_recv"] = self._p_recv
if packet_assert_process.returncode != 0:
return False
else:
return True
class PacketAssert(BaseTestModule):
interface = DeviceParam(mandatory=True)
p_filter = StrParam(default='')
grep_for = ListParam(default=[])
promiscuous = BoolParam(default=False)
_grep_exprs = []
_p_recv = 0
def _prepare_grep_exprs(self):
for expr in self.params.grep_for:
if expr is not None:
self._grep_exprs.append(expr)
def _compose_cmd(self):
cmd = "tcpdump"
if not self.params.promiscuous:
cmd += " -p"
iface = self.params.interface.name
filt = self.params.p_filter
cmd += " -nn -i %s \"%s\"" % (iface, filt)
return cmd
def _check_line(self, line):
if line != "":
for exp in self._grep_exprs:
if not re.search(exp, line):
return
self._p_recv += 1
def _is_real_err(self, err):
ignore_exprs = [r"tcpdump: verbose output suppressed, use -v or -vv for full protocol decode",
r"listening on %s, link-type .* \(.*\), capture size [0-9]* bytes" %
self.params.interface.name, r"\d+ packets captured",
r"\d+ packets received by filter", r"\d+ packets dropped by kernel"]
for line in err.split('\n'):
if not line:
continue
match = False
for expr in ignore_exprs:
if re.search(expr, line):
match = True
break
if not match:
return True
return False
def run(self):
self._res_data = {}
if not is_installed("tcpdump"):
self._res_data["msg"] = "tcpdump is not installed on this machine!"
logging.error(self._res_data["msg"])
return False
self._prepare_grep_exprs()
cmd = self._compose_cmd()
logging.debug("compiled command: {}".format(cmd))
packet_assert_process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, close_fds=True)
try:
self.wait_for_interrupt()
except:
raise LnstError("Could not handle interrupt properly.")
with packet_assert_process.stdout, packet_assert_process.stderr:
stderr=packet_assert_process.stderr.read().decode()
stdout=packet_assert_process.stdout.read().decode()
self._res_data["stderr"] = stderr
if self._is_real_err(stderr):
self._res_data["msg"] = "errors reported by tcpdump"
logging.error(self._res_data["msg"])
logging.error(self._res_data["stderr"])
return False
for line in stdout.split("\n"):
self._check_line(line)
logging.debug("Capturing finised. Received %d packets." % self._p_recv)
self._res_data["p_recv"] = self._p_recv
return True
class IperfClient(IperfBase):
server = HostnameOrIpParam(mandatory=True)
duration = IntParam(default=10)
udp = BoolParam(default=False)
sctp = BoolParam(default=False)
port = IntParam()
blksize = IntParam()
mss = IntParam()
cpu_bind = IntParam()
parallel = IntParam()
opts = StrParam()
_role = "client"
def __init__(self, **kwargs):
super(IperfClient, self).__init__(**kwargs)
if self.params.udp and self.params.sctp:
raise TestModuleError(
"Parameters udp and sctp are mutually exclusive!")
def runtime_estimate(self):
_duration_overhead = 5
return self.params.duration + _duration_overhead
def _compose_cmd(self):
port = ""
if "port" in self.params:
port = "-p {:d}".format(self.params.port)
if "blksize" in self.params:
blksize = "-l {:d}".format(self.params.blksize)
else:
blksize = ""
if "mss" in self.params:
mss = "-M {:d}".format(self.params.mss)
else:
mss = ""
if "cpu_bind" in self.params:
cpu = "-A {:d}".format(self.params.cpu_bind)
else:
cpu = ""
if "parallel" in self.params:
parallel = "-P {:d}".format(self.params.parallel)
else:
parallel = ""
if self.params.udp:
test = "--udp"
elif self.params.sctp:
test = "--sctp"
elif self.params.mptcp:
test = "--multipath"
else:
test = ""
cmd = ("iperf3 -c {server} -b 0/1000 -J -t {duration}"
" {cpu} {test} {mss} {blksize} {parallel} {port}"
" {opts}".format(
server=self.params.server,
duration=self.params.duration,
cpu=cpu,
test=test,
mss=mss,
blksize=blksize,
parallel=parallel,
port=port,
opts=self.params.opts if "opts" in self.params else ""))
return cmd
class IperfBase(BaseTestModule):
mptcp = BoolParam(default=False)
def run(self):
self._res_data = {}
if not is_installed("iperf3"):
self._res_data["msg"] = "Iperf is not installed on this machine!"
logging.error(self._res_data["msg"])
return False
cmd = self._compose_cmd()
logging.debug("compiled command: %s" % cmd)
logging.debug("running as {} ...".format(self._role))
server = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
try:
stdout, stderr = server.communicate()
stdout = stdout.decode()
stderr = stderr.decode()
except KeyboardInterrupt:
pass
try:
self._res_data["data"] = json.loads(stdout)
except JSONDecodeError:
self._res_data["msg"] = "Error while parsing the iperf json output"
self._res_data["data"] = stdout
self._res_data["stderr"] = stderr
logging.error(self._res_data["msg"])
return False
try:
self._check_json_sanity()
except:
self._res_data["msg"] = "Iperf provided incomplete json data"
self._res_data["data"] = stdout
self._res_data["stderr"] = stderr
logging.error(self._res_data["msg"])
return False
self._res_data["stderr"] = stderr
if stderr != "":
self._res_data["msg"] = "errors reported by iperf"
logging.error(self._res_data["msg"])
logging.error(self._res_data["stderr"])
if server.returncode > 0:
self._res_data["msg"] = "{} returncode = {}".format(
self._role, server.returncode)
logging.error(self._res_data["msg"])
return False
return True
def _check_json_sanity(self):
data = self._res_data["data"]
if "start" not in data:
raise Exception()
if "end" not in data:
raise Exception()
if len(data["intervals"]) == 0:
raise Exception()
if "streams" not in data["end"]:
raise Exception
class DisableTurboboostMixin(BaseSubConfigMixin):
"""
This mixin class is an extension to the :any:`BaseEnrtRecipe` class that can
be used to disable CPU turboboost on hosts before running the tests.
Any recipe that wants to use the mixin must define the
:attr:`disable_turboboost_host_list` property first.
Note: The mixin uses intel_pstate sysfs interface to disable the CPU feature
and so it is usable only by systems with Intel CPUs.
:param disable_turboost:
(optional test parameter) boolean to control the CPU turboboost. When
the parameter is set to **True** the CPU turboboost is disabled on all
hosts defined by :attr:`disable_turboboost_host_list` property. Otherwise
this mixin has no effect.
"""
disable_turboboost = BoolParam(default=False)
@property
def disable_turboboost_host_list(self):
"""
The value of this property is a list of hosts for which the CPU turboboost
should be turned off. Derived class can override this property.
"""
return []
def _is_turboboost_supported(self, host):
file_check = host.run(
"ls /sys/devices/system/cpu/intel_pstate/no_turbo",
job_level=ResultLevel.DEBUG)
return file_check.passed
def apply_sub_configuration(self, config):
super().apply_sub_configuration(config)
if self.params.disable_turboboost:
for host in self.disable_turboboost_host_list:
if self._is_turboboost_supported(host):
# TODO: save previous state
host.run(
"echo 1 > /sys/devices/system/cpu/intel_pstate/no_turbo"
)
def generate_sub_configuration_description(self, config):
description = super().generate_sub_configuration_description(config)
if self.params.disable_turboboost:
for host in self.disable_turboboost_host_list:
if self._is_turboboost_supported(host):
description.append(
"turboboost disabled through intel_pstate on {}".
format(host.hostid))
else:
description.append("warning: user requested to disable turboboost "\
"through intel_pstate but the sysfs file is not available "\
"on host {}".format(host.hostid))
else:
description.append(
"configuration of turboboost through intel_pstate skipped")
return description
def remove_sub_configuration(self, config):
if self.params.disable_turboboost:
for host in self.disable_turboboost_host_list:
if self._is_turboboost_supported(host):
# TODO: restore previous state
host.run(
"echo 0 > /sys/devices/system/cpu/intel_pstate/no_turbo"
)
return super().remove_sub_configuration(config)
class BaseEnrtRecipe(BaseSubConfigMixin, PingTestAndEvaluate, PerfRecipe):
#common requirements parameters
driver = StrParam(default="ixgbe")
#common test parameters
ip_versions = Param(default=("ipv4", "ipv6"))
#common ping test params
ping_parallel = BoolParam(default=False)
ping_bidirect = BoolParam(default=False)
ping_count = IntParam(default=100)
ping_interval = StrParam(default=0.2)
ping_psize = IntParam(default=None)
#common perf test params
perf_tests = Param(default=("tcp_stream", "udp_stream", "sctp_stream"))
perf_tool_cpu = IntParam(mandatory=False)
perf_duration = IntParam(default=60)
perf_iterations = IntParam(default=5)
perf_parallel_streams = IntParam(default=1)
perf_msg_sizes = ListParam(default=[123])
perf_reverse = BoolParam(default=False)
net_perf_tool = Param(default=IperfFlowMeasurement)
cpu_perf_tool = Param(default=StatCPUMeasurement)
def test(self):
with self._test_wide_context() as main_config:
for sub_config in self.generate_sub_configurations(main_config):
with self._sub_context(sub_config) as recipe_config:
self.do_tests(recipe_config)
@contextmanager
def _test_wide_context(self):
config = self.test_wide_configuration()
self.describe_test_wide_configuration(config)
try:
yield config
finally:
self.test_wide_deconfiguration(config)
def test_wide_configuration(self):
return EnrtConfiguration()
def test_wide_deconfiguration(self, config):
#TODO check if anything is still applied and throw exception?
return
def describe_test_wide_configuration(self, config):
description = self.generate_test_wide_description(config)
self.add_result(
True, "Summary of used Recipe parameters:\n{}".format(
pprint.pformat(self.params._to_dict())))
self.add_result(True, "\n".join(description))
def generate_test_wide_description(self, config):
return [
"Testwide configuration for recipe {} description:".format(
self.__class__.__name__)
]
@contextmanager
def _sub_context(self, config):
self.apply_sub_configuration(config)
self.describe_sub_configuration(config)
try:
yield config
finally:
self.remove_sub_configuration(config)
def describe_sub_configuration(self, config):
description = self.generate_sub_configuration_description(config)
self.add_result(True, "\n".join(description))
def generate_sub_configuration_description(self, config):
return ["Sub configuration description:"]
def do_tests(self, recipe_config):
self.do_ping_tests(recipe_config)
self.do_perf_tests(recipe_config)
def do_ping_tests(self, recipe_config):
for ping_config in self.generate_ping_configurations(recipe_config):
result = self.ping_test(ping_config)
self.ping_evaluate_and_report(ping_config, result)
def do_perf_tests(self, recipe_config):
for perf_config in self.generate_perf_configurations(recipe_config):
result = self.perf_test(perf_config)
self.perf_report_and_evaluate(result)
def generate_ping_configurations(self, config):
for endpoint1, endpoint2 in self.generate_ping_endpoints(config):
for ipv in self.params.ip_versions:
ip_filter = {}
if ipv == "ipv4":
ip_filter.update(family=AF_INET)
elif ipv == "ipv6":
ip_filter.update(family=AF_INET6)
ip_filter.update(is_link_local=False)
endpoint1_ips = endpoint1.ips_filter(**ip_filter)
endpoint2_ips = endpoint2.ips_filter(**ip_filter)
if len(endpoint1_ips) != len(endpoint2_ips):
raise LnstError(
"Source/destination ip lists are of different size.")
ping_conf_list = []
for src_addr, dst_addr in zip(endpoint1_ips, endpoint2_ips):
pconf = PingConf(
client=endpoint1.netns,
client_bind=src_addr,
destination=endpoint2.netns,
destination_address=dst_addr,
count=self.params.ping_count,
interval=self.params.ping_interval,
size=self.params.ping_psize,
)
ping_conf_list.append(pconf)
if self.params.ping_bidirect:
ping_conf_list.append(self._create_reverse_ping(pconf))
if not self.params.ping_parallel:
break
yield ping_conf_list
def generate_ping_endpoints(self, config):
return []
def generate_perf_configurations(self, config):
for flows in self.generate_flow_combinations(config):
perf_recipe_conf = dict(
recipe_config=config,
flows=flows,
)
flows_measurement = self.params.net_perf_tool(
flows, perf_recipe_conf)
cpu_measurement_hosts = set()
for flow in flows:
cpu_measurement_hosts.add(flow.generator)
cpu_measurement_hosts.add(flow.receiver)
cpu_measurement = self.params.cpu_perf_tool(
cpu_measurement_hosts,
perf_recipe_conf,
)
perf_conf = PerfRecipeConf(
measurements=[cpu_measurement, flows_measurement],
iterations=self.params.perf_iterations,
)
perf_conf.register_evaluators(cpu_measurement,
self.cpu_perf_evaluators)
perf_conf.register_evaluators(flows_measurement,
self.net_perf_evaluators)
yield perf_conf
def generate_flow_combinations(self, config):
for client_nic, server_nic in self.generate_perf_endpoints(config):
for ipv in self.params.ip_versions:
if ipv == "ipv4":
family = AF_INET
elif ipv == "ipv6":
family = AF_INET6
client_bind = client_nic.ips_filter(family=family)[0]
server_bind = server_nic.ips_filter(family=family)[0]
for perf_test in self.params.perf_tests:
for size in self.params.perf_msg_sizes:
flow = PerfFlow(
type=perf_test,
generator=client_nic.netns,
generator_bind=client_bind,
receiver=server_nic.netns,
receiver_bind=server_bind,
msg_size=size,
duration=self.params.perf_duration,
parallel_streams=self.params.perf_parallel_streams,
cpupin=self.params.perf_tool_cpu
if "perf_tool_cpu" in self.params else None)
yield [flow]
if self.params.perf_reverse:
reverse_flow = self._create_reverse_flow(flow)
yield [reverse_flow]
def generate_perf_endpoints(self, config):
return []
@property
def cpu_perf_evaluators(self):
return []
@property
def net_perf_evaluators(self):
return [NonzeroFlowEvaluator()]
def _create_reverse_flow(self, flow):
rev_flow = PerfFlow(type=flow.type,
generator=flow.receiver,
generator_bind=flow.receiver_bind,
receiver=flow.generator,
receiver_bind=flow.generator_bind,
msg_size=flow.msg_size,
duration=flow.duration,
parallel_streams=flow.parallel_streams,
cpupin=flow.cpupin)
return rev_flow
def _create_reverse_ping(self, pconf):
return PingConf(
client=pconf.destination,
client_bind=pconf.destination_address,
destination=pconf.client,
destination_address=pconf.client_bind,
count=pconf.ping_count,
interval=pconf.ping_interval,
size=pconf.ping_psize,
)