diff options
Diffstat (limited to 'resources/tools/t-rex/t-rex-stateless.py')
| -rwxr-xr-x | resources/tools/t-rex/t-rex-stateless.py | 158 |
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()) |