from .topology import NodeType
from .topology import NodeSubTypeTG
from .topology import Topology
-from MLRsearch.AbstractMeasurer import AbstractMeasurer
-from MLRsearch.MultipleLossRatioSearch import MultipleLossRatioSearch
-from MLRsearch.ReceiveRateMeasurement import ReceiveRateMeasurement
+from .MLRsearch.AbstractMeasurer import AbstractMeasurer
+from .MLRsearch.MultipleLossRatioSearch import MultipleLossRatioSearch
+from .MLRsearch.ReceiveRateMeasurement import ReceiveRateMeasurement
+from .PLRsearch.PLRsearch import PLRsearch
__all__ = ['TGDropRateSearchImpl', 'TrafficGenerator', 'OptimizedSearch']
FIXME: Describe API."""
# TODO: Decrease friction between various search and rate provider APIs.
- # FIXME: Remove "trex" from lines which could work with other TGs.
+ # TODO: Remove "trex" from lines which could work with other TGs.
- # use one instance of TrafficGenerator for all tests in test suite
+ # Use one instance of TrafficGenerator for all tests in test suite
ROBOT_LIBRARY_SCOPE = 'TEST SUITE'
def __init__(self):
self._latency.append(self._result.split(', ')[4].split('=')[1])
self._latency.append(self._result.split(', ')[5].split('=')[1])
+ def trex_stl_start_unidirection(self, duration, rate, framesize,
+ traffic_type, tx_port=0, rx_port=1,
+ async_call=False, latency=False,
+ warmup_time=5.0):
+ """Execute script on remote node over ssh to start unidirection traffic.
+ The purpose of this function is to support performance test that need to
+ measure unidirectional traffic, e.g. Load balancer maglev mode and l3dsr
+ mode test.
+
+ :param duration: Time expresed in seconds for how long to send traffic.
+ :param rate: Traffic rate expressed with units (pps, %)
+ :param framesize: L2 frame size to send (without padding and IPG).
+ :param traffic_type: Module name as a traffic type identifier.
+ See resources/traffic_profiles/trex for implemented modules.
+ :param tx_port: Traffic generator transmit port.
+ :param rx_port: Traffic generator receive port.
+ :param latency: With latency measurement.
+ :param async_call: If enabled then don't wait for all incomming trafic.
+ :param warmup_time: Warmup time period.
+ :type duration: float
+ :type rate: str
+ :type framesize: str
+ :type traffic_type: str
+ :type tx_port: integer
+ :type rx_port: integer
+ :type latency: bool
+ :type async_call: bool
+ :type warmup_time: float
+ :returns: Nothing
+ :raises RuntimeError: In case of TG driver issue.
+ """
+ ssh = SSH()
+ ssh.connect(self._node)
+
+ _latency = "--latency" if latency else ""
+ _async = "--async" if async_call else ""
+
+ profile_path = ("{0}/resources/traffic_profiles/trex/"
+ "{1}.py".format(Constants.REMOTE_FW_DIR,
+ traffic_type))
+ (ret, stdout, _) = ssh.exec_command(
+ "sh -c "
+ "'{0}/resources/tools/trex/trex_stateless_profile.py "
+ "--profile {1} "
+ "--duration {2} "
+ "--frame_size {3} "
+ "--rate {4} "
+ "--warmup_time {5} "
+ "--port_0 {6} "
+ "--port_1 {7} "
+ "{8} " # --async
+ "{9} " # --latency
+ "{10}'". # --unidirection
+ format(Constants.REMOTE_FW_DIR, profile_path, duration, framesize,
+ rate, warmup_time, tx_port, rx_port, _async, _latency,
+ "--unidirection"),
+ timeout=float(duration) + 60)
+
+ if int(ret) != 0:
+ raise RuntimeError('TRex unidirection runtime error')
+ elif async_call:
+ #no result
+ self._received = None
+ self._sent = None
+ self._loss = None
+ self._latency = None
+ else:
+ # 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])
+
def stop_traffic_on_tg(self):
"""Stop all traffic on TG.
if self._node['subtype'] == NodeSubTypeTG.TREX:
self.trex_stl_stop_remote_exec(self._node)
- def send_traffic_on_tg(self, duration, rate, framesize,
- traffic_type, warmup_time=5, async_call=False,
- latency=True):
+ def send_traffic_on_tg(self, duration, rate, framesize, traffic_type,
+ unidirection=False, tx_port=0, rx_port=1,
+ warmup_time=5, async_call=False, latency=True):
"""Send traffic from all configured interfaces on TG.
:param duration: Duration of test traffic generation in seconds.
:param framesize: Frame size (L2) in Bytes.
:param traffic_type: Module name as a traffic type identifier.
See resources/traffic_profiles/trex for implemented modules.
+ :param unidirection: Traffic is unidirectional.
+ :param tx_port: Traffic generator transmit port.
+ :param rx_port: Traffic generator receive port.
:param warmup_time: Warmup phase in seconds.
:param async_call: Async mode.
:param latency: With latency measurement.
:type rate: str
:type framesize: str
:type traffic_type: str
+ :type unidirection: bool
+ :type tx_port: integer
+ :type rx_port: integer
:type warmup_time: float
:type async_call: bool
:type latency: bool
if node['subtype'] is None:
raise RuntimeError('TG subtype not defined')
elif node['subtype'] == NodeSubTypeTG.TREX:
- self.trex_stl_start_remote_exec(duration, rate, framesize,
- traffic_type, async_call, latency,
- warmup_time=warmup_time)
+ if unidirection:
+ self.trex_stl_start_unidirection(duration, rate, framesize,
+ traffic_type, tx_port,
+ rx_port, async_call, latency,
+ warmup_time)
+ else:
+ self.trex_stl_start_remote_exec(duration, rate, framesize,
+ traffic_type, async_call,
+ latency, warmup_time)
else:
raise NotImplementedError("TG subtype not supported")
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=600.0):
+ timeout=720.0, doublings=1):
"""Setup initialized TG, perform optimized search, return intervals.
:param frame_size: Frame size identifier or value [B].
to perform before the final phase [1].
:param timeout: The search will fail itself when not finished
before this overall time [s].
+ :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.
:type frame_size: str or int
:type traffic_type: str
:type minimum_transmit_rate: float
:type initial_trial_duration: float
:type number_of_intermediate_phases: int
:type timeout: float
+ :type doublings: int
:returns: Structure containing narrowed down NDR and PDR intervals
and their measurements.
:rtype: NdrPdrResult
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)
+ initial_trial_duration=initial_trial_duration, timeout=timeout,
+ doublings=doublings)
result = algorithm.narrow_down_ndr_and_pdr(
minimum_transmit_rate, maximum_transmit_rate, packet_loss_ratio)
return result
+
+ @staticmethod
+ def perform_soak_search(
+ frame_size, traffic_type, minimum_transmit_rate,
+ maximum_transmit_rate, plr_target=1e-7, tdpt=0.2,
+ initial_count=50, timeout=1800.0):
+ """Setup initialized TG, perform soak search, return avg and stdev.
+
+ :param frame_size: Frame size identifier or value [B].
+ :param traffic_type: Module name as a traffic type identifier.
+ See resources/traffic_profiles/trex for implemented modules.
+ :param minimum_transmit_rate: Minimal bidirectional
+ target transmit rate [pps].
+ :param maximum_transmit_rate: Maximal bidirectional
+ target transmit rate [pps].
+ :param plr_target: Fraction of packets lost to achieve [1].
+ :param tdpt: Trial duration per trial.
+ The algorithm linearly increases trial duration with trial number,
+ this is the increment between succesive trials, in seconds.
+ :param initial_count: Offset to apply before the first trial.
+ For example initial_count=50 makes first trial to be 51*tdpt long.
+ 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].
+ :type frame_size: str or int
+ :type traffic_type: str
+ :type minimum_transmit_rate: float
+ :type maximum_transmit_rate: float
+ :type plr_target: float
+ :type initial_count: int
+ :type timeout: float
+ :returns: Average and stdev of estimated bidirectional rate giving PLR.
+ :rtype: 2-tuple of float
+ """
+ tg_instance = BuiltIn().get_library_instance(
+ 'resources.libraries.python.TrafficGenerator')
+ tg_instance.set_rate_provider_defaults(frame_size, traffic_type)
+ algorithm = PLRsearch(
+ measurer=tg_instance, trial_duration_per_trial=tdpt,
+ packet_loss_ratio_target=plr_target,
+ trial_number_offset=initial_count, timeout=timeout)
+ result = algorithm.search(minimum_transmit_rate, maximum_transmit_rate)
+ return result
Code Review / csit.git / blobdiff