from .topology import NodeType
from .topology import NodeSubTypeTG
from .topology import Topology
-from .search.AbstractRateProvider import AbstractRateProvider
-from .search.OptimizedSearchAlgorithm import OptimizedSearchAlgorithm
-from .search.ReceiveRateMeasurement import ReceiveRateMeasurement
+from .MLRsearch.AbstractMeasurer import AbstractMeasurer
+from .MLRsearch.MultipleLossRatioSearch import MultipleLossRatioSearch
+from .MLRsearch.ReceiveRateMeasurement import ReceiveRateMeasurement
__all__ = ['TGDropRateSearchImpl', 'TrafficGenerator', 'OptimizedSearch']
return tg_instance.get_latency_int()
-class TrafficGenerator(AbstractRateProvider):
+class TrafficGenerator(AbstractMeasurer):
"""Traffic Generator.
FIXME: Describe API."""
:raises Exception: If loss occured.
"""
if self._loss is None:
- raise Exception('The traffic generation has not been issued')
+ raise RuntimeError('The traffic generation has not been issued')
if self._loss != '0':
- raise Exception('Traffic loss occurred: {0}'.format(self._loss))
+ raise RuntimeError('Traffic loss occurred: {0}'.format(self._loss))
+
+ def fail_if_no_traffic_forwarded(self):
+ """Fail if no traffic forwarded.
+
+ :returns: nothing
+ :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')
def partial_traffic_loss_accepted(self, loss_acceptance,
loss_acceptance_type):
duration, unit_rate, self.frame_size, self.traffic_type,
self.warmup_time, latency=True)
transmit_count = int(self.get_sent())
- drop_count = int(self.get_loss())
+ loss_count = int(self.get_loss())
measurement = ReceiveRateMeasurement(
- duration, transmit_rate, transmit_count, drop_count)
+ duration, transmit_rate, transmit_count, loss_count)
measurement.latency = self.get_latency_int()
return measurement
@staticmethod
def perform_optimized_ndrpdr_search(
- frame_size, traffic_type, fail_rate, line_rate,
- allowed_drop_fraction=0.005, final_relative_width=0.005,
- final_trial_duration=30.0, initial_trial_duration=1.0,
- intermediate_phases=2, timeout=600.0):
+ frame_size, traffic_type, minimum_transmit_rate,
+ 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):
"""Setup initialized TG, perform optimized search, return intervals.
: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 fail_rate: Minimal target transmit rate [pps].
- :param line_rate: Maximal target transmit rate [pps].
- :param allowed_drop_fraction: Fraction of dropped packets for PDR [1].
+ :param minimum_transmit_rate: Minimal bidirectional
+ target transmit rate [pps].
+ :param maximum_transmit_rate: Maximal bidirectional
+ target transmit rate [pps].
+ :param packet_loss_ratio: Fraction of packets lost, for PDR [1].
:param final_relative_width: Final lower bound transmit rate
cannot be more distant that this multiple of upper bound [1].
:param final_trial_duration: Trial duration for the final phase [s].
:param initial_trial_duration: Trial duration for the initial phase
and also for the first intermediate phase [s].
- :param intermediate_phases: Number of intermediate phases to perform
- before the final phase [1].
+ :param number_of_intermediate_phases: Number of intermediate phases
+ to perform before the final phase [1].
:param timeout: The search will fail itself when not finished
before this overall time [s].
:type frame_size: str or int
:type traffic_type: str
- :type fail_rate: float
- :type line_rate: float
- :type allowed_drop_fraction: float
+ :type minimum_transmit_rate: float
+ :type maximum_transmit_rate: float
+ :type packet_loss_ratio: float
:type final_relative_width: float
:type final_trial_duration: float
:type initial_trial_duration: float
- :type intermediate_phases: int
+ :type number_of_intermediate_phases: int
:type timeout: float
- :returns: Structure containing narrowed down intervals
+ :returns: Structure containing narrowed down NDR and PDR intervals
and their measurements.
:rtype: NdrPdrResult
:raises RuntimeError: If total duration is larger than timeout.
tg_instance = BuiltIn().get_library_instance(
'resources.libraries.python.TrafficGenerator')
tg_instance.set_rate_provider_defaults(frame_size, traffic_type)
- algorithm = OptimizedSearchAlgorithm(
- tg_instance, final_trial_duration=final_trial_duration,
+ algorithm = MultipleLossRatioSearch(
+ measurer=tg_instance, final_trial_duration=final_trial_duration,
final_relative_width=final_relative_width,
- intermediate_phases=intermediate_phases,
+ number_of_intermediate_phases=number_of_intermediate_phases,
initial_trial_duration=initial_trial_duration, timeout=timeout)
result = algorithm.narrow_down_ndr_and_pdr(
- fail_rate, line_rate, allowed_drop_fraction)
+ minimum_transmit_rate, maximum_transmit_rate, packet_loss_ratio)
return result