NFVBENCH-153 Add support for python3

[nfvbench.git] / nfvbench / traffic_gen / traffic_utils.py

diff --git a/nfvbench/traffic_gen/traffic_utils.py b/nfvbench/traffic_gen/traffic_utils.py
index c3428a4..c875a5d 100644 (file)
--- 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
@@ -49,18 +54,22 @@ def convert_rates(l2frame_size, rate, intf_speed):
         pps = bps_to_pps(bps, avg_packet_size)
     else:
         raise Exception('Traffic config needs to have a rate type key')
-
     return {
         'initial_rate_type': initial_rate_type,
-        'rate_pps': int(pps),
+        'rate_pps': int(float(pps)),
         'rate_percent': load,
-        'rate_bps': int(bps)
+        'rate_bps': int(float(bps))
     }
 
 
 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)
 
 
@@ -103,23 +112,22 @@ def parse_rate_str(rate_str):
             rate_pps = rate_pps[:-1]
         except KeyError:
             multiplier = 1
-        rate_pps = int(rate_pps.strip()) * multiplier
+        rate_pps = int(float(rate_pps.strip()) * multiplier)
         if rate_pps <= 0:
             raise Exception('%s is out of valid range' % rate_str)
         return {'rate_pps': str(rate_pps)}
-    elif rate_str.endswith('ps'):
+    if rate_str.endswith('ps'):
         rate = rate_str.replace('ps', '').strip()
         bit_rate = bitmath.parse_string(rate).bits
         if bit_rate <= 0:
             raise Exception('%s is out of valid range' % rate_str)
         return {'rate_bps': str(int(bit_rate))}
-    elif rate_str.endswith('%'):
+    if rate_str.endswith('%'):
         rate_percent = float(rate_str.replace('%', '').strip())
         if rate_percent <= 0 or rate_percent > 100.0:
             raise Exception('%s is out of valid range (must be 1-100%%)' % rate_str)
         return {'rate_percent': str(rate_percent)}
-    else:
-        raise Exception('Unknown rate string format %s' % rate_str)
+    raise Exception('Unknown rate string format %s' % rate_str)
 
 def get_load_from_rate(rate_str, avg_frame_size=64, line_rate='10Gbps'):
     '''From any rate string (with unit) return the corresponding load (in % unit)
@@ -162,10 +170,10 @@ def to_rate_str(rate):
     if 'rate_pps' in rate:
         pps = rate['rate_pps']
         return '{}pps'.format(pps)
-    elif 'rate_bps' in rate:
+    if 'rate_bps' in rate:
         bps = rate['rate_bps']
         return '{}bps'.format(bps)
-    elif 'rate_percent' in rate:
+    if 'rate_percent' in rate:
         load = rate['rate_percent']
         return '{}%'.format(load)
     assert False
@@ -175,7 +183,7 @@ def to_rate_str(rate):
 
 def nan_replace(d):
     """Replaces every occurence of 'N/A' with float nan."""
-    for k, v in d.iteritems():
+    for k, v in d.items():
         if isinstance(v, dict):
             nan_replace(v)
         elif v == 'N/A':
@@ -190,5 +198,5 @@ def mac_to_int(mac):
 def int_to_mac(i):
     """Converts integer representation of MAC address to hex string."""
     mac = format(i, 'x').zfill(12)
-    blocks = [mac[x:x + 2] for x in xrange(0, len(mac), 2)]
+    blocks = [mac[x:x + 2] for x in range(0, len(mac), 2)]
     return ':'.join(blocks)