CSIT-136 IMIX T-REX driver

Change-Id: Ife7c543d07bcac4bad82894eea0f4e0e5a8db4bb
Signed-off-by: Miroslav Miklus <mmiklus@cisco.com>

1 files changed, 97 insertions, 61 deletions

diff --git a/resources/tools/t-rex/t-rex-stateless.py b/resources/tools/t-rex/t-rex-stateless.py
index 7ff4c3713c..347782b3a3 100755
--- a/resources/tools/t-rex/t-rex-stateless.py
+++ b/resources/tools/t-rex/t-rex-stateless.py
@@ -52,6 +52,10 @@ sys.path.insert(0, "/opt/trex-core-2.03/scripts/automation/"+\
                    "trex_control_plane/stl/")
 from trex_stl_lib.api import *
 
+stream_table = {'IMIX_v4_1': [{'size': 64, 'pps': 28, 'isg':0},
+                              {'size': 570, 'pps': 16, 'isg':0.1},
+                              {'size': 1518, 'pps': 4, 'isg':0.2}]
+               }
 
 def generate_payload(length):
     """Generate payload.
@@ -100,8 +104,75 @@ def get_start_end_ipv6(start_ip, end_ip):
 
     return base_p1, max_p1
 
+def create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size):
+    """Create STLStream streams
+
+    :param base_pkt_a: Base packet a for stream_a
+    :param base_pkt_b: Base packet b for stream_b
+    :param vm1: vm for stream_a
+    :param vm2: vm for stream_b
+    :param frame_size: frame size or name of traffic profile
+    :type base_pkt_a: Eth (scapy)
+    :type base_pkt_b: Eth (scapy)
+    :type vm1: STLScVmRaw
+    :type vm2: STLScVmRaw
+    :frame_size: int or string
+    :return: stream_a, stream_b, stream_a_latency, stream_b_latency
+    :rtype: STLStream, STLStream, STLStream, STLStream
+    """
+
+    if type(frame_size) is int:
+
+        fsize_no_fcs = frame_size - 4 # no FCS
+        pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
+            max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
+        pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
+            max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
+        pkt_lat_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
+            max(0, fsize_no_fcs-len(base_pkt_a))))
+        pkt_lat_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
+            max(0, fsize_no_fcs-len(base_pkt_b))))
+        lat_stream1 = STLStream(packet=pkt_lat_a,
+                                flow_stats=STLFlowLatencyStats(pg_id=0),
+                                mode=STLTXCont(pps=1000))
+        # second traffic stream with a phase of 10ns (inter stream gap)
+        lat_stream2 = STLStream(packet=pkt_lat_b,
+                                isg=10.0,
+                                flow_stats=STLFlowLatencyStats(pg_id=1),
+                                mode=STLTXCont(pps=1000))
+
+        stream1 = STLStream(packet=pkt_a,
+                            mode=STLTXCont(pps=1000))
+        # second traffic stream with a phase of 10ns (inter stream gap)
+        stream2 = STLStream(packet=pkt_b,
+                            isg=10.0,
+                            mode=STLTXCont(pps=1000))
+    elif type(frame_size) is str:
+        lat_stream1 = []
+        lat_stream2 = []
+        stream1 = []
+        stream2 = []
+
+        for x in stream_table[frame_size]:
+            fsize_no_fcs = x['size'] - 4 # no FCS
+            pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
+                max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
+            pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
+                max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
+
+            stream1.append(STLStream(packet=pkt_a,
+                               isg=x['isg'],
+                               mode=STLTXCont(pps=x['pps'])))
+            stream2.append(STLStream(packet=pkt_b,
+                               isg=x['isg'],
+                               mode=STLTXCont(pps=x['pps'])))
 
-def create_packets(traffic_options, frame_size=64):
+    else:
+        raise ValueError("Unknown frame_size type")
+
+    return (stream1, stream2, lat_stream1, lat_stream2)
+
+def create_streams(traffic_options, frame_size=64):
     """Create two IP packets to be used in stream.
 
     :param traffic_options: Parameters for packets.
@@ -112,12 +183,10 @@ def create_packets(traffic_options, frame_size=64):
     :rtype: Tuple of STLPktBuilder
     """
 
-    if frame_size < 64:
-        print_error("Packet min. size is 64B")
+    if type(frame_size) is int and frame_size < 64:
+        print_error("Frame min. size is 64B")
         sys.exit(1)
 
-    fsize_no_fcs = frame_size - 4 # no FCS
-
     p1_src_start_ip = traffic_options['p1_src_start_ip']
     p1_src_end_ip = traffic_options['p1_src_end_ip']
     p1_dst_start_ip = traffic_options['p1_dst_start_ip']
@@ -149,19 +218,10 @@ def create_packets(traffic_options, frame_size=64):
                       STLVmFixIpv4(offset="IP"),
                      ], split_by_field="src")
 
-    pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
-    pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
-    lat_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_a))))
-    lat_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_b))))
+    return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size)
 
-    return(pkt_a, pkt_b, lat_a, lat_b)
 
-
-def create_packets_v6(traffic_options, frame_size=78):
+def create_streams_v6(traffic_options, frame_size=78):
     """Create two IPv6 packets to be used in stream.
 
     :param traffic_options: Parameters for packets.
@@ -172,12 +232,10 @@ def create_packets_v6(traffic_options, frame_size=78):
     :rtype: Tuple of STLPktBuilder
     """
 
-    if frame_size < 78:
-        print "Packet min. size is 78B"
+    if type(frame_size) is int and frame_size < 78:
+        print_error("Frame min. size is 78B")
         sys.exit(2)
 
-    fsize_no_fcs = frame_size - 4 # no FCS
-
     p1_src_start_ip = traffic_options['p1_src_start_ip']
     p1_src_end_ip = traffic_options['p1_src_end_ip']
     p1_dst_start_ip = traffic_options['p1_dst_start_ip']
@@ -213,19 +271,9 @@ def create_packets_v6(traffic_options, frame_size=78):
                      ]
                      , split_by_field="ipv6_src")
 
-    pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_a))), vm=vm1)
-    pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_b))), vm=vm2)
-    lat_a = STLPktBuilder(pkt=base_pkt_a/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_a))))
-    lat_b = STLPktBuilder(pkt=base_pkt_b/generate_payload(
-        max(0, fsize_no_fcs-len(base_pkt_b))))
-
-    return(pkt_a, pkt_b, lat_a, lat_b)
-
+    return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size)
 
-def simple_burst(pkt_a, pkt_b, pkt_lat_a, pkt_lat_b, duration, rate,
+def simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b, duration, rate,
                  warmup_time, async_start, latency):
     """Run the traffic with specific parameters.
 
@@ -270,28 +318,12 @@ def simple_burst(pkt_a, pkt_b, pkt_lat_a, pkt_lat_b, duration, rate,
         # prepare our ports (my machine has 0 <--> 1 with static route)
         client.reset(ports=[0, 1])
 
-        # create two traffic streams without latency stats
-        stream1 = STLStream(packet=pkt_a,
-                            mode=STLTXCont(pps=1000))
-        # second traffic stream with a phase of 10ns (inter stream gap)
-        stream2 = STLStream(packet=pkt_b,
-                            isg=10.0,
-                            mode=STLTXCont(pps=1000))
-        client.add_streams(stream1, ports=[0])
-        client.add_streams(stream2, ports=[1])
+        client.add_streams(stream_a, ports=[0])
+        client.add_streams(stream_b, ports=[1])
 
         if latency:
-            # create two traffic streams with latency stats
-            lat_stream1 = STLStream(packet=pkt_lat_a,
-                                    flow_stats=STLFlowLatencyStats(pg_id=0),
-                                    mode=STLTXCont(pps=1000))
-            # second traffic stream with a phase of 10ns (inter stream gap)
-            lat_stream2 = STLStream(packet=pkt_lat_b,
-                                    isg=10.0,
-                                    flow_stats=STLFlowLatencyStats(pg_id=1),
-                                    mode=STLTXCont(pps=1000))
-            client.add_streams(lat_stream1, ports=[0])
-            client.add_streams(lat_stream2, ports=[1])
+            client.add_streams(stream_lat_a, ports=[0])
+            client.add_streams(stream_lat_b, ports=[1])
 
         #warmup phase
         if warmup_time > 0:
@@ -397,7 +429,7 @@ def parse_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("-d", "--duration", required=True, type=int,
                         help="Duration of traffic run")
-    parser.add_argument("-s", "--frame_size", required=True, type=int,
+    parser.add_argument("-s", "--frame_size", required=True,
                         help="Size of a Frame without padding and IPG")
     parser.add_argument("-r", "--rate", required=True,
                         help="Traffic rate with included units (%, pps)")
@@ -447,11 +479,15 @@ def main():
     args = parse_args()
 
     _duration = args.duration
-    _frame_size = args.frame_size
+    _latency = args.latency
+    if args.frame_size.isdigit():
+        _frame_size = int(args.frame_size)
+    else:
+        _frame_size = args.frame_size
+        _latency = False
     _rate = args.rate
     _use_ipv6 = args.use_IPv6
     _async_call = args.async
-    _latency = args.latency
     _warmup_time = args.warmup_time
 
     _traffic_options = {}
@@ -464,14 +500,14 @@ def main():
         print_error('IPv6 latency is not supported yet. Running without lat.')
         _latency = False
 
-        pkt_a, pkt_b, lat_a, lat_b = create_packets_v6(_traffic_options,
-                                                       frame_size=_frame_size)
+        stream_a, stream_b, stream_lat_a, stream_lat_b = create_streams_v6(
+            _traffic_options, frame_size=_frame_size)
     else:
-        pkt_a, pkt_b, lat_a, lat_b = create_packets(_traffic_options,
-                                                    frame_size=_frame_size)
+        stream_a, stream_b, stream_lat_a, stream_lat_b = create_streams(
+            _traffic_options, frame_size=_frame_size)
 
-    simple_burst(pkt_a, pkt_b, lat_a, lat_b, _duration, _rate, _warmup_time,
-                 _async_call, _latency)
+    simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b,
+                 _duration, _rate, _warmup_time, _async_call, _latency)
 
 if __name__ == "__main__":
     sys.exit(main())