X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FTrafficGenerator.py;h=c5192e263db32759e5c792767aeea0e9c05571f7;hb=9378751a08ca5660886927f5502dcef19bc7f51c;hp=2e9b787321f0eabf8708ca7b5c98feb83ad035f4;hpb=ff820e3d53434889aacde2373314c3be8d00f765;p=csit.git diff --git a/resources/libraries/python/TrafficGenerator.py b/resources/libraries/python/TrafficGenerator.py index 2e9b787321..c5192e263d 100644 --- a/resources/libraries/python/TrafficGenerator.py +++ b/resources/libraries/python/TrafficGenerator.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019 Cisco and/or its affiliates. +# Copyright (c) 2020 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -18,18 +18,20 @@ import time from robot.api import logger from robot.libraries.BuiltIn import BuiltIn -from .DropRateSearch import DropRateSearch from .Constants import Constants -from .ssh import SSH, exec_cmd_no_error -from .topology import NodeType -from .topology import NodeSubTypeTG -from .topology import Topology +from .CpuUtils import CpuUtils +from .DropRateSearch import DropRateSearch from .MLRsearch.AbstractMeasurer import AbstractMeasurer from .MLRsearch.MultipleLossRatioSearch import MultipleLossRatioSearch from .MLRsearch.ReceiveRateMeasurement import ReceiveRateMeasurement from .PLRsearch.PLRsearch import PLRsearch +from .OptionString import OptionString +from .ssh import exec_cmd_no_error, exec_cmd +from .topology import NodeType +from .topology import NodeSubTypeTG +from .topology import Topology -__all__ = ['TGDropRateSearchImpl', 'TrafficGenerator', 'OptimizedSearch'] +__all__ = [u"TGDropRateSearchImpl", u"TrafficGenerator", u"OptimizedSearch"] def check_subtype(node): @@ -44,27 +46,28 @@ def check_subtype(node): :rtype: NodeSubTypeTG :raises RuntimeError: If node is not supported, message explains how. """ - if node.get('type') is None: - raise RuntimeError('Node type is not defined') + if node.get(u"type") is None: + msg = u"Node type is not defined" elif node['type'] != NodeType.TG: - raise RuntimeError('Node type is {typ!r}, not a TG'.format( - typ=node['type'])) - elif node.get('subtype') is None: - raise RuntimeError('TG subtype is not defined') - elif node['subtype'] == NodeSubTypeTG.TREX: + msg = f"Node type is {node[u'type']!r}, not a TG" + elif node.get(u"subtype") is None: + msg = u"TG subtype is not defined" + elif node[u"subtype"] != NodeSubTypeTG.TREX: + msg = f"TG subtype {node[u'subtype']!r} is not supported" + else: return NodeSubTypeTG.TREX - raise RuntimeError('TG subtype {sub!r} is not supported'.format( - sub=node['subtype'])) + raise RuntimeError(msg) class TGDropRateSearchImpl(DropRateSearch): """Drop Rate Search implementation.""" - def __init__(self): - super(TGDropRateSearchImpl, self).__init__() + # def __init__(self): + # super(TGDropRateSearchImpl, self).__init__() - def measure_loss(self, rate, frame_size, loss_acceptance, - loss_acceptance_type, traffic_profile, skip_warmup=False): + def measure_loss( + self, rate, frame_size, loss_acceptance, loss_acceptance_type, + traffic_profile, skip_warmup=False): """Runs the traffic and evaluate the measured results. :param rate: Offered traffic load. @@ -72,7 +75,7 @@ class TGDropRateSearchImpl(DropRateSearch): :param loss_acceptance: Permitted drop ratio or frames count. :param loss_acceptance_type: Type of permitted loss. :param traffic_profile: Module name as a traffic profile identifier. - See resources/traffic_profiles/trex for implemented modules. + See GPL/traffic_profiles/trex for implemented modules. :param skip_warmup: Start TRex without warmup traffic if true. :type rate: float :type frame_size: str @@ -88,24 +91,29 @@ class TGDropRateSearchImpl(DropRateSearch): # we need instance of TrafficGenerator instantiated by Robot Framework # to be able to use trex_stl-*() tg_instance = BuiltIn().get_library_instance( - 'resources.libraries.python.TrafficGenerator') + u"resources.libraries.python.TrafficGenerator" + ) subtype = check_subtype(tg_instance.node) if subtype == NodeSubTypeTG.TREX: unit_rate = str(rate) + self.get_rate_type_str() if skip_warmup: tg_instance.trex_stl_start_remote_exec( self.get_duration(), unit_rate, frame_size, traffic_profile, - warmup_time=0.0) + warmup_time=0.0 + ) else: tg_instance.trex_stl_start_remote_exec( - self.get_duration(), unit_rate, frame_size, traffic_profile) + self.get_duration(), unit_rate, frame_size, traffic_profile + ) loss = tg_instance.get_loss() sent = tg_instance.get_sent() if self.loss_acceptance_type_is_percentage(): loss = (float(loss) / float(sent)) * 100 - logger.trace("comparing: {los} < {acc} {typ}".format( - los=loss, acc=loss_acceptance, typ=loss_acceptance_type)) + logger.trace( + f"comparing: {loss} < {loss_acceptance} {loss_acceptance_type}" + ) return float(loss) <= float(loss_acceptance) + return False def get_latency(self): """Returns min/avg/max latency. @@ -114,10 +122,13 @@ class TGDropRateSearchImpl(DropRateSearch): :rtype: list """ tg_instance = BuiltIn().get_library_instance( - 'resources.libraries.python.TrafficGenerator') + u"resources.libraries.python.TrafficGenerator" + ) return tg_instance.get_latency_int() +# TODO: Pylint says too-many-instance-attributes. +# A fix is developed in https://gerrit.fd.io/r/c/csit/+/22221 class TrafficGenerator(AbstractMeasurer): """Traffic Generator. @@ -127,7 +138,7 @@ class TrafficGenerator(AbstractMeasurer): # TODO: Remove "trex" from lines which could work with other TGs. # Use one instance of TrafficGenerator for all tests in test suite - ROBOT_LIBRARY_SCOPE = 'TEST SUITE' + ROBOT_LIBRARY_SCOPE = u"TEST SUITE" def __init__(self): # TODO: Number of fields will be reduced with CSIT-1378. @@ -140,6 +151,8 @@ class TrafficGenerator(AbstractMeasurer): self._sent = None self._latency = None self._received = None + self._approximated_rate = None + self._approximated_duration = None # Measurement input fields, needed for async stop result. self._start_time = None self._rate = None @@ -147,6 +160,11 @@ class TrafficGenerator(AbstractMeasurer): self.frame_size = None self.traffic_profile = None self.warmup_time = None + self.traffic_directions = None + self.negative_loss = None + # Transient data needed for async measurements. + self._xstats = (None, None) + # TODO: Rename "xstats" to something opaque, so TRex is not privileged? @property def node(self): @@ -189,6 +207,17 @@ class TrafficGenerator(AbstractMeasurer): """ return self._latency + def get_approximated_rate(self): + """Return approximated rate computed as ratio of transmited packets over + duration of trial. + + :returns: Approximated rate. + :rtype: str + """ + return self._approximated_rate + + # TODO: pylint says disable=too-many-locals. + # A fix is developed in https://gerrit.fd.io/r/c/csit/+/22221 def initialize_traffic_generator( self, tg_node, tg_if1, tg_if2, tg_if1_adj_node, tg_if1_adj_if, tg_if2_adj_node, tg_if2_adj_if, osi_layer, tg_if1_dst_mac=None, @@ -224,39 +253,32 @@ class TrafficGenerator(AbstractMeasurer): if subtype == NodeSubTypeTG.TREX: self._node = tg_node - ssh = SSH() - ssh.connect(self._node) - - (ret, _, _) = ssh.exec_command( - "sudo -E sh -c '{0}/resources/tools/trex/" - "trex_installer.sh {1}'".format(Constants.REMOTE_FW_DIR, - Constants.TREX_INSTALL_VERSION), - timeout=1800) - if int(ret) != 0: - raise RuntimeError('TRex installation failed.') - if1_pci = Topology().get_interface_pci_addr(self._node, tg_if1) if2_pci = Topology().get_interface_pci_addr(self._node, tg_if2) if1_addr = Topology().get_interface_mac(self._node, tg_if1) if2_addr = Topology().get_interface_mac(self._node, tg_if2) - if osi_layer == 'L2': + if osi_layer == u"L2": if1_adj_addr = if2_addr if2_adj_addr = if1_addr - elif osi_layer == 'L3': - if1_adj_addr = Topology().get_interface_mac(tg_if1_adj_node, - tg_if1_adj_if) - if2_adj_addr = Topology().get_interface_mac(tg_if2_adj_node, - tg_if2_adj_if) - elif osi_layer == 'L7': + elif osi_layer == u"L3": + if1_adj_addr = Topology().get_interface_mac( + tg_if1_adj_node, tg_if1_adj_if + ) + if2_adj_addr = Topology().get_interface_mac( + tg_if2_adj_node, tg_if2_adj_if + ) + elif osi_layer == u"L7": if1_addr = Topology().get_interface_ip4(self._node, tg_if1) if2_addr = Topology().get_interface_ip4(self._node, tg_if2) - if1_adj_addr = Topology().get_interface_ip4(tg_if1_adj_node, - tg_if1_adj_if) - if2_adj_addr = Topology().get_interface_ip4(tg_if2_adj_node, - tg_if2_adj_if) + if1_adj_addr = Topology().get_interface_ip4( + tg_if1_adj_node, tg_if1_adj_if + ) + if2_adj_addr = Topology().get_interface_ip4( + tg_if2_adj_node, tg_if2_adj_if + ) else: - raise ValueError("Unknown Test Type") + raise ValueError(u"Unknown Test Type") # in case of switched environment we can override MAC addresses if tg_if1_dst_mac is not None and tg_if2_dst_mac is not None: @@ -269,101 +291,138 @@ class TrafficGenerator(AbstractMeasurer): if1_adj_addr, if2_adj_addr = if2_adj_addr, if1_adj_addr self._ifaces_reordered = True - if osi_layer == 'L2' or osi_layer == 'L3': - (ret, _, _) = ssh.exec_command( - "sudo sh -c 'cat << EOF > /etc/trex_cfg.yaml\n" - "- version: 2\n" - " interfaces: [\"{0}\",\"{1}\"]\n" - " port_info:\n" - " - dest_mac: [{2}]\n" - " src_mac: [{3}]\n" - " - dest_mac: [{4}]\n" - " src_mac: [{5}]\n" - "EOF'"\ - .format(if1_pci, if2_pci, - "0x"+if1_adj_addr.replace(":", ",0x"), - "0x"+if1_addr.replace(":", ",0x"), - "0x"+if2_adj_addr.replace(":", ",0x"), - "0x"+if2_addr.replace(":", ",0x"))) - elif osi_layer == 'L7': - (ret, _, _) = ssh.exec_command( - "sudo sh -c 'cat << EOF > /etc/trex_cfg.yaml\n" - "- version: 2\n" - " interfaces: [\"{0}\",\"{1}\"]\n" - " port_info:\n" - " - ip: [{2}]\n" - " default_gw: [{3}]\n" - " - ip: [{4}]\n" - " default_gw: [{5}]\n" - "EOF'"\ - .format(if1_pci, if2_pci, - if1_addr, if1_adj_addr, - if2_addr, if2_adj_addr)) + master_thread_id, latency_thread_id, socket, threads = \ + CpuUtils.get_affinity_trex( + self._node, tg_if1, tg_if2, + tg_dtc=Constants.TREX_CORE_COUNT) + + if osi_layer in (u"L2", u"L3"): + dst_mac0 = f"0x{if1_adj_addr.replace(u':', u',0x')}" + src_mac0 = f"0x{if1_addr.replace(u':', u',0x')}" + dst_mac1 = f"0x{if2_adj_addr.replace(u':', u',0x')}" + src_mac1 = f"0x{if2_addr.replace(u':', u',0x')}" + exec_cmd_no_error( + self._node, + f"sh -c 'cat << EOF > /etc/trex_cfg.yaml\n" + f"- version: 2\n" + f" c: {len(threads)}\n" + f" limit_memory: {Constants.TREX_LIMIT_MEMORY}\n" + f" interfaces: [\"{if1_pci}\",\"{if2_pci}\"]\n" + f" port_info:\n" + f" - dest_mac: [{dst_mac0}]\n" + f" src_mac: [{src_mac0}]\n" + f" - dest_mac: [{dst_mac1}]\n" + f" src_mac: [{src_mac1}]\n" + f" platform :\n" + f" master_thread_id: {master_thread_id}\n" + f" latency_thread_id: {latency_thread_id}\n" + f" dual_if:\n" + f" - socket: {socket}\n" + f" threads: {threads}\n" + f"EOF'", + sudo=True, message=u"TRex config generation!" + ) + elif osi_layer == u"L7": + exec_cmd_no_error( + self._node, + f"sh -c 'cat << EOF > /etc/trex_cfg.yaml\n" + f"- version: 2\n" + f" c: {len(threads)}\n" + f" limit_memory: {Constants.TREX_LIMIT_MEMORY}\n" + f" interfaces: [\"{if1_pci}\",\"{if2_pci}\"]\n" + f" port_info:\n" + f" - ip: [{if1_addr}]\n" + f" default_gw: [{if1_adj_addr}]\n" + f" - ip: [{if2_addr}]\n" + f" default_gw: [{if2_adj_addr}]\n" + f" platform :\n" + f" master_thread_id: {master_thread_id}\n" + f" latency_thread_id: {latency_thread_id}\n" + f" dual_if:\n" + f" - socket: {socket}\n" + f" threads: {threads}\n" + f"EOF'", + sudo=True, message=u"TRex config generation!" + ) else: - raise ValueError("Unknown Test Type") - if int(ret) != 0: - raise RuntimeError('TRex config generation error') + raise ValueError(u"Unknown Test Type!") - self._startup_trex(osi_layer) + TrafficGenerator.startup_trex( + self._node, osi_layer, subtype=subtype + ) - def _startup_trex(self, osi_layer): + @staticmethod + def startup_trex(tg_node, osi_layer, subtype=None): """Startup sequence for the TRex traffic generator. + :param tg_node: Traffic generator node. :param osi_layer: 'L2', 'L3' or 'L7' - OSI Layer testing type. + :param subtype: Traffic generator sub-type. + :type tg_node: dict :type osi_layer: str + :type subtype: NodeSubTypeTG :raises RuntimeError: If node subtype is not a TREX or startup failed. """ - # No need to check subtype, we know it is TREX. - for _ in range(0, 3): - # Kill TRex only if it is already running. - cmd = "sh -c 'pgrep t-rex && pkill t-rex && sleep 3 || true'" - exec_cmd_no_error( - self._node, cmd, sudo=True, message='Kill TRex failed!') - - # Configure TRex. - ports = '' - for port in self._node['interfaces'].values(): - ports += ' {pci}'.format(pci=port.get('pci_address')) + if not subtype: + subtype = check_subtype(tg_node) + if subtype == NodeSubTypeTG.TREX: + for _ in range(0, 3): + # Kill TRex only if it is already running. + cmd = u"sh -c \"pgrep t-rex && pkill t-rex && sleep 3 || true\"" + exec_cmd_no_error( + tg_node, cmd, sudo=True, message=u"Kill TRex failed!" + ) - cmd = ("sh -c 'cd {dir}/scripts/ && " - "./dpdk_nic_bind.py -u {ports} || true'" - .format(dir=Constants.TREX_INSTALL_DIR, ports=ports)) - exec_cmd_no_error( - self._node, cmd, sudo=True, - message='Unbind PCI ports from driver failed!') + # Configure TRex. + ports = '' + for port in tg_node[u"interfaces"].values(): + ports += f" {port.get(u'pci_address')}" - cmd = ("sh -c 'cd {dir}/scripts/ && ./trex-cfg'" - .format(dir=Constants.TREX_INSTALL_DIR)) - exec_cmd_no_error( - self._node, cmd, sudo=True, message='Config TRex failed!') - - # Start TRex. - cmd = ("sh -c 'cd {dir}/scripts/ && " - "nohup ./t-rex-64 {mode} -i -c 7 > " - "/tmp/trex.log 2>&1 &' > /dev/null" - .format(dir=Constants.TREX_INSTALL_DIR, - mode='--astf' if osi_layer == 'L7' else '')) - try: - exec_cmd_no_error(self._node, cmd, sudo=True) - except RuntimeError: - cmd = "sh -c 'cat /tmp/trex.log'" - exec_cmd_no_error(self._node, cmd, sudo=True, - message='Get TRex logs failed!') - raise RuntimeError('Start TRex failed!') - - # Test if TRex starts successfuly. - cmd = ("sh -c '{dir}/resources/tools/trex/trex_server_info.py'" - .format(dir=Constants.REMOTE_FW_DIR)) - try: + cmd = f"sh -c \"cd {Constants.TREX_INSTALL_DIR}/scripts/ && " \ + f"./dpdk_nic_bind.py -u {ports} || true\"" exec_cmd_no_error( - self._node, cmd, sudo=True, message='Test TRex failed!', - retries=20) - except RuntimeError: - continue - return - # After max retries TRex is still not responding to API critical error - # occurred. - raise RuntimeError('Start TRex failed after multiple retries!') + tg_node, cmd, sudo=True, + message=u"Unbind PCI ports from driver failed!" + ) + + # Start TRex. + cd_cmd = f"cd '{Constants.TREX_INSTALL_DIR}/scripts/'" + trex_cmd = OptionString([u"nohup", u"./t-rex-64"]) + trex_cmd.add(u"-i") + trex_cmd.add(u"--prefix $(hostname)") + trex_cmd.add(u"--hdrh") + trex_cmd.add(u"--no-scapy-server") + trex_cmd.add_if(u"--astf", osi_layer == u"L7") + # OptionString does not create double space if extra is empty. + trex_cmd.add(f"{Constants.TREX_EXTRA_CMDLINE}") + inner_command = f"{cd_cmd} && {trex_cmd} > /tmp/trex.log 2>&1 &" + cmd = f"sh -c \"{inner_command}\" > /dev/null" + try: + exec_cmd_no_error(tg_node, cmd, sudo=True) + except RuntimeError: + cmd = u"sh -c \"cat /tmp/trex.log\"" + exec_cmd_no_error( + tg_node, cmd, sudo=True, + message=u"Get TRex logs failed!" + ) + raise RuntimeError(u"Start TRex failed!") + + # Test if TRex starts successfuly. + command_line = OptionString().add(u"python3") + dirname = f"{Constants.REMOTE_FW_DIR}/GPL/tools/trex" + command_line.add(f"'{dirname}/trex_server_info.py'") + try: + exec_cmd_no_error( + tg_node, command_line, sudo=True, + message=u"Test TRex failed!", retries=20 + ) + except RuntimeError: + continue + return + # After max retries TRex is still not responding to API critical + # error occurred. + exec_cmd(tg_node, u"cat /tmp/trex.log", sudo=True) + raise RuntimeError(u"Start TRex failed after multiple retries!") @staticmethod def is_trex_running(node): @@ -375,11 +434,7 @@ class TrafficGenerator(AbstractMeasurer): :rtype: bool :raises RuntimeError: If node type is not a TG. """ - # No need to check subtype, we know it is TREX. - - ssh = SSH() - ssh.connect(node) - ret, _, _ = ssh.exec_command_sudo("pidof t-rex") + ret, _, _ = exec_cmd(node, u"pgrep t-rex", sudo=True) return bool(int(ret) == 0) @staticmethod @@ -394,15 +449,16 @@ class TrafficGenerator(AbstractMeasurer): """ subtype = check_subtype(node) if subtype == NodeSubTypeTG.TREX: - ssh = SSH() - ssh.connect(node) - (ret, _, _) = ssh.exec_command( - "sh -c 'sudo pkill t-rex && sleep 3'") - if int(ret) != 0: - raise RuntimeError('pkill t-rex failed') + exec_cmd_no_error( + node, + u"sh -c " + u"\"if pgrep t-rex; then sudo pkill t-rex && sleep 3; fi\"", + sudo=False, + message=u"pkill t-rex failed" + ) def _parse_traffic_results(self, stdout): - """Parse stdout of scripts into fieds of self. + """Parse stdout of scripts into fields of self. Block of code to reuse, by sync start, or stop after async. TODO: Is the output TG subtype dependent? @@ -413,52 +469,59 @@ class TrafficGenerator(AbstractMeasurer): # last line from console output line = stdout.splitlines()[-1] self._result = line - logger.info('TrafficGen result: {0}'.format(self._result)) - self._received = self._result.split(', ')[1].split('=')[1] - self._sent = self._result.split(', ')[2].split('=')[1] - self._loss = self._result.split(', ')[3].split('=')[1] - self._latency = [] - self._latency.append(self._result.split(', ')[4].split('=')[1]) - self._latency.append(self._result.split(', ')[5].split('=')[1]) + logger.info(f"TrafficGen result: {self._result}") + self._received = self._result.split(u", ")[1].split(u"=", 1)[1] + self._sent = self._result.split(u", ")[2].split(u"=", 1)[1] + self._loss = self._result.split(u", ")[3].split(u"=", 1)[1] + self._approximated_duration = \ + self._result.split(u", ")[5].split(u"=", 1)[1] + self._approximated_rate = self._result.split(u", ")[6].split(u"=", 1)[1] + self._latency = list() + self._latency.append(self._result.split(u", ")[7].split(u"=", 1)[1]) + self._latency.append(self._result.split(u", ")[8].split(u"=", 1)[1]) def trex_stl_stop_remote_exec(self, node): """Execute script on remote node over ssh to stop running traffic. - Internal state is updated with results. + Internal state is updated with measurement results. :param node: TRex generator node. :type node: dict - :returns: Nothing :raises RuntimeError: If stop traffic script fails. """ # No need to check subtype, we know it is TREX. - ssh = SSH() - ssh.connect(node) - - (ret, stdout, _) = ssh.exec_command( - "sh -c '{}/resources/tools/trex/" - "trex_stateless_stop.py'".format(Constants.REMOTE_FW_DIR)) - - if int(ret) != 0: - raise RuntimeError('TRex stateless runtime error') - + command_line = OptionString().add(u"python3") + dirname = f"{Constants.REMOTE_FW_DIR}/GPL/tools/trex" + command_line.add(f"'{dirname}/trex_stateless_stop.py'") + command_line.change_prefix(u"--") + for index, value in enumerate(self._xstats): + if value is not None: + value = value.replace(u"'", u"\"") + command_line.add_equals(f"xstat{index}", f"'{value}'") + stdout, _ = exec_cmd_no_error( + node, command_line, message=u"TRex stateless runtime error" + ) self._parse_traffic_results(stdout) def trex_stl_start_remote_exec( self, duration, rate, frame_size, traffic_profile, async_call=False, - latency=True, warmup_time=5.0, unidirection=False, tx_port=0, + latency=True, warmup_time=5.0, traffic_directions=2, tx_port=0, rx_port=1): """Execute script on remote node over ssh to start traffic. + In sync mode, measurement results are stored internally. + In async mode, initial data including xstats are stored internally. + :param duration: Time expresed in seconds for how long to send traffic. :param rate: Traffic rate expressed with units (pps, %) :param frame_size: L2 frame size to send (without padding and IPG). :param traffic_profile: Module name as a traffic profile identifier. - See resources/traffic_profiles/trex for implemented modules. + See GPL/traffic_profiles/trex for implemented modules. :param async_call: If enabled then don't wait for all incomming trafic. :param latency: With latency measurement. :param warmup_time: Warmup time period. - :param unidirection: Traffic is unidirectional. Default: False + :param traffic_directions: Traffic is bi- (2) or uni- (1) directional. + Default: 2 :param tx_port: Traffic generator transmit port for first flow. Default: 0 :param rx_port: Traffic generator receive port for first flow. @@ -470,54 +533,60 @@ class TrafficGenerator(AbstractMeasurer): :type async_call: bool :type latency: bool :type warmup_time: float - :type unidirection: bool + :type traffic_directions: int :type tx_port: int :type rx_port: int :raises RuntimeError: In case of TG driver issue. """ # No need to check subtype, we know it is TREX. - ssh = SSH() - ssh.connect(self._node) reorder = self._ifaces_reordered # Just to make the next line fit. p_0, p_1 = (rx_port, tx_port) if reorder else (tx_port, rx_port) - # Values from Robot can introduce type unicode, - # we need to encode them, so that repr() does not lead with 'u'. - if isinstance(rate, unicode): - rate = rate.encode("utf-8") if not isinstance(duration, (float, int)): duration = float(duration) if not isinstance(warmup_time, (float, int)): warmup_time = float(warmup_time) - command = ( - "sh -c '{tool}/resources/tools/trex/trex_stateless_profile.py" - " --profile {prof}/resources/traffic_profiles/trex/{traffic}.py" - " --duration {duration!r} --frame_size {frame_size} --rate {rate!r}" - " --warmup_time {warmup!r} --port_0 {p_0} --port_1 {p_1}").format( - tool=Constants.REMOTE_FW_DIR, prof=Constants.REMOTE_FW_DIR, - traffic=traffic_profile, duration=duration, - frame_size=frame_size, rate=rate, warmup=warmup_time, p_0=p_0, - p_1=p_1) + + command_line = OptionString().add(u"python3") + dirname = f"{Constants.REMOTE_FW_DIR}/GPL/tools/trex" + command_line.add(f"'{dirname}/trex_stateless_profile.py'") + command_line.change_prefix(u"--") + dirname = f"{Constants.REMOTE_FW_DIR}/GPL/traffic_profiles/trex" + quoted_path = f"'{dirname}/{traffic_profile}.py'" + command_line.add_with_value(u"profile", quoted_path) + command_line.add_with_value(u"duration", f"{duration!r}") + command_line.add_with_value(u"frame_size", frame_size) + command_line.add_with_value(u"rate", f"{rate!r}") + command_line.add_with_value(u"warmup_time", f"{warmup_time!r}") + command_line.add_with_value(u"port_0", p_0) + command_line.add_with_value(u"port_1", p_1) + command_line.add_with_value(u"traffic_directions", traffic_directions) + command_line.add_if(u"async_start", async_call) + command_line.add_if(u"latency", latency) + command_line.add_if(u"force", Constants.TREX_SEND_FORCE) + + stdout, _ = exec_cmd_no_error( + self._node, command_line, timeout=float(duration) + 60, + message=u"TRex stateless runtime error" + ) + + self.traffic_directions = traffic_directions if async_call: - command += " --async" - if latency: - command += " --latency" - if unidirection: - command += " --unidirection" - command += "'" - - (ret, stdout, _) = ssh.exec_command( - command, timeout=float(duration) + 60) - - if int(ret) != 0: - raise RuntimeError('TRex stateless runtime error') - elif async_call: - #no result + # no result self._start_time = time.time() - self._rate = float(rate[:-3]) if "pps" in rate else rate + self._rate = float(rate[:-3]) if u"pps" in rate else float(rate) self._received = None self._sent = None self._loss = None self._latency = None + xstats = [None, None] + index = 0 + for line in stdout.splitlines(): + if f"Xstats snapshot {index}: " in line: + xstats[index] = line[19:] + index += 1 + if index == 2: + break + self._xstats = tuple(xstats) else: self._parse_traffic_results(stdout) self._start_time = None @@ -526,19 +595,26 @@ class TrafficGenerator(AbstractMeasurer): def stop_traffic_on_tg(self): """Stop all traffic on TG. - :returns: Nothing + :returns: Structure containing the result of the measurement. + :rtype: ReceiveRateMeasurement :raises RuntimeError: If TG is not set. """ subtype = check_subtype(self._node) if subtype == NodeSubTypeTG.TREX: self.trex_stl_stop_remote_exec(self._node) + return self.get_measurement_result() def send_traffic_on_tg( self, duration, rate, frame_size, traffic_profile, warmup_time=5, - async_call=False, latency=True, unidirection=False, tx_port=0, + async_call=False, latency=True, traffic_directions=2, tx_port=0, rx_port=1): """Send traffic from all configured interfaces on TG. + In async mode, xstats is stored internally, + to enable getting correct result when stopping the traffic. + In both modes, stdout is returned, + but _parse_traffic_results only works in sync output. + Note that bidirectional traffic also contains flows transmitted from rx_port and received in tx_port. But some tests use asymmetric traffic, so those arguments are relevant. @@ -557,11 +633,12 @@ class TrafficGenerator(AbstractMeasurer): :param rate: Offered load per interface (e.g. 1%, 3gbps, 4mpps, ...). :param frame_size: Frame size (L2) in Bytes. :param traffic_profile: Module name as a traffic profile identifier. - See resources/traffic_profiles/trex for implemented modules. + See GPL/traffic_profiles/trex for implemented modules. :param warmup_time: Warmup phase in seconds. :param async_call: Async mode. :param latency: With latency measurement. - :param unidirection: Traffic is unidirectional. Default: False + :param traffic_directions: Traffic is bi- (2) or uni- (1) directional. + Default: 2 :param tx_port: Traffic generator transmit port for first flow. Default: 0 :param rx_port: Traffic generator receive port for first flow. @@ -573,7 +650,7 @@ class TrafficGenerator(AbstractMeasurer): :type warmup_time: float :type async_call: bool :type latency: bool - :type unidirection: bool + :type traffic_directions: int :type tx_port: int :type rx_port: int :returns: TG output. @@ -586,7 +663,8 @@ class TrafficGenerator(AbstractMeasurer): if subtype == NodeSubTypeTG.TREX: self.trex_stl_start_remote_exec( duration, rate, frame_size, traffic_profile, async_call, - latency, warmup_time, unidirection, tx_port, rx_port) + latency, warmup_time, traffic_directions, tx_port, rx_port + ) return self._result @@ -597,9 +675,9 @@ class TrafficGenerator(AbstractMeasurer): :raises Exception: If loss occured. """ if self._loss is None: - raise RuntimeError('The traffic generation has not been issued') - if self._loss != '0': - raise RuntimeError('Traffic loss occurred: {0}'.format(self._loss)) + raise RuntimeError(u"The traffic generation has not been issued") + if self._loss != u"0": + raise RuntimeError(f"Traffic loss occurred: {self._loss}") def fail_if_no_traffic_forwarded(self): """Fail if no traffic forwarded. @@ -608,12 +686,12 @@ class TrafficGenerator(AbstractMeasurer): :raises Exception: If no traffic forwarded. """ if self._received is None: - raise RuntimeError('The traffic generation has not been issued') - if self._received == '0': - raise RuntimeError('No traffic forwarded') + raise RuntimeError(u"The traffic generation has not been issued") + if self._received == u"0": + raise RuntimeError(u"No traffic forwarded") - def partial_traffic_loss_accepted(self, loss_acceptance, - loss_acceptance_type): + def partial_traffic_loss_accepted( + self, loss_acceptance, loss_acceptance_type): """Fail if loss is higher then accepted in traffic run. :param loss_acceptance: Permitted drop ratio or frames count. @@ -624,34 +702,43 @@ class TrafficGenerator(AbstractMeasurer): :raises Exception: If loss is above acceptance criteria. """ if self._loss is None: - raise Exception('The traffic generation has not been issued') + raise Exception(u"The traffic generation has not been issued") - if loss_acceptance_type == 'percentage': + if loss_acceptance_type == u"percentage": loss = (float(self._loss) / float(self._sent)) * 100 - elif loss_acceptance_type == 'frames': + elif loss_acceptance_type == u"frames": loss = float(self._loss) else: - raise Exception('Loss acceptance type not supported') + raise Exception(u"Loss acceptance type not supported") if loss > float(loss_acceptance): - raise Exception("Traffic loss {} above loss acceptance: {}".format( - loss, loss_acceptance)) + raise Exception( + f"Traffic loss {loss} above loss acceptance: {loss_acceptance}" + ) - def set_rate_provider_defaults(self, frame_size, traffic_profile, - warmup_time=0.0): + def set_rate_provider_defaults( + self, frame_size, traffic_profile, warmup_time=0.0, + traffic_directions=2, negative_loss=True): """Store values accessed by measure(). :param frame_size: Frame size identifier or value [B]. :param traffic_profile: Module name as a traffic profile identifier. - See resources/traffic_profiles/trex for implemented modules. + See GPL/traffic_profiles/trex for implemented modules. :param warmup_time: Traffic duration before measurement starts [s]. + :param traffic_directions: Traffic is bi- (2) or uni- (1) directional. + Default: 2 + :param negative_loss: If false, negative loss is reported as zero loss. :type frame_size: str or int :type traffic_profile: str :type warmup_time: float + :type traffic_directions: int + :type negative_loss: bool """ self.frame_size = frame_size self.traffic_profile = str(traffic_profile) self.warmup_time = float(warmup_time) + self.traffic_directions = traffic_directions + self.negative_loss = negative_loss def get_measurement_result(self, duration=None, transmit_rate=None): """Return the result of last measurement as ReceiveRateMeasurement. @@ -674,20 +761,25 @@ class TrafficGenerator(AbstractMeasurer): duration = time.time() - self._start_time self._start_time = None if transmit_rate is None: - # Assuming bi-directional traffic here. - transmit_rate = self._rate * 2.0 + transmit_rate = self._rate * self.traffic_directions transmit_count = int(self.get_sent()) loss_count = int(self.get_loss()) + if loss_count < 0 and not self.negative_loss: + loss_count = 0 measurement = ReceiveRateMeasurement( - duration, transmit_rate, transmit_count, loss_count) + duration, transmit_rate, transmit_count, loss_count + ) measurement.latency = self.get_latency_int() + measurement.approximated_rate = self.get_approximated_rate() return measurement def measure(self, duration, transmit_rate): - """Run bi-directional measurement, parse and return results. + """Run trial measurement, parse and return aggregate results. + + Aggregate means sum over traffic directions. :param duration: Trial duration [s]. - :param transmit_rate: Target bidirectional transmit rate [pps]. + :param transmit_rate: Target aggregate transmit rate [pps]. :type duration: float :type transmit_rate: float :returns: Structure containing the result of the measurement. @@ -699,15 +791,22 @@ class TrafficGenerator(AbstractMeasurer): duration = float(duration) transmit_rate = float(transmit_rate) # TG needs target Tr per stream, but reports aggregate Tx and Dx. - unit_rate = str(transmit_rate / 2.0) + "pps" + unit_rate_int = transmit_rate / float(self.traffic_directions) + unit_rate_str = str(unit_rate_int) + u"pps" self.send_traffic_on_tg( - duration, unit_rate, self.frame_size, self.traffic_profile, - warmup_time=self.warmup_time, latency=True) + duration, unit_rate_str, self.frame_size, self.traffic_profile, + warmup_time=self.warmup_time, latency=True, + traffic_directions=self.traffic_directions + ) return self.get_measurement_result(duration, transmit_rate) -class OptimizedSearch(object): - """Class to be imported as Robot Library, containing a single keyword.""" +class OptimizedSearch: + """Class to be imported as Robot Library, containing search keywords. + + Aside of setting up measurer and forwarding arguments, + the main business is to translate min/max rate from unidir to aggregate. + """ @staticmethod def perform_optimized_ndrpdr_search( @@ -715,15 +814,15 @@ class OptimizedSearch(object): maximum_transmit_rate, packet_loss_ratio=0.005, final_relative_width=0.005, final_trial_duration=30.0, initial_trial_duration=1.0, number_of_intermediate_phases=2, - timeout=720.0, doublings=1): + timeout=720.0, doublings=1, traffic_directions=2): """Setup initialized TG, perform optimized search, return intervals. :param frame_size: Frame size identifier or value [B]. :param traffic_profile: Module name as a traffic profile identifier. - See resources/traffic_profiles/trex for implemented modules. - :param minimum_transmit_rate: Minimal bidirectional + See GPL/traffic_profiles/trex for implemented modules. + :param minimum_transmit_rate: Minimal uni-directional target transmit rate [pps]. - :param maximum_transmit_rate: Maximal bidirectional + :param maximum_transmit_rate: Maximal uni-directional target transmit rate [pps]. :param packet_loss_ratio: Fraction of packets lost, for PDR [1]. :param final_relative_width: Final lower bound transmit rate @@ -738,6 +837,8 @@ class OptimizedSearch(object): :param doublings: How many doublings to do in external search step. Default 1 is suitable for fairly stable tests, less stable tests might get better overal duration with 2 or more. + :param traffic_directions: Traffic is bi- (2) or uni- (1) directional. + Default: 2 :type frame_size: str or int :type traffic_profile: str :type minimum_transmit_rate: float @@ -749,39 +850,47 @@ class OptimizedSearch(object): :type number_of_intermediate_phases: int :type timeout: float :type doublings: int + :type traffic_directions: int :returns: Structure containing narrowed down NDR and PDR intervals and their measurements. :rtype: NdrPdrResult :raises RuntimeError: If total duration is larger than timeout. """ + minimum_transmit_rate *= traffic_directions + maximum_transmit_rate *= traffic_directions # we need instance of TrafficGenerator instantiated by Robot Framework # to be able to use trex_stl-*() tg_instance = BuiltIn().get_library_instance( - 'resources.libraries.python.TrafficGenerator') - tg_instance.set_rate_provider_defaults(frame_size, traffic_profile) + u"resources.libraries.python.TrafficGenerator" + ) + tg_instance.set_rate_provider_defaults( + frame_size, traffic_profile, traffic_directions=traffic_directions) algorithm = MultipleLossRatioSearch( measurer=tg_instance, final_trial_duration=final_trial_duration, final_relative_width=final_relative_width, number_of_intermediate_phases=number_of_intermediate_phases, initial_trial_duration=initial_trial_duration, timeout=timeout, - doublings=doublings) + doublings=doublings + ) result = algorithm.narrow_down_ndr_and_pdr( - minimum_transmit_rate, maximum_transmit_rate, packet_loss_ratio) + minimum_transmit_rate, maximum_transmit_rate, packet_loss_ratio + ) return result @staticmethod def perform_soak_search( frame_size, traffic_profile, minimum_transmit_rate, maximum_transmit_rate, plr_target=1e-7, tdpt=0.1, - initial_count=50, timeout=1800.0, trace_enabled=False): + initial_count=50, timeout=1800.0, trace_enabled=False, + traffic_directions=2): """Setup initialized TG, perform soak search, return avg and stdev. :param frame_size: Frame size identifier or value [B]. :param traffic_profile: Module name as a traffic profile identifier. - See resources/traffic_profiles/trex for implemented modules. - :param minimum_transmit_rate: Minimal bidirectional + See GPL/traffic_profiles/trex for implemented modules. + :param minimum_transmit_rate: Minimal uni-directional target transmit rate [pps]. - :param maximum_transmit_rate: Maximal bidirectional + :param maximum_transmit_rate: Maximal uni-directional target transmit rate [pps]. :param plr_target: Fraction of packets lost to achieve [1]. :param tdpt: Trial duration per trial. @@ -792,6 +901,9 @@ class OptimizedSearch(object): This is needed because initial "search" phase of integrator takes significant time even without any trial results. :param timeout: The search will stop after this overall time [s]. + :param trace_enabled: True if trace enabled else False. + :param traffic_directions: Traffic is bi- (2) or uni- (1) directional. + Default: 2 :type frame_size: str or int :type traffic_profile: str :type minimum_transmit_rate: float @@ -799,16 +911,24 @@ class OptimizedSearch(object): :type plr_target: float :type initial_count: int :type timeout: float - :returns: Average and stdev of estimated bidirectional rate giving PLR. + :type trace_enabled: bool + :type traffic_directions: int + :returns: Average and stdev of estimated aggregate rate giving PLR. :rtype: 2-tuple of float """ + minimum_transmit_rate *= traffic_directions + maximum_transmit_rate *= traffic_directions tg_instance = BuiltIn().get_library_instance( - 'resources.libraries.python.TrafficGenerator') - tg_instance.set_rate_provider_defaults(frame_size, traffic_profile) + u"resources.libraries.python.TrafficGenerator" + ) + tg_instance.set_rate_provider_defaults( + frame_size, traffic_profile, traffic_directions=traffic_directions, + negative_loss=False) algorithm = PLRsearch( measurer=tg_instance, trial_duration_per_trial=tdpt, packet_loss_ratio_target=plr_target, trial_number_offset=initial_count, timeout=timeout, - trace_enabled=trace_enabled) + trace_enabled=trace_enabled + ) result = algorithm.search(minimum_transmit_rate, maximum_transmit_rate) return result