nfvbench/traffic_gen/traffic_utils.py

   1 # Copyright 2016 Cisco Systems, Inc.  All rights reserved.
   2 #
   3 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   4 #    not use this file except in compliance with the License. You may obtain
   5 #    a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 #    Unless required by applicable law or agreed to in writing, software
  10 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 #    License for the specific language governing permissions and limitations
  13 #    under the License.
  14
  15
  16 import bitmath
  17 from nfvbench.utils import multiplier_map
  18
  19 imix_avg_l2_size = None
  20
  21
  22 def convert_rates(l2frame_size, rate, intf_speed):
  23     avg_packet_size = get_average_packet_size(l2frame_size)
  24     if 'rate_pps' in rate:
  25         initial_rate_type = 'rate_pps'
  26         pps = rate['rate_pps']
  27         bps = pps_to_bps(pps, avg_packet_size)
  28         load = bps_to_load(bps, intf_speed)
  29     elif 'rate_bps' in rate:
  30         initial_rate_type = 'rate_bps'
  31         bps = rate['rate_bps']
  32         load = bps_to_load(bps, intf_speed)
  33         pps = bps_to_pps(bps, avg_packet_size)
  34     elif 'rate_percent' in rate:
  35         initial_rate_type = 'rate_percent'
  36         load = rate['rate_percent']
  37         bps = load_to_bps(load, intf_speed)
  38         pps = bps_to_pps(bps, avg_packet_size)
  39     else:
  40         raise Exception('Traffic config needs to have a rate type key')
  41
  42     return {
  43         'initial_rate_type': initial_rate_type,
  44         'rate_pps': int(pps),
  45         'rate_percent': load,
  46         'rate_bps': int(bps)
  47     }
  48
  49
  50 def get_average_packet_size(l2frame_size):
  51     if l2frame_size.upper() == 'IMIX':
  52         return imix_avg_l2_size
  53     return float(l2frame_size)
  54
  55
  56 def load_to_bps(load_percentage, intf_speed):
  57     return float(load_percentage) / 100.0 * intf_speed
  58
  59
  60 def bps_to_load(bps, intf_speed):
  61     return float(bps) / intf_speed * 100.0
  62
  63
  64 def bps_to_pps(bps, avg_packet_size):
  65     return float(bps) / (avg_packet_size + 20.0) / 8
  66
  67
  68 def pps_to_bps(pps, avg_packet_size):
  69     return float(pps) * (avg_packet_size + 20.0) * 8
  70
  71
  72 def weighted_avg(weight, count):
  73     if sum(weight):
  74
  75         return sum([x[0] * x[1] for x in zip(weight, count)]) / sum(weight)
  76     return float('nan')
  77
  78 def parse_rate_str(rate_str):
  79     if rate_str.endswith('pps'):
  80         rate_pps = rate_str[:-3]
  81         if not rate_pps:
  82             raise Exception('%s is missing a numeric value' % rate_str)
  83         try:
  84             multiplier = multiplier_map[rate_pps[-1].upper()]
  85             rate_pps = rate_pps[:-1]
  86         except KeyError:
  87             multiplier = 1
  88         rate_pps = int(rate_pps.strip()) * multiplier
  89         if rate_pps <= 0:
  90             raise Exception('%s is out of valid range' % rate_str)
  91         return {'rate_pps': str(rate_pps)}
  92     elif rate_str.endswith('ps'):
  93         rate = rate_str.replace('ps', '').strip()
  94         bit_rate = bitmath.parse_string(rate).bits
  95         if bit_rate <= 0:
  96             raise Exception('%s is out of valid range' % rate_str)
  97         return {'rate_bps': str(int(bit_rate))}
  98     elif rate_str.endswith('%'):
  99         rate_percent = float(rate_str.replace('%', '').strip())
 100         if rate_percent <= 0 or rate_percent > 100.0:
 101             raise Exception('%s is out of valid range (must be 1-100%%)' % rate_str)
 102         return {'rate_percent': str(rate_percent)}
 103     else:
 104         raise Exception('Unknown rate string format %s' % rate_str)
 105
 106
 107 def divide_rate(rate, divisor):
 108     if 'rate_pps' in rate:
 109         key = 'rate_pps'
 110         value = int(rate[key])
 111     elif 'rate_bps' in rate:
 112         key = 'rate_bps'
 113         value = int(rate[key])
 114     else:
 115         key = 'rate_percent'
 116         value = float(rate[key])
 117     value /= divisor
 118     rate = dict(rate)
 119     rate[key] = str(value) if value else str(1)
 120     return rate
 121
 122
 123 def to_rate_str(rate):
 124     if 'rate_pps' in rate:
 125         pps = rate['rate_pps']
 126         return '{}pps'.format(pps)
 127     elif 'rate_bps' in rate:
 128         bps = rate['rate_bps']
 129         return '{}bps'.format(bps)
 130     elif 'rate_percent' in rate:
 131         load = rate['rate_percent']
 132         return '{}%'.format(load)
 133     else:
 134         assert False
 135
 136
 137 def nan_replace(d):
 138     """Replaces every occurence of 'N/A' with float nan."""
 139     for k, v in d.iteritems():
 140         if isinstance(v, dict):
 141             nan_replace(v)
 142         elif v == 'N/A':
 143             d[k] = float('nan')
 144
 145
 146 def mac_to_int(mac):
 147     """Converts MAC address to integer representation."""
 148     return int(mac.translate(None, ":.- "), 16)
 149
 150
 151 def int_to_mac(i):
 152     """Converts integer representation of MAC address to hex string."""
 153     mac = format(i, 'x').zfill(12)
 154     blocks = [mac[x:x + 2] for x in xrange(0, len(mac), 2)]
 155     return ':'.join(blocks)