X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FMLRsearch%2FReceiveRateMeasurement.py;fp=resources%2Flibraries%2Fpython%2FMLRsearch%2FReceiveRateMeasurement.py;h=c732e66026e384d14e06bfd0e616fce22601317f;hp=31a6f8202e0cddf6ff3f755710e21137c84ac413;hb=023fa41e51c966a1956bda6b915ffd894ff10e84;hpb=e31998ea56c55879fbaae8e58b0dad0bc6549dae

diff --git a/resources/libraries/python/MLRsearch/ReceiveRateMeasurement.py b/resources/libraries/python/MLRsearch/ReceiveRateMeasurement.py
index 31a6f8202e..c732e66026 100644
--- a/resources/libraries/python/MLRsearch/ReceiveRateMeasurement.py
+++ b/resources/libraries/python/MLRsearch/ReceiveRateMeasurement.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:
@@ -17,18 +17,39 @@
 class ReceiveRateMeasurement:
     """Structure defining the result of single Rr measurement."""
 
-    def __init__(self, duration, target_tr, transmit_count, loss_count):
+    def __init__(
+            self, duration, target_tr, transmit_count, loss_count,
+            approximated_duration=0.0, partial_transmit_count=0):
         """Constructor, normalize primary and compute secondary quantities.
 
+        If approximated_duration is nonzero, it is stored.
+        If approximated_duration is zero, duration value is stored.
+        Either way, additional secondary quantities are computed
+        from the store value.
+
+        If there is zero transmit_count, fractions are set to zero.
+
+        In some cases, traffic generator does not attempt all the needed
+        transactions. In that case, nonzero partial_transmit_count
+        holds (an estimate of) count of the actually attempted transactions.
+        This is used to populate some secondary quantities.
+
+        TODO: Use None instead of zero?
+
         :param duration: Measurement duration [s].
         :param target_tr: Target transmit rate [pps].
             If bidirectional traffic is measured, this is bidirectional rate.
         :param transmit_count: Number of packets transmitted [1].
         :param loss_count: Number of packets transmitted but not received [1].
+        :param approximated_duration: Estimate of the actual time of the trial.
+        :param partial_transmit_count: Estimate count of actually attempted
+            transactions.
         :type duration: float
         :type target_tr: float
         :type transmit_count: int
         :type loss_count: int
+        :type approximated_duration: float
+        :type partial_transmit_count: int
         """
         self.duration = float(duration)
         self.target_tr = float(target_tr)
@@ -38,8 +59,41 @@ class ReceiveRateMeasurement:
         self.transmit_rate = transmit_count / self.duration
         self.loss_rate = loss_count / self.duration
         self.receive_rate = self.receive_count / self.duration
-        self.loss_fraction = float(self.loss_count) / self.transmit_count
-        # TODO: Do we want to store also the real time (duration + overhead)?
+        self.loss_fraction = (
+            float(self.loss_count) / self.transmit_count
+            if self.transmit_count > 0 else 1.0
+        )
+        self.receive_fraction = (
+            float(self.receive_count) / self.transmit_count
+            if self.transmit_count > 0 else 0.0
+        )
+        self.approximated_duration = (
+            float(approximated_duration) if approximated_duration
+            else self.duration
+        )
+        self.approximated_receive_rate = (
+            self.receive_count / self.approximated_duration
+            if self.approximated_duration > 0.0 else 0.0
+        )
+        # If the traffic generator is unreliable and sends less packets,
+        # the absolute receive rate might be too low for next target.
+        self.partial_transmit_count = (
+            int(partial_transmit_count) if partial_transmit_count
+            else self.transmit_count
+        )
+        self.partial_receive_fraction = (
+            float(self.receive_count) / self.partial_transmit_count
+            if self.partial_transmit_count > 0 else 0.0
+        )
+        self.partial_receive_rate = (
+            self.target_tr * self.partial_receive_fraction
+        )
+        # We use relative packet ratios in order to support cases
+        # where target_tr is in transactions per second,
+        # but there are multiple packets per transaction.
+        self.relative_receive_rate = (
+            self.target_tr * self.receive_count / self.transmit_count
+        )
 
     def __str__(self):
         """Return string reporting input and loss fraction."""
@@ -51,4 +105,6 @@ class ReceiveRateMeasurement:
         return f"ReceiveRateMeasurement(duration={self.duration!r}," \
             f"target_tr={self.target_tr!r}," \
             f"transmit_count={self.transmit_count!r}," \
-            f"loss_count={self.loss_count!r})"
+            f"loss_count={self.loss_count!r}," \
+            f"approximated_duration={self.approximated_duration!r}," \
+            f"partial_transmit_count={self.partial_transmit_count!r})"