X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Ft-rex%2Ft-rex-stateless.py;h=24f4a997389ba3f10ad42e1f9564ef915fd58b44;hp=97ccc9730493e384fc57c139904b20e3f33c0e83;hb=868380b0204758ef34c6be5bae0c9bdb00c4107f;hpb=10f3b07a5c883e20ef345c8b1c8e24063a50281f diff --git a/resources/tools/t-rex/t-rex-stateless.py b/resources/tools/t-rex/t-rex-stateless.py index 97ccc97304..24f4a99738 100755 --- a/resources/tools/t-rex/t-rex-stateless.py +++ b/resources/tools/t-rex/t-rex-stateless.py @@ -41,16 +41,21 @@ Functionality: """ +import argparse import json import socket import string import struct -import sys, getopt +import sys -sys.path.insert(0, "/opt/trex-core-2.00/scripts/automation/"+\ +sys.path.insert(0, "/opt/trex-core-2.09/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. @@ -91,7 +96,7 @@ def get_start_end_ipv6(start_ip, end_ip): print "IPv6: start_ip is greater then end_ip" sys.exit(2) - max_p1 = abs(int(lo1) - int(lo2)) + 1 + max_p1 = abs(int(lo1) - int(lo2)) base_p1 = lo1 except AddressValueError as ex_error: print ex_error @@ -99,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=9000)) + # 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=9000)) -def create_packets(traffic_options, frame_size=64): + stream1 = STLStream(packet=pkt_a, + mode=STLTXCont(pps=9000)) + # second traffic stream with a phase of 10ns (inter stream gap) + stream2 = STLStream(packet=pkt_b, + isg=10.0, + mode=STLTXCont(pps=9000)) + 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']))) + + 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. @@ -108,15 +180,13 @@ def create_packets(traffic_options, frame_size=64): :type traffic_options: list :type frame_size: int :return: Packet instances. - :rtype STLPktBuilder + :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'] @@ -124,39 +194,50 @@ def create_packets(traffic_options, frame_size=64): p2_src_end_ip = traffic_options['p2_src_end_ip'] p2_dst_start_ip = traffic_options['p2_dst_start_ip'] + p1_dst_end_ip = traffic_options['p1_dst_end_ip'] + p2_dst_end_ip = traffic_options['p2_dst_end_ip'] + base_pkt_a = Ether()/IP(src=p1_src_start_ip, dst=p1_dst_start_ip, proto=61) base_pkt_b = Ether()/IP(src=p2_src_start_ip, dst=p2_dst_start_ip, proto=61) - # The following code applies raw instructions to packet (IP src increment). - # It splits the generated traffic by "ip_src" variable to cores and fix - # IPv4 header checksum. - vm1 = STLScVmRaw([STLVmFlowVar(name="src", - min_value=p1_src_start_ip, - max_value=p1_src_end_ip, - size=4, op="inc"), - STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"), - STLVmFixIpv4(offset="IP"), - ], split_by_field="src") - # The following code applies raw instructions to packet (IP src increment). - # It splits the generated traffic by "ip_src" variable to cores and fix - # IPv4 header checksum. - vm2 = STLScVmRaw([STLVmFlowVar(name="src", - min_value=p2_src_start_ip, - max_value=p2_src_end_ip, - size=4, op="inc"), - STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"), - STLVmFixIpv4(offset="IP"), - ], split_by_field="src") - - pkt_a = STLPktBuilder(pkt=base_pkt_a/generate_payload( - fsize_no_fcs-len(base_pkt_a)), vm=vm1) - pkt_b = STLPktBuilder(pkt=base_pkt_b/generate_payload( - fsize_no_fcs-len(base_pkt_b)), vm=vm2) - - return(pkt_a, pkt_b) - - -def create_packets_v6(traffic_options, frame_size=78): + # The following code applies raw instructions to packet (IP src/dst + # increment). It splits the generated traffic by "ip_src"/"ip_dst" variable + # to cores and fix IPv4 header checksum. + if p1_dst_end_ip and p2_dst_end_ip: + vm1 = STLScVmRaw([STLVmFlowVar(name="dst", + min_value=p1_dst_start_ip, + max_value=p1_dst_end_ip, + size=4, op="inc"), + STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"), + STLVmFixIpv4(offset="IP"), + ], split_by_field="dst") + vm2 = STLScVmRaw([STLVmFlowVar(name="dst", + min_value=p2_dst_start_ip, + max_value=p2_dst_end_ip, + size=4, op="inc"), + STLVmWrFlowVar(fv_name="dst", pkt_offset="IP.dst"), + STLVmFixIpv4(offset="IP"), + ], split_by_field="dst") + else: + vm1 = STLScVmRaw([STLVmFlowVar(name="src", + min_value=p1_src_start_ip, + max_value=p1_src_end_ip, + size=4, op="inc"), + STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"), + STLVmFixIpv4(offset="IP"), + ], split_by_field="src") + vm2 = STLScVmRaw([STLVmFlowVar(name="src", + min_value=p2_src_start_ip, + max_value=p2_src_end_ip, + size=4, op="inc"), + STLVmWrFlowVar(fv_name="src", pkt_offset="IP.src"), + STLVmFixIpv4(offset="IP"), + ], split_by_field="src") + + return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size) + + +def create_streams_v6(traffic_options, frame_size=78): """Create two IPv6 packets to be used in stream. :param traffic_options: Parameters for packets. @@ -164,15 +245,13 @@ def create_packets_v6(traffic_options, frame_size=78): :type traffic_options: List :type frame_size: int :return: Packet instances. - :rtype STLPktBuilder + :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'] @@ -180,55 +259,112 @@ def create_packets_v6(traffic_options, frame_size=78): p2_src_end_ip = traffic_options['p2_src_end_ip'] p2_dst_start_ip = traffic_options['p2_dst_start_ip'] - base_p1, max_p1 = get_start_end_ipv6(p1_src_start_ip, p1_src_end_ip) - base_p2, max_p2 = get_start_end_ipv6(p2_src_start_ip, p2_src_end_ip) + p1_dst_end_ip = traffic_options['p1_dst_end_ip'] + p2_dst_end_ip = traffic_options['p2_dst_end_ip'] base_pkt_a = Ether()/IPv6(src=p1_src_start_ip, dst=p1_dst_start_ip) base_pkt_b = Ether()/IPv6(src=p2_src_start_ip, dst=p2_dst_start_ip) - # The following code applies raw instructions to packet (IP src increment). - # It splits the generated traffic by "ip_src" variable to cores - vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_src", - min_value=base_p1, - max_value=max_p1+base_p1, - size=8, op="inc"), - STLVmWrFlowVar(fv_name="ipv6_src", pkt_offset="IPv6.src", - offset_fixup=8) - ] - , split_by_field="ipv6_src") - - # The following code applies raw instructions to packet (IP src increment). - # It splits the generated traffic by "ip_src" variable to cores - vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_src", - min_value=base_p2, - max_value=max_p2+base_p2, - size=8, op="inc"), - STLVmWrFlowVar(fv_name="ipv6_src", pkt_offset="IPv6.src", - offset_fixup=8) - ] - , 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) - - return(pkt_a, pkt_b) - - -def simple_burst(pkt_a, pkt_b, duration=10, rate="1mpps", warmup_time=5): + # The following code applies raw instructions to packet (IP src/dst + # increment). It splits the generated traffic by "ip_src"/"ip_dst" variable + # to cores. + if p1_dst_end_ip and p2_dst_end_ip: + base_p1, max_p1 = get_start_end_ipv6(p1_dst_start_ip, p1_dst_end_ip) + base_p2, max_p2 = get_start_end_ipv6(p2_dst_start_ip, p2_dst_end_ip) + + vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_dst", + min_value=base_p1, + max_value=max_p1+base_p1, + size=8, op="inc"), + STLVmWrFlowVar(fv_name="ipv6_dst", + pkt_offset="IPv6.dst", + offset_fixup=8) + ] + , split_by_field="ipv6_dst") + vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_dst", + min_value=base_p2, + max_value=max_p2+base_p2, + size=8, op="inc"), + STLVmWrFlowVar(fv_name="ipv6_dst", + pkt_offset="IPv6.dst", + offset_fixup=8) + ] + , split_by_field="ipv6_dst") + else: + base_p1, max_p1 = get_start_end_ipv6(p1_src_start_ip, p1_src_end_ip) + base_p2, max_p2 = get_start_end_ipv6(p2_src_start_ip, p2_src_end_ip) + + vm1 = STLScVmRaw([STLVmFlowVar(name="ipv6_src", + min_value=base_p1, + max_value=max_p1+base_p1, + size=8, op="inc"), + STLVmWrFlowVar(fv_name="ipv6_src", + pkt_offset="IPv6.src", + offset_fixup=8) + ] + , split_by_field="ipv6_src") + vm2 = STLScVmRaw([STLVmFlowVar(name="ipv6_src", + min_value=base_p2, + max_value=max_p2+base_p2, + size=8, op="inc"), + STLVmWrFlowVar(fv_name="ipv6_src", + pkt_offset="IPv6.src", + offset_fixup=8) + ] + , split_by_field="ipv6_src") + + return create_streams_v46(base_pkt_a, base_pkt_b, vm1, vm2, frame_size) + +def fmt_latency(lat_min, lat_avg, lat_max): + """ Return formatted, rounded latency + + :param lat_min: Min latency + :param lat_avg: Average latency + :param lat_max: Max latency + :type lat_min: string + :type lat_avg: string + :type lat_max: string + :return: Formatted and rounded output "min/avg/max" + :rtype: string + """ + + try: + t_min = int(round(float(lat_min))) + except ValueError: + t_min = int(-1) + try: + t_avg = int(round(float(lat_avg))) + except ValueError: + t_avg = int(-1) + try: + t_max = int(round(float(lat_max))) + except ValueError: + t_max = int(-1) + + return "/".join(str(tmp) for tmp in (t_min, t_avg, t_max)) + +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. :param pkt_a: Base packet for stream 1. :param pkt_b: Base packet for stream 2. - :param duration: Duration of traffic run in seconds. + :param pkt_lat_a: Base packet for latency stream 1. + :param pkt_lat_b: Base packet for latency stream 2. + :param duration: Duration of traffic run in seconds (-1=infinite). :param rate: Rate of traffic run [percentage, pps, bps]. :param warmup_time: Warm up duration. + :param async_start: Start the traffic and exit. + :param latency: With latency stats. :type pkt_a: STLPktBuilder :type pkt_b: STLPktBuilder + :type pkt_lat_a: STLPktBuilder + :type pkt_lat_b: STLPktBuilder :type duration: int :type rate: string :type warmup_time: int + :type async_start: bool + :type latency: bool :return: nothing """ @@ -239,37 +375,49 @@ def simple_burst(pkt_a, pkt_b, duration=10, rate="1mpps", warmup_time=5): total_sent = 0 lost_a = 0 lost_b = 0 + lat_a = "-1/-1/-1" + lat_b = "-1/-1/-1" try: # turn this off if too many logs #client.set_verbose("high") - # create two streams - stream1 = STLStream(packet=pkt_a, - mode=STLTXCont(pps=100)) - - # second stream with a phase of 10ns (inter stream gap) - stream2 = STLStream(packet=pkt_b, - isg=10.0, - mode=STLTXCont(pps=100)) - # connect to server client.connect() # prepare our ports (my machine has 0 <--> 1 with static route) client.reset(ports=[0, 1]) - # add both streams to ports - 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: + try: + client.add_streams(stream_lat_a, ports=[0]) + client.add_streams(stream_lat_b, ports=[1]) + except: + #Disable latency if NIC does not support requested stream type + print "##### FAILED to add latency streams #####" + latency = False #warmup phase - if warmup_time is not None: + if warmup_time > 0: + # clear the stats before injecting client.clear_stats() + + # choose rate and start traffic client.start(ports=[0, 1], mult=rate, duration=warmup_time) + + # block until done client.wait_on_traffic(ports=[0, 1], timeout=(warmup_time+30)) + + if client.get_warnings(): + for warning in client.get_warnings(): + print(warning) + + # read the stats after the test stats = client.get_stats() - print stats + print "#####warmup statistics#####" print json.dumps(stats, indent=4, separators=(',', ': '), sort_keys=True) @@ -279,64 +427,60 @@ def simple_burst(pkt_a, pkt_b, duration=10, rate="1mpps", warmup_time=5): print "\npackets lost from 0 --> 1: {0} pkts".format(lost_a) print "packets lost from 1 --> 0: {0} pkts".format(lost_b) - # clear the stats before injecting client.clear_stats() - total_rcvd = 0 - total_sent = 0 lost_a = 0 lost_b = 0 # choose rate and start traffic client.start(ports=[0, 1], mult=rate, duration=duration) - # block until done - client.wait_on_traffic(ports=[0, 1], timeout=(duration+30)) + if not async_start: + # block until done + client.wait_on_traffic(ports=[0, 1], timeout=(duration+30)) - # read the stats after the test - stats = client.get_stats() + if client.get_warnings(): + for warning in client.get_warnings(): + print(warning) - print "#####statistics#####" - print json.dumps(stats, indent=4, - separators=(',', ': '), sort_keys=True) + # read the stats after the test + stats = client.get_stats() - lost_a = stats[0]["opackets"] - stats[1]["ipackets"] - lost_b = stats[1]["opackets"] - stats[0]["ipackets"] + print "#####statistics#####" + print json.dumps(stats, indent=4, + separators=(',', ': '), sort_keys=True) + lost_a = stats[0]["opackets"] - stats[1]["ipackets"] + lost_b = stats[1]["opackets"] - stats[0]["ipackets"] - total_sent = stats[0]["opackets"] + stats[1]["opackets"] - total_rcvd = stats[0]["ipackets"] + stats[1]["ipackets"] + if latency: + lat_a = fmt_latency(\ + str(stats["latency"][0]["latency"]["total_min"]),\ + str(stats["latency"][0]["latency"]["average"]),\ + str(stats["latency"][0]["latency"]["total_max"])) + lat_b = fmt_latency(\ + str(stats["latency"][1]["latency"]["total_min"]),\ + str(stats["latency"][1]["latency"]["average"]),\ + str(stats["latency"][1]["latency"]["total_max"])) - print "\npackets lost from 0 --> 1: {0} pkts".format(lost_a) - print "packets lost from 1 --> 0: {0} pkts".format(lost_b) + total_sent = stats[0]["opackets"] + stats[1]["opackets"] + total_rcvd = stats[0]["ipackets"] + stats[1]["ipackets"] + + print "\npackets lost from 0 --> 1: {0} pkts".format(lost_a) + print "packets lost from 1 --> 0: {0} pkts".format(lost_b) except STLError as ex_error: print_error(str(ex_error)) sys.exit(1) finally: - client.disconnect() - print "rate={0}, totalReceived={1}, totalSent={2}, frameLoss={3}"\ - .format(rate, total_rcvd, total_sent, lost_a+lost_b) - - -def print_help(): - """Print help on stdout.""" - - print "args: [-h] -d -s "+\ - " [-r] "+\ - " [-6] Use of ipv6 "+\ - "--p1_src_mac "+\ - "--p1_dst_mac "+\ - "--p1_src_start_ip "+\ - "--p1_src_end_ip "+\ - "--p1_dst_start_ip "+\ - "--p1_dst_end_ip "+\ - "--p2_src_mac "+\ - "--p2_dst_mac "+\ - "--p2_src_start_ip "+\ - "--p2_src_end_ip "+\ - "--p2_dst_start_ip "+\ - "--p2_dst_end_ip " + if async_start: + client.disconnect(stop_traffic=False, release_ports=True) + else: + client.disconnect() + print "rate={0}, totalReceived={1}, totalSent={2}, "\ + "frameLoss={3}, latencyStream0(usec)={4}, "\ + "latencyStream1(usec)={5}".format(rate, total_rcvd,\ + total_sent, lost_a+lost_b, lat_a, lat_b) def print_error(msg): @@ -350,62 +494,95 @@ def print_error(msg): sys.stderr.write(msg+'\n') -def main(argv): +def parse_args(): + """Parse arguments from cmd line. + + :return: Parsed arguments. + :rtype ArgumentParser + """ + + 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, + help="Size of a Frame without padding and IPG") + parser.add_argument("-r", "--rate", required=True, + help="Traffic rate with included units (%, pps)") + parser.add_argument("-6", "--use_IPv6", action="store_true", + default=False, + help="Use IPv6 traffic profile instead of IPv4") + parser.add_argument("--async", action="store_true", + default=False, + help="Non-blocking call of the script") + parser.add_argument("--latency", action="store_true", + default=False, + help="Add latency stream") + parser.add_argument("-w", "--warmup_time", type=int, + default=5, + help="Traffic warmup time in seconds, 0 = disable") +# parser.add_argument("--p1_src_mac", +# help="Port 1 source MAC address") +# parser.add_argument("--p1_dst_mac", +# help="Port 1 destination MAC address") + parser.add_argument("--p1_src_start_ip", required=True, + help="Port 1 source start IP address") + parser.add_argument("--p1_src_end_ip", + default=False, + help="Port 1 source end IP address") + parser.add_argument("--p1_dst_start_ip", required=True, + help="Port 1 destination start IP address") + parser.add_argument("--p1_dst_end_ip", + default=False, + help="Port 1 destination end IP address") +# parser.add_argument("--p2_src_mac", +# help="Port 2 source MAC address") +# parser.add_argument("--p2_dst_mac", +# help="Port 2 destination MAC address") + parser.add_argument("--p2_src_start_ip", required=True, + help="Port 2 source start IP address") + parser.add_argument("--p2_src_end_ip", + default=False, + help="Port 2 source end IP address") + parser.add_argument("--p2_dst_start_ip", required=True, + help="Port 2 destination start IP address") + parser.add_argument("--p2_dst_end_ip", + default=False, + help="Port 2 destination end IP address") + + return parser.parse_args() + + +def main(): """Main function.""" - _duration = 10 - _frame_size = 64 - _rate = '1mpps' - _traffic_options = {} - _use_ipv6 = False + args = parse_args() - try: - opts, _ = getopt.getopt(argv, "hd:s:r:6o:", - ["help", - "p1_src_mac=", - "p1_dst_mac=", - "p1_src_start_ip=", - "p1_src_end_ip=", - "p1_dst_start_ip=", - "p1_dst_end_ip=", - "p2_src_mac=", - "p2_dst_mac=", - "p2_src_start_ip=", - "p2_src_end_ip=", - "p2_dst_start_ip=", - "p2_dst_end_ip="]) - except getopt.GetoptError: - print_help() - sys.exit(1) - for opt, arg in opts: - if opt in ('-h', "--help"): - print_help() - sys.exit() - elif opt == '-d': - _duration = int(arg) - elif opt == '-s': - _frame_size = int(arg) - elif opt == '-r': - _rate = arg - elif opt == '-6': - _use_ipv6 = True - elif opt.startswith("--p"): - _traffic_options[opt[2:]] = arg - - print _traffic_options - if len(_traffic_options) != 6: - print_error("Supported only: src_start_ip, src_end_ip, dst_start_ip") - print_help() - sys.exit(1) + _duration = args.duration + _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 + _warmup_time = args.warmup_time + + _traffic_options = {} + for attr in [a for a in dir(args) if a.startswith('p')]: + if getattr(args, attr) is not None: + _traffic_options[attr] = getattr(args, attr) if _use_ipv6: - pkt_a, pkt_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 = 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, duration=_duration, rate=_rate) + simple_burst(stream_a, stream_b, stream_lat_a, stream_lat_b, + _duration, _rate, _warmup_time, _async_call, _latency) if __name__ == "__main__": - main(sys.argv[1:]) + sys.exit(main())