NFVBENCH-108 Adjust exact frame size to take into account FCS field2.0.5

Minimum L2 frame size is now set to 64 bytes.
If VLAN tagging, min frame size for the latency stream is 68 bytes.

Also fix issue with interface baseline.

Change-Id: If6ff7515c0112ab419070c86f7094ff88930d33b
Signed-off-by: ahothan <ahothan@cisco.com>

8 files changed, 54 insertions, 55 deletions

diff --git a/docs/development/design/traffic_desc.rst b/docs/development/design/traffic_desc.rst
index 6442013..cd80a1c 100644
--- a/docs/development/design/traffic_desc.rst
+++ b/docs/development/design/traffic_desc.rst
@@ -23,8 +23,7 @@ The code to create the UDP packet is located in TRex.create_pkt() (nfvbench/traf
 NFVbench always generates UDP packets (even when doing L2 forwarding).
 The final size of the frame containing each UDP packet will be based on the requested L2 frame size.
 When taking into account the minimum payload size requirements from the traffic generator for
-the latency streams, the minimum L2 frame size is 64 byte (no vlan tagging) or
-68 bytes (with vlan tagging).
+the latency streams, the minimum L2 frame size is 64 byte.
 
 Flows Specification
 -------------------
diff --git a/nfvbench/chain_runner.py b/nfvbench/chain_runner.py
index c120501..876fec2 100644
--- a/nfvbench/chain_runner.py
+++ b/nfvbench/chain_runner.py
@@ -90,13 +90,13 @@ class ChainRunner(object):
                 self.traffic_client.ensure_arp_successful()
             self.traffic_client.ensure_end_to_end()
 
-    def __get_result_per_frame_size(self, frame_size, actual_frame_size, bidirectional):
+    def __get_result_per_frame_size(self, frame_size, bidirectional):
         traffic_result = {
             frame_size: {}
         }
         result = {}
         if not self.config.no_traffic:
-            self.traffic_client.set_traffic(actual_frame_size, bidirectional)
+            self.traffic_client.set_traffic(frame_size, bidirectional)
 
             if self.config.single_run:
                 result = self.stats_manager.run_fixed_rate()
@@ -105,9 +105,6 @@ class ChainRunner(object):
 
                 for dr in ['pdr', 'ndr']:
                     if dr in results:
-                        if frame_size != actual_frame_size:
-                            results[dr]['l2frame_size'] = frame_size
-                            results[dr]['actual_l2frame_size'] = actual_frame_size
                         traffic_result[frame_size][dr] = results[dr]
                         if 'warning' in results[dr]['stats'] and results[dr]['stats']['warning']:
                             traffic_result['warning'] = results[dr]['stats']['warning']
@@ -117,8 +114,6 @@ class ChainRunner(object):
                 result['run_config'] = self.traffic_client.get_run_config(result)
                 required = result['run_config']['direction-total']['orig']['rate_pps']
                 actual = result['stats']['total_tx_rate']
-                if frame_size != actual_frame_size:
-                    result['actual_l2frame_size'] = actual_frame_size
                 warning = self.traffic_client.compare_tx_rates(required, actual)
                 if warning is not None:
                     result['run_config']['warning'] = warning
@@ -128,9 +123,8 @@ class ChainRunner(object):
 
     def __get_chain_result(self):
         result = OrderedDict()
-        for fs, actual_fs in zip(self.config.frame_sizes, self.config.actual_frame_sizes):
+        for fs in self.config.frame_sizes:
             result.update(self.__get_result_per_frame_size(fs,
-                                                           actual_fs,
                                                            self.config.traffic.bidirectional))
         chain_result = {
             'flow_count': self.config.flow_count,
diff --git a/nfvbench/nfvbench.py b/nfvbench/nfvbench.py
index 933d6fa..0d6da7f 100644
--- a/nfvbench/nfvbench.py
+++ b/nfvbench/nfvbench.py
@@ -90,18 +90,19 @@ class NFVBench(object):
                                             self.factory,
                                             self.notifier)
             new_frame_sizes = []
-            min_packet_size = "68" if self.config.vlan_tagging else "64"
+            # make sure that the min frame size is 64
+            min_packet_size = 64
             for frame_size in self.config.frame_sizes:
                 try:
-                    if int(frame_size) < int(min_packet_size):
-                        new_frame_sizes.append(min_packet_size)
-                        LOG.info("Adjusting frame size %s Bytes to minimum size %s Bytes due to " +
-                                 "traffic generator restriction", frame_size, min_packet_size)
-                    else:
+                    if int(frame_size) < min_packet_size:
+                        frame_size = str(min_packet_size)
+                        LOG.info("Adjusting frame size %s bytes to minimum size %s bytes",
+                                 frame_size, min_packet_size)
+                    if frame_size not in new_frame_sizes:
                         new_frame_sizes.append(frame_size)
                 except ValueError:
-                    new_frame_sizes.append(frame_size)
-            self.config.actual_frame_sizes = tuple(new_frame_sizes)
+                    new_frame_sizes.append(frame_size.upper())
+            self.config.frame_sizes = new_frame_sizes
             result = {
                 "date": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                 "nfvbench_version": __version__,
diff --git a/nfvbench/stats_manager.py b/nfvbench/stats_manager.py
index a1fb497..98ac413 100644
--- a/nfvbench/stats_manager.py
+++ b/nfvbench/stats_manager.py
@@ -73,9 +73,9 @@ class StatsManager(object):
 
     def _update_interface_stats(self, diff=False):
         """Update interface stats for both the traffic generator and the worker."""
-        self.traffic_client.update_interface_stats(diff=True)
+        self.traffic_client.update_interface_stats(diff)
         if self.worker:
-            self.worker.update_interface_stats(diff=True)
+            self.worker.update_interface_stats(diff)
 
     def run_fixed_rate(self):
         """Run a fixed rate and analyze results."""
diff --git a/nfvbench/summarizer.py b/nfvbench/summarizer.py
index 0d84ab2..f03d3bc 100644
--- a/nfvbench/summarizer.py
+++ b/nfvbench/summarizer.py
@@ -350,12 +350,6 @@ class NFVBenchSummarizer(Summarizer):
     def __chain_analysis_summarize(self, frame_size, analysis):
         self._put()
         self._put('L2 frame size:', frame_size)
-        if 'actual_l2frame_size' in analysis:
-            self._put('Actual l2 frame size:', analysis['actual_l2frame_size'])
-        elif self.config['ndr_run'] and 'actual_l2frame_size' in analysis['ndr']:
-            self._put('Actual l2 frame size:', analysis['ndr']['actual_l2frame_size'])
-        elif self.config['pdr_run'] and 'actual_l2frame_size' in analysis['pdr']:
-            self._put('Actual l2 frame size:', analysis['pdr']['actual_l2frame_size'])
         if self.config['ndr_run']:
             self._put('NDR search duration:', Formatter.float(0)(analysis['ndr']['time_taken_sec']),
                       'seconds')
diff --git a/nfvbench/traffic_gen/traffic_base.py b/nfvbench/traffic_gen/traffic_base.py
index 459af0f..0360591 100644
--- a/nfvbench/traffic_gen/traffic_base.py
+++ b/nfvbench/traffic_gen/traffic_base.py
@@ -18,6 +18,7 @@ import sys
 from nfvbench.log import LOG
 import traffic_utils
 
+
 class Latency(object):
     """A class to hold latency data."""
 
@@ -50,14 +51,11 @@ class TrafficGeneratorException(Exception):
 
 
 class AbstractTrafficGenerator(object):
+
     def __init__(self, traffic_client):
         self.traffic_client = traffic_client
         self.generator_config = traffic_client.generator_config
         self.config = traffic_client.config
-        self.imix_l2_sizes = [64, 594, 1518]
-        self.imix_ratios = [7, 4, 1]
-        self.imix_avg_l2_size = 0
-        self.adjust_imix_min_size(64)
 
     @abc.abstractmethod
     def get_version(self):
@@ -134,11 +132,3 @@ class AbstractTrafficGenerator(object):
         return: a list of speed in Gbps indexed by the port#
         """
         pass
-
-    def adjust_imix_min_size(self, min_size):
-        # assume the min size is always the first entry
-        self.imix_l2_sizes[0] = min_size
-        self.imix_avg_l2_size = sum(
-            [1.0 * imix[0] * imix[1] for imix in zip(self.imix_l2_sizes, self.imix_ratios)]) / sum(
-                self.imix_ratios)
-        traffic_utils.imix_avg_l2_size = self.imix_avg_l2_size
diff --git a/nfvbench/traffic_gen/traffic_utils.py b/nfvbench/traffic_gen/traffic_utils.py
index c3428a4..f856267 100644
--- a/nfvbench/traffic_gen/traffic_utils.py
+++ b/nfvbench/traffic_gen/traffic_utils.py
@@ -16,13 +16,18 @@
 import bitmath
 from nfvbench.utils import multiplier_map
 
-imix_avg_l2_size = None
+# IMIX frame size including the 4-byte FCS field
+IMIX_L2_SIZES = [64, 594, 1518]
+IMIX_RATIOS = [7, 4, 1]
+# weighted average l2 frame size includng the 4-byte FCS
+IMIX_AVG_L2_FRAME_SIZE = sum(
+    [1.0 * imix[0] * imix[1] for imix in zip(IMIX_L2_SIZES, IMIX_RATIOS)]) / sum(IMIX_RATIOS)
 
 
 def convert_rates(l2frame_size, rate, intf_speed):
     """Convert a given rate unit into the other rate units.
 
-    l2frame_size: size of the L2 frame in bytes or 'IMIX'
+    l2frame_size: size of the L2 frame in bytes (includes 32-bit FCS) or 'IMIX'
     rate: a dict that has at least one of the following key:
           'rate_pps', 'rate_bps', 'rate_percent'
           with the corresponding input value
@@ -59,8 +64,13 @@ def convert_rates(l2frame_size, rate, intf_speed):
 
 
 def get_average_packet_size(l2frame_size):
+    """Retrieve the average L2 frame size
+
+    l2frame_size: an L2 frame size in bytes (including FCS) or 'IMIX'
+    return: average l2 frame size inlcuding the 32-bit FCS
+    """
     if l2frame_size.upper() == 'IMIX':
-        return imix_avg_l2_size
+        return IMIX_AVG_L2_FRAME_SIZE
     return float(l2frame_size)
 
 
diff --git a/nfvbench/traffic_gen/trex.py b/nfvbench/traffic_gen/trex.py
index 6aec57d..6bb0c34 100644
--- a/nfvbench/traffic_gen/trex.py
+++ b/nfvbench/traffic_gen/trex.py
@@ -27,6 +27,9 @@ from nfvbench.utils import TimeoutError
 from traffic_base import AbstractTrafficGenerator
 from traffic_base import TrafficGeneratorException
 import traffic_utils as utils
+from traffic_utils import IMIX_AVG_L2_FRAME_SIZE
+from traffic_utils import IMIX_L2_SIZES
+from traffic_utils import IMIX_RATIOS
 
 # pylint: disable=import-error
 from trex_stl_lib.api import CTRexVmInsFixHwCs
@@ -245,15 +248,17 @@ class TRex(AbstractTrafficGenerator):
         results['avg_delay_usec'] = int(average / self.chain_count)
 
     def _create_pkt(self, stream_cfg, l2frame_size):
+        """Create a packet of given size.
+
+        l2frame_size: size of the L2 frame in bytes (including the 32-bit FCS)
+        """
+        # Trex will add the FCS field, so we need to remove 4 bytes from the l2 frame size
+        frame_size = int(l2frame_size) - 4
+
         pkt_base = Ether(src=stream_cfg['mac_src'], dst=stream_cfg['mac_dst'])
         if stream_cfg['vlan_tag'] is not None:
-            # 50 = 14 (Ethernet II) + 4 (Vlan tag) + 4 (CRC Checksum) + 20 (IPv4) + 8 (UDP)
             pkt_base /= Dot1Q(vlan=stream_cfg['vlan_tag'])
-            l2payload_size = int(l2frame_size) - 50
-        else:
-            # 46 = 14 (Ethernet II) + 4 (CRC Checksum) + 20 (IPv4) + 8 (UDP)
-            l2payload_size = int(l2frame_size) - 46
-        payload = 'x' * l2payload_size
+
         udp_args = {}
         if stream_cfg['udp_src_port']:
             udp_args['sport'] = int(stream_cfg['udp_src_port'])
@@ -301,8 +306,9 @@ class TRex(AbstractTrafficGenerator):
                                l4_offset="UDP",
                                l4_type=CTRexVmInsFixHwCs.L4_TYPE_UDP)
         ]
+        pad = max(0, frame_size - len(pkt_base)) * 'x'
 
-        return STLPktBuilder(pkt=pkt_base / payload, vm=STLScVmRaw(vm_param))
+        return STLPktBuilder(pkt=pkt_base / pad, vm=STLScVmRaw(vm_param))
 
     def generate_streams(self, port, chain_id, stream_cfg, l2frame, latency=True):
         """Create a list of streams corresponding to a given chain and stream config.
@@ -310,15 +316,13 @@ class TRex(AbstractTrafficGenerator):
         port: port where the streams originate (0 or 1)
         chain_id: the chain to which the streams are associated to
         stream_cfg: stream configuration
-        l2frame: L2 frame size
+        l2frame: L2 frame size (including 4-byte FCS) or 'IMIX'
         latency: if True also create a latency stream
         """
         streams = []
         pg_id, lat_pg_id = self.get_pg_id(port, chain_id)
         if l2frame == 'IMIX':
-            min_size = 64 if stream_cfg['vlan_tag'] is None else 68
-            self.adjust_imix_min_size(min_size)
-            for ratio, l2_frame_size in zip(self.imix_ratios, self.imix_l2_sizes):
+            for ratio, l2_frame_size in zip(IMIX_RATIOS, IMIX_L2_SIZES):
                 pkt = self._create_pkt(stream_cfg, l2_frame_size)
                 streams.append(STLStream(packet=pkt,
                                          flow_stats=STLFlowStats(pg_id=pg_id),
@@ -326,13 +330,20 @@ class TRex(AbstractTrafficGenerator):
 
             if latency:
                 # for IMIX, the latency packets have the average IMIX packet size
-                pkt = self._create_pkt(stream_cfg, self.imix_avg_l2_size)
+                pkt = self._create_pkt(stream_cfg, IMIX_AVG_L2_FRAME_SIZE)
 
         else:
-            pkt = self._create_pkt(stream_cfg, l2frame)
+            l2frame_size = int(l2frame)
+            pkt = self._create_pkt(stream_cfg, l2frame_size)
             streams.append(STLStream(packet=pkt,
                                      flow_stats=STLFlowStats(pg_id=pg_id),
                                      mode=STLTXCont()))
+            # for the latency stream, the minimum payload is 16 bytes even in case of vlan tagging
+            # without vlan, the min l2 frame size is 64
+            # with vlan it is 68
+            # This only applies to the latency stream
+            if latency and stream_cfg['vlan_tag'] and l2frame_size < 68:
+                pkt = self._create_pkt(stream_cfg, 68)
 
         if latency:
             streams.append(STLStream(packet=pkt,