diff options
Diffstat (limited to 'GPL')
24 files changed, 1523 insertions, 303 deletions
diff --git a/GPL/tools/trex/trex_astf_profile.py b/GPL/tools/trex/trex_astf_profile.py index 0542486105..63831e4bf4 100644 --- a/GPL/tools/trex/trex_astf_profile.py +++ b/GPL/tools/trex/trex_astf_profile.py @@ -15,7 +15,7 @@ """This module gets T-Rex advanced stateful (astf) traffic profile together with other parameters, reads the profile and sends the traffic. At the end, it -measures the packet loss and latency. +parses for various counters. """ import argparse @@ -60,8 +60,16 @@ def fmt_latency(lat_min, lat_avg, lat_max, hdrh): def simple_burst( - profile_file, duration, framesize, mult, warmup_time, port_0, port_1, - latency, async_start=False, traffic_directions=2): + profile_file, + duration, + framesize, + multiplier, + port_0, + port_1, + latency, + async_start=False, + traffic_directions=2, + ): """Send traffic and measure packet loss and latency. Procedure: @@ -70,20 +78,36 @@ def simple_burst( - resets the ports, - removes all existing streams, - adds streams from the traffic profile to the ports, - - if the warm-up time is more than 0, sends the warm-up traffic, reads the - statistics, - clears the statistics from the client, - starts the traffic, - waits for the defined time (or runs forever if async mode is defined), - - stops the traffic, + - explicitly stops the traffic, - reads and displays the statistics and - disconnects from the client. + Duration details: + Contrary to stateless mode, ASTF profiles typically limit the number + of flows/transactions that can happen. + The caller is expected to set the duration parameter accordingly to + this limit and multiplier, including any overheads. + See *_traffic_duration output fields for TRex's measurement + of the real traffic duration (should be without any inactivity overheads). + If traffic has not ended by the final time, the traffic + is stopped explicitly, counters reflect the state just after the stop. + + TODO: Support tests which focus only on some transaction phases, + e.g. TCP tests ignoring init and teardown separated by delays. + Currently, approximated time measures the whole traffic duration. + :param profile_file: A python module with T-rex traffic profile. - :param duration: Duration of traffic run in seconds (-1=infinite). + :param duration: Expected duration for all transactions to finish, + assuming only tolerable duration stretching happens. + This includes later start of later transactions + (according to TPS multiplier) and expected duration of each transaction. + Critically, this also includes any delay TRex shows when starting + traffic (but not the similar delay during stopping). :param framesize: Frame size. - :param mult: Multiplier of profile CPS. - :param warmup_time: Traffic warm-up time in seconds, 0 = disable. + :param multiplier: Multiplier of profile CPS. :param port_0: Port 0 on the traffic generator. :param port_1: Port 1 on the traffic generator. :param latency: With latency stats. @@ -92,8 +116,7 @@ def simple_burst( :type profile_file: str :type duration: float :type framesize: int or str - :type mult: int - :type warmup_time: float + :type multiplier: int :type port_0: int :type port_1: int :type latency: bool @@ -101,7 +124,7 @@ def simple_burst( :type traffic_directions: int """ client = None - total_rcvd = 0 + total_received = 0 total_sent = 0 lost_a = 0 lost_b = 0 @@ -111,7 +134,6 @@ def simple_burst( lat_b_hist = u"" l7_data = u"" stats = dict() - stats_sampling = 1.0 approximated_duration = 0 # Read the profile. @@ -139,37 +161,6 @@ def simple_burst( if traffic_directions > 1: ports.append(port_1) - # Warm-up phase. - if warmup_time > 0: - # Clear the stats before injecting. - client.clear_stats() - # Choose CPS and start traffic. - client.start(mult=mult, duration=warmup_time) - time_start = time.monotonic() - - # Read the stats after the warmup duration (no sampling needed). - time.sleep(warmup_time) - stats[time.monotonic()-time_start] = client.get_stats() - - if client.get_warnings(): - for warning in client.get_warnings(): - print(warning) - - client.reset() - - print(u"##### Warmup Statistics #####") - print(json.dumps(stats, indent=4, separators=(u",", u": "))) - - # TODO: check stats format - stats = stats[sorted(stats.keys())[-1]] - lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"] - if traffic_directions > 1: - lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"] - - print(f"packets lost from {port_0} --> {port_1}: {lost_a} pkts") - if traffic_directions > 1: - print(f"packets lost from {port_1} --> {port_0}: {lost_b} pkts") - # Clear the stats before injecting. lost_a = 0 lost_b = 0 @@ -177,21 +168,15 @@ def simple_burst( # Choose CPS and start traffic. client.start( - mult=mult, duration=duration, nc=True, - latency_pps=mult if latency else 0, client_mask=2**len(ports)-1 + mult=multiplier, + # Increase the input duration slightly, + # to ensure it does not end before sleep&stop below happens. + duration=duration + 0.1 if duration > 0 else duration, + nc=True, + latency_pps=int(multiplier) if latency else 0, + client_mask=2**len(ports)-1, ) time_start = time.monotonic() - # t-rex starts the packet flow with the delay - stats[time.monotonic()-time_start] = client.get_stats(ports=[port_0]) - while stats[sorted(stats.keys())[-1]][port_0][u"opackets"] == 0: - stats.clear() - time.sleep(0.001) - stats[time.monotonic() - time_start] = \ - client.get_stats(ports=[port_0]) - else: - trex_start_time = list(sorted(stats.keys()))[-1] - time_start += trex_start_time - stats.clear() if async_start: # For async stop, we need to export the current snapshot. @@ -201,26 +186,27 @@ def simple_burst( xsnap1 = client.ports[port_1].get_xstats().reference_stats print(f"Xstats snapshot 1: {xsnap1!r}") else: - time.sleep( - stats_sampling if stats_sampling < duration else duration + time.sleep(duration) + + # Do not block yet, the existing transactions may take long time + # to finish. We need an action that is almost reset(), + # but without clearing stats. + client.stop(block=False) + client.stop_latency() + client.remove_rx_queue(client.get_all_ports()) + # Now we can wait for the real traffic stop. + client.stop(block=True) + + # Read the stats after the traffic stopped (or time up). + stats[time.monotonic() - time_start] = client.get_stats( + ports=ports ) - # Do not block until done. - while client.is_traffic_active(ports=ports): - # Sample the stats. - stats[time.monotonic()-time_start] = \ - client.get_stats(ports=ports) - time.sleep( - stats_sampling if stats_sampling < duration else duration - ) - else: - # Read the stats after the test - stats[time.monotonic()-time_start] = \ - client.get_stats(ports=ports) if client.get_warnings(): for warning in client.get_warnings(): print(warning) + # Now finish the complete reset. client.reset() print(u"##### Statistics #####") @@ -253,8 +239,10 @@ def simple_burst( if traffic_directions > 1: total_sent = \ stats[port_0][u"opackets"] + stats[port_1][u"opackets"] - total_rcvd = \ + total_received = \ stats[port_0][u"ipackets"] + stats[port_1][u"ipackets"] + client_sent = stats[port_0][u"opackets"] + client_received = stats[port_0][u"ipackets"] client_stats = stats[u"traffic"][u"client"] server_stats = stats[u"traffic"][u"server"] # Some zero counters are not sent @@ -263,109 +251,112 @@ def simple_burst( c_act_flows = client_stats[u"m_active_flows"] c_est_flows = client_stats[u"m_est_flows"] c_traffic_duration = client_stats.get(u"m_traffic_duration", 0) - l7_data = f"client_active_flows={c_act_flows}, " - l7_data += f"client_established_flows={c_est_flows}, " - l7_data += f"client_traffic_duration={c_traffic_duration}, " + l7_data = f"client_active_flows={c_act_flows}; " + l7_data += f"client_established_flows={c_est_flows}; " + l7_data += f"client_traffic_duration={c_traffic_duration}; " # Possible errors # Too many packets in NIC rx queue c_err_rx_throttled = client_stats.get(u"err_rx_throttled", 0) - l7_data += f"client_err_rx_throttled={c_err_rx_throttled}, " + l7_data += f"client_err_rx_throttled={c_err_rx_throttled}; " # Number of client side flows that were not opened # due to flow-table overflow c_err_nf_throttled = client_stats.get(u"err_c_nf_throttled", 0) - l7_data += f"client_err_nf_throttled={c_err_nf_throttled}, " + l7_data += f"client_err_nf_throttled={c_err_nf_throttled}; " # Too many flows c_err_flow_overflow = client_stats.get(u"err_flow_overflow", 0) - l7_data += f"client_err_flow_overflow={c_err_flow_overflow}, " + l7_data += f"client_err_flow_overflow={c_err_flow_overflow}; " # Server s_act_flows = server_stats[u"m_active_flows"] s_est_flows = server_stats[u"m_est_flows"] s_traffic_duration = server_stats.get(u"m_traffic_duration", 0) - l7_data += f"server_active_flows={s_act_flows}, " - l7_data += f"server_established_flows={s_est_flows}, " - l7_data += f"server_traffic_duration={s_traffic_duration}, " + l7_data += f"server_active_flows={s_act_flows}; " + l7_data += f"server_established_flows={s_est_flows}; " + l7_data += f"server_traffic_duration={s_traffic_duration}; " # Possible errors # Too many packets in NIC rx queue s_err_rx_throttled = server_stats.get(u"err_rx_throttled", 0) - l7_data += f"client_err_rx_throttled={s_err_rx_throttled}, " + l7_data += f"client_err_rx_throttled={s_err_rx_throttled}; " if u"udp" in profile_file: # Client # Established connections c_udp_connects = client_stats.get(u"udps_connects", 0) - l7_data += f"client_udp_connects={c_udp_connects}, " + l7_data += f"client_udp_connects={c_udp_connects}; " # Closed connections c_udp_closed = client_stats.get(u"udps_closed", 0) - l7_data += f"client_udp_closed={c_udp_closed}, " + l7_data += f"client_udp_closed={c_udp_closed}; " # Sent bytes c_udp_sndbyte = client_stats.get(u"udps_sndbyte", 0) - l7_data += f"client_udp_tx_bytes={c_udp_sndbyte}, " + l7_data += f"client_udp_tx_bytes={c_udp_sndbyte}; " # Sent packets c_udp_sndpkt = client_stats.get(u"udps_sndpkt", 0) - l7_data += f"client_udp_tx_packets={c_udp_sndpkt}, " + l7_data += f"client_udp_tx_packets={c_udp_sndpkt}; " # Received bytes c_udp_rcvbyte = client_stats.get(u"udps_rcvbyte", 0) - l7_data += f"client_udp_rx_bytes={c_udp_rcvbyte}, " + l7_data += f"client_udp_rx_bytes={c_udp_rcvbyte}; " # Received packets c_udp_rcvpkt = client_stats.get(u"udps_rcvpkt", 0) - l7_data += f"client_udp_rx_packets={c_udp_rcvpkt}, " + l7_data += f"client_udp_rx_packets={c_udp_rcvpkt}; " # Keep alive drops c_udp_keepdrops = client_stats.get(u"udps_keepdrops", 0) - l7_data += f"client_udp_keep_drops={c_udp_keepdrops}, " + l7_data += f"client_udp_keep_drops={c_udp_keepdrops}; " + # Client without flow + c_err_cwf = client_stats.get(u"err_cwf", 0) + l7_data += f"client_err_cwf={c_err_cwf}; " # Server # Accepted connections s_udp_accepts = server_stats.get(u"udps_accepts", 0) - l7_data += f"server_udp_accepts={s_udp_accepts}, " + l7_data += f"server_udp_accepts={s_udp_accepts}; " # Closed connections s_udp_closed = server_stats.get(u"udps_closed", 0) - l7_data += f"server_udp_closed={s_udp_closed}, " + l7_data += f"server_udp_closed={s_udp_closed}; " # Sent bytes s_udp_sndbyte = server_stats.get(u"udps_sndbyte", 0) - l7_data += f"server_udp_tx_bytes={s_udp_sndbyte}, " + l7_data += f"server_udp_tx_bytes={s_udp_sndbyte}; " # Sent packets s_udp_sndpkt = server_stats.get(u"udps_sndpkt", 0) - l7_data += f"server_udp_tx_packets={s_udp_sndpkt}, " + l7_data += f"server_udp_tx_packets={s_udp_sndpkt}; " # Received bytes s_udp_rcvbyte = server_stats.get(u"udps_rcvbyte", 0) - l7_data += f"server_udp_rx_bytes={s_udp_rcvbyte}, " + l7_data += f"server_udp_rx_bytes={s_udp_rcvbyte}; " # Received packets s_udp_rcvpkt = server_stats.get(u"udps_rcvpkt", 0) - l7_data += f"server_udp_rx_packets={s_udp_rcvpkt}, " + l7_data += f"server_udp_rx_packets={s_udp_rcvpkt}; " elif u"tcp" in profile_file: # Client - # Initiated connections - c_tcp_connatt = client_stats.get(u"tcps_connattempt", 0) - l7_data += f"client_tcp_connect_inits={c_tcp_connatt}, " + # Connection attempts + c_tcp_connattempt = client_stats.get(u"tcps_connattempt", 0) + l7_data += f"client_tcp_connattempt={c_tcp_connattempt}; " # Established connections c_tcp_connects = client_stats.get(u"tcps_connects", 0) - l7_data += f"client_tcp_connects={c_tcp_connects}, " + l7_data += f"client_tcp_connects={c_tcp_connects}; " # Closed connections c_tcp_closed = client_stats.get(u"tcps_closed", 0) - l7_data += f"client_tcp_closed={c_tcp_closed}, " + l7_data += f"client_tcp_closed={c_tcp_closed}; " # Send bytes c_tcp_sndbyte = client_stats.get(u"tcps_sndbyte", 0) - l7_data += f"client_tcp_tx_bytes={c_tcp_sndbyte}, " + l7_data += f"client_tcp_tx_bytes={c_tcp_sndbyte}; " # Received bytes c_tcp_rcvbyte = client_stats.get(u"tcps_rcvbyte", 0) - l7_data += f"client_tcp_rx_bytes={c_tcp_rcvbyte}, " + l7_data += f"client_tcp_rx_bytes={c_tcp_rcvbyte}; " # Server # Accepted connections s_tcp_accepts = server_stats.get(u"tcps_accepts", 0) - l7_data += f"server_tcp_accepts={s_tcp_accepts}, " + l7_data += f"server_tcp_accepts={s_tcp_accepts}; " # Established connections s_tcp_connects = server_stats.get(u"tcps_connects", 0) - l7_data += f"server_tcp_connects={s_tcp_connects}, " + l7_data += f"server_tcp_connects={s_tcp_connects}; " # Closed connections s_tcp_closed = server_stats.get(u"tcps_closed", 0) - l7_data += f"server_tcp_closed={s_tcp_closed}, " + l7_data += f"server_tcp_closed={s_tcp_closed}; " # Sent bytes s_tcp_sndbyte = server_stats.get(u"tcps_sndbyte", 0) - l7_data += f"server_tcp_tx_bytes={s_tcp_sndbyte}, " + l7_data += f"server_tcp_tx_bytes={s_tcp_sndbyte}; " # Received bytes s_tcp_rcvbyte = server_stats.get(u"tcps_rcvbyte", 0) - l7_data += f"server_tcp_rx_bytes={s_tcp_rcvbyte}, " + l7_data += f"server_tcp_rx_bytes={s_tcp_rcvbyte}; " else: total_sent = stats[port_0][u"opackets"] - total_rcvd = stats[port_1][u"ipackets"] + total_received = stats[port_1][u"ipackets"] print(f"packets lost from {port_0} --> {port_1}: {lost_a} pkts") if traffic_directions > 1: @@ -383,14 +374,17 @@ def simple_burst( client.clear_profile() client.disconnect() print( - f"trex_start_time={trex_start_time}, " - f"cps={mult!r}, total_received={total_rcvd}, " - f"total_sent={total_sent}, frame_loss={lost_a + lost_b}, " - f"approximated_duration={approximated_duration}, " - f"latency_stream_0(usec)={lat_a}, " - f"latency_stream_1(usec)={lat_b}, " - f"latency_hist_stream_0={lat_a_hist}, " - f"latency_hist_stream_1={lat_b_hist}, " + f"multiplier={multiplier!r}; " + f"total_received={total_received}; " + f"total_sent={total_sent}; " + f"frame_loss={lost_a + lost_b}; " + f"approximated_duration={approximated_duration}; " + f"latency_stream_0(usec)={lat_a}; " + f"latency_stream_1(usec)={lat_b}; " + f"latency_hist_stream_0={lat_a_hist}; " + f"latency_hist_stream_1={lat_b_hist}; " + f"client_sent={client_sent}; " + f"client_received={client_received}; " f"{l7_data}" ) @@ -408,21 +402,17 @@ def main(): ) parser.add_argument( u"-d", u"--duration", required=True, type=float, - help=u"Duration of traffic run." + help=u"Duration of the whole traffic run, including overheads." ) parser.add_argument( u"-s", u"--frame_size", required=True, help=u"Size of a Frame without padding and IPG." ) parser.add_argument( - u"-m", u"--mult", required=True, type=int, + u"-m", u"--multiplier", required=True, type=float, help=u"Multiplier of profile CPS." ) parser.add_argument( - u"-w", u"--warmup_time", type=float, default=5.0, - help=u"Traffic warm-up time in seconds, 0 = disable." - ) - parser.add_argument( u"--port_0", required=True, type=int, help=u"Port 0 on the traffic generator." ) @@ -451,10 +441,15 @@ def main(): framesize = args.frame_size simple_burst( - profile_file=args.profile, duration=args.duration, framesize=framesize, - mult=args.mult, warmup_time=args.warmup_time, port_0=args.port_0, - port_1=args.port_1, latency=args.latency, async_start=args.async_start, - traffic_directions=args.traffic_directions + profile_file=args.profile, + duration=args.duration, + framesize=framesize, + multiplier=args.multiplier, + port_0=args.port_0, + port_1=args.port_1, + latency=args.latency, + async_start=args.async_start, + traffic_directions=args.traffic_directions, ) diff --git a/GPL/tools/trex/trex_astf_stop.py b/GPL/tools/trex/trex_astf_stop.py index 655bdf1a97..d9784e661a 100644 --- a/GPL/tools/trex/trex_astf_stop.py +++ b/GPL/tools/trex/trex_astf_stop.py @@ -92,12 +92,15 @@ def main(): total_rcvd, total_sent = rx_0 + rx_1, tx_0 + tx_1 total_lost = total_sent - total_rcvd - # TODO: Add latency. print( - f"cps='unknown', total_received={total_rcvd}, total_sent={total_sent}, " - f"frame_loss={total_lost}, " - f"latency_stream_0(usec)=-1/-1/-1, latency_stream_1(usec)=-1/-1/-1, " - u"latency_hist_stream_0={}, latency_hist_stream_1={}, " + f"cps='unknown'; " + f"total_received={total_rcvd}; " + f"total_sent={total_sent}; " + f"frame_loss={total_lost}; " + f"latency_stream_0(usec)=-1/-1/-1; " + f"latency_stream_1(usec)=-1/-1/-1; " + f"latency_hist_stream_0={}; " + f"latency_hist_stream_1={}; " ) diff --git a/GPL/tools/trex/trex_stl_profile.py b/GPL/tools/trex/trex_stl_profile.py index ac09b8dda1..ea001b58b6 100644 --- a/GPL/tools/trex/trex_stl_profile.py +++ b/GPL/tools/trex/trex_stl_profile.py @@ -60,8 +60,17 @@ def fmt_latency(lat_min, lat_avg, lat_max, hdrh): def simple_burst( - profile_file, duration, framesize, rate, warmup_time, port_0, port_1, - latency, async_start=False, traffic_directions=2, force=False): + profile_file, + duration, + framesize, + rate, + port_0, + port_1, + latency, + async_start=False, + traffic_directions=2, + force=False, + ): """Send traffic and measure packet loss and latency. Procedure: @@ -83,7 +92,6 @@ def simple_burst( :param framesize: Frame size. :param duration: Duration of traffic run in seconds (-1=infinite). :param rate: Traffic rate [percentage, pps, bps]. - :param warmup_time: Traffic warm-up time in seconds, 0 = disable. :param port_0: Port 0 on the traffic generator. :param port_1: Port 1 on the traffic generator. :param latency: With latency stats. @@ -94,7 +102,6 @@ def simple_burst( :type framesize: int or str :type duration: float :type rate: str - :type warmup_time: float :type port_0: int :type port_1: int :type latency: bool @@ -105,8 +112,7 @@ def simple_burst( client = None total_rcvd = 0 total_sent = 0 - approximated_duration = 0 - approximated_rate = 0 + approximated_duration = 0.0 lost_a = 0 lost_b = 0 lat_a = u"-1/-1/-1/" @@ -162,40 +168,6 @@ def simple_burst( ports = [port_0] if traffic_directions > 1: ports.append(port_1) - # Warm-up phase: - if warmup_time > 0: - # Clear the stats before injecting: - client.clear_stats() - - # Choose rate and start traffic: - client.start( - ports=ports, mult=rate, duration=warmup_time, force=force, - core_mask=STLClient.CORE_MASK_PIN - ) - - # Block until done: - time_start = time.monotonic() - client.wait_on_traffic(ports=ports, timeout=warmup_time+30) - time_stop = time.monotonic() - approximated_duration = time_stop - time_start - - if client.get_warnings(): - for warning in client.get_warnings(): - print(warning) - - # Read the stats after the test: - stats = client.get_stats() - - print(u"##### Warmup statistics #####") - print(json.dumps(stats, indent=4, separators=(u",", u": "))) - - lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"] - if traffic_directions > 1: - lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"] - - print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts") - if traffic_directions > 1: - print(f"packets lost from {port_1} --> {port_0}: {lost_b} pkts") # Clear the stats before injecting: client.clear_stats() @@ -204,8 +176,11 @@ def simple_burst( # Choose rate and start traffic: client.start( - ports=ports, mult=rate, duration=duration, force=force, - core_mask=STLClient.CORE_MASK_PIN + ports=ports, + mult=rate, + duration=duration, + force=force, + core_mask=STLClient.CORE_MASK_PIN, ) if async_start: @@ -254,10 +229,6 @@ def simple_burst( else: total_sent = stats[port_0][u"opackets"] total_rcvd = stats[port_1][u"ipackets"] - try: - approximated_rate = total_sent / approximated_duration - except ZeroDivisionError: - pass print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts") if traffic_directions > 1: @@ -275,13 +246,14 @@ def simple_burst( if client: client.disconnect() print( - f"rate={rate!r}, total_received={total_rcvd}, " - f"total_sent={total_sent}, frame_loss={lost_a + lost_b}, " - f"target_duration={duration!r}, " - f"approximated_duration={approximated_duration!r}, " - f"approximated_rate={approximated_rate}, " - f"latency_stream_0(usec)={lat_a}, " - f"latency_stream_1(usec)={lat_b}, " + f"rate={rate!r}; " + f"total_received={total_rcvd}; " + f"total_sent={total_sent}; " + f"frame_loss={lost_a + lost_b}; " + f"target_duration={duration!r}; " + f"approximated_duration={approximated_duration!r}; " + f"latency_stream_0(usec)={lat_a}; " + f"latency_stream_1(usec)={lat_b}; " ) @@ -309,10 +281,6 @@ def main(): help=u"Traffic rate with included units (pps)." ) parser.add_argument( - u"-w", u"--warmup_time", type=float, default=5.0, - help=u"Traffic warm-up time in seconds, 0 = disable." - ) - parser.add_argument( u"--port_0", required=True, type=int, help=u"Port 0 on the traffic generator." ) @@ -345,10 +313,16 @@ def main(): framesize = args.frame_size simple_burst( - profile_file=args.profile, duration=args.duration, framesize=framesize, - rate=args.rate, warmup_time=args.warmup_time, port_0=args.port_0, - port_1=args.port_1, latency=args.latency, async_start=args.async_start, - traffic_directions=args.traffic_directions, force=args.force + profile_file=args.profile, + duration=args.duration, + framesize=framesize, + rate=args.rate, + port_0=args.port_0, + port_1=args.port_1, + latency=args.latency, + async_start=args.async_start, + traffic_directions=args.traffic_directions, + force=args.force, ) diff --git a/GPL/tools/trex/trex_stl_stop.py b/GPL/tools/trex/trex_stl_stop.py index dcdae7c10a..f07479da8a 100644 --- a/GPL/tools/trex/trex_stl_stop.py +++ b/GPL/tools/trex/trex_stl_stop.py @@ -91,13 +91,16 @@ def main(): total_rcvd, total_sent = rx_0 + rx_1, tx_0 + tx_1 total_lost = total_sent - total_rcvd - # TODO: Add latency. print( - f"rate='unknown', total_received={total_rcvd}, " - f"total_sent={total_sent}, frame_loss={total_lost}, " - f"target_duration='manual', approximated_duration='manual', " - f"approximated_rate='unknown', " - f"latency_stream_0(usec)=-1/-1/-1, latency_stream_1(usec)=-1/-1/-1" + f"rate='unknown'; " + f"total_received={total_rcvd}; " + f"total_sent={total_sent}; " + f"frame_loss={total_lost}; " + f"target_duration='manual'; " + f"approximated_duration='manual'; " + f"approximated_rate='unknown'; " + f"latency_stream_0(usec)=-1/-1/-1; " + f"latency_stream_1(usec)=-1/-1/-1; " ) diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h-pps.py new file mode 100644 index 0000000000..0c22573a09 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h-pps.py @@ -0,0 +1,117 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.3.255 + - Destination IP address range: 20.0.0.0 - 20.0.3.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.3.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.3.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + self.data_size = 11111 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + prog_c.connect() + prog_c.send(u"1" * self.data_size) + prog_c.recv(self.data_size) + + # server commands + prog_s = ASTFProgram() + prog_s.accept() + prog_c.recv(self.data_size) + prog_c.send(u"1" * self.data_size) + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=64512, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py index 809a954a30..a86355b365 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-1024h.py @@ -25,6 +25,9 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. """ from trex.astf.api import * @@ -49,9 +52,6 @@ class TrafficProfile(TrafficProfileBaseClass): # header length for TCP packet with 0B payload self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options - # Delay for keeping tcp sessions active - self.delay = 2000000 # delay 2s (2,000,000 usec) - def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -68,8 +68,6 @@ class TrafficProfile(TrafficProfileBaseClass): prog_c.connect() # receive syn-ack (0B sent in tcp syn-ack packet) and send ack prog_c.recv(0) - # wait defined time, then send fin-ack - prog_c.delay(self.delay) # server commands prog_s = ASTFProgram() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h-pps.py new file mode 100644 index 0000000000..c73de7b9c7 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h-pps.py @@ -0,0 +1,117 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.63.255 + - Destination IP address range: 20.0.0.0 - 20.0.63.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.63.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.63.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + self.data_size = 11111 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + prog_c.connect() + prog_c.send(u"1" * self.data_size) + prog_c.recv(self.data_size) + + # server commands + prog_s = ASTFProgram() + prog_s.accept() + prog_c.recv(self.data_size) + prog_c.send(u"1" * self.data_size) + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=1032192, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py index 0d7f9a5974..4899726fc2 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-16384h.py @@ -25,6 +25,9 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. """ from trex.astf.api import * @@ -49,9 +52,6 @@ class TrafficProfile(TrafficProfileBaseClass): # header length for TCP packet with 0B payload self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options - # Delay for keeping tcp sessions active - self.delay = 2000000 # delay 2s (2,000,000 usec) - def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -68,8 +68,6 @@ class TrafficProfile(TrafficProfileBaseClass): prog_c.connect() # receive syn-ack (0B sent in tcp syn-ack packet) and send ack prog_c.recv(0) - # wait defined time, then send fin-ack - prog_c.delay(self.delay) # server commands prog_s = ASTFProgram() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h-pps.py new file mode 100644 index 0000000000..007b3668ac --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h-pps.py @@ -0,0 +1,117 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 172.16.0.0 - 172.19.255.255 + - Destination IP address range: 20.16.0.0 - 20.19.255.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"172.16.0.0" + self.p1_src_end_ip = u"172.19.255.255" + self.p1_dst_start_ip = u"20.16.0.0" + self.p1_dst_end_ip = u"20.19.255.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + self.data_size = 11111 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + prog_c.connect() + prog_c.send(u"1" * self.data_size) + prog_c.recv(self.data_size) + + # server commands + prog_s = ASTFProgram() + prog_s.accept() + prog_c.recv(self.data_size) + prog_c.send(u"1" * self.data_size) + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=16515072, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py index 6f533844e0..d52d293c92 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-262144h.py @@ -25,6 +25,9 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. """ from trex.astf.api import * @@ -49,9 +52,6 @@ class TrafficProfile(TrafficProfileBaseClass): # header length for TCP packet with 0B payload self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options - # Delay for keeping tcp sessions active - self.delay = 2000000 # delay 2s (2,000,000 usec) - def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -68,8 +68,6 @@ class TrafficProfile(TrafficProfileBaseClass): prog_c.connect() # receive syn-ack (0B sent in tcp syn-ack packet) and send ack prog_c.recv(0) - # wait defined time, then send fin-ack - prog_c.delay(self.delay) # server commands prog_s = ASTFProgram() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h-pps.py new file mode 100644 index 0000000000..dc2b612057 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h-pps.py @@ -0,0 +1,117 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.15.255 + - Destination IP address range: 20.0.0.0 - 20.0.15.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.15.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.15.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + self.data_size = 11111 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + prog_c.connect() + prog_c.send(u"1" * self.data_size) + prog_c.recv(self.data_size) + + # server commands + prog_s = ASTFProgram() + prog_s.accept() + prog_c.recv(self.data_size) + prog_c.send(u"1" * self.data_size) + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=258048, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py index acfc5e109a..4ff89a8acb 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-4096h.py @@ -25,6 +25,9 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. """ from trex.astf.api import * @@ -49,9 +52,6 @@ class TrafficProfile(TrafficProfileBaseClass): # header length for TCP packet with 0B payload self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options - # Delay for keeping tcp sessions active - self.delay = 2000000 # delay 2s (2,000,000 usec) - def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -68,8 +68,6 @@ class TrafficProfile(TrafficProfileBaseClass): prog_c.connect() # receive syn-ack (0B sent in tcp syn-ack packet) and send ack prog_c.recv(0) - # wait defined time, then send fin-ack - prog_c.delay(self.delay) # server commands prog_s = ASTFProgram() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h-pps.py new file mode 100644 index 0000000000..8ba3be5b69 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h-pps.py @@ -0,0 +1,117 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. + +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / TCP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.255.255 + - Destination IP address range: 20.0.0.0 - 20.0.255.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.255.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.255.255" + + # Headers length; not used in this profile, just for the record of + # header length for TCP packet with 0B payload + self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options + self.data_size = 11111 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates, None + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + # client commands + prog_c = ASTFProgram() + prog_c.connect() + prog_c.send(u"1" * self.data_size) + prog_c.recv(self.data_size) + + # server commands + prog_s = ASTFProgram() + prog_s.accept() + prog_c.recv(self.data_size) + prog_c.send(u"1" * self.data_size) + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=4128768, # TODO: set via input parameter + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py index 7d2f5b6265..e5786f4f05 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4tcp-65536h.py @@ -25,6 +25,9 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up and tears down TCP session. +No delays, no data transfer. """ from trex.astf.api import * @@ -49,9 +52,6 @@ class TrafficProfile(TrafficProfileBaseClass): # header length for TCP packet with 0B payload self.headers_size = 58 # 14B l2 + 20B ipv4 + 24B tcp incl. 4B options - # Delay for keeping tcp sessions active - self.delay = 2000000 # delay 2s (2,000,000 usec) - def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -68,8 +68,6 @@ class TrafficProfile(TrafficProfileBaseClass): prog_c.connect() # receive syn-ack (0B sent in tcp syn-ack packet) and send ack prog_c.recv(0) - # wait defined time, then send fin-ack - prog_c.delay(self.delay) # server commands prog_s = ASTFProgram() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h-pps.py new file mode 100644 index 0000000000..3de855442e --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h-pps.py @@ -0,0 +1,140 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / UDP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.3.255 + - Destination IP address range: 20.0.0.0 - 20.0.3.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self, **kwargs): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.3.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.3.255" + + self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B UDP + + self.udp_data = u"" + + self.n_data = 32 # TODO: set via input parameter + self.m_delay = 1200000 # delay 1200s (1,200,000 ms) + self.u_delay = 1000 * self.m_delay # delay 1200s (1,200,000,000 us) + self.limit = 64512 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + if self.framesize == 64: + self.udp_data += self._gen_padding(self.headers_size, 72) + if self.framesize == 1518: + self.udp_data += self._gen_padding(self.headers_size, 1514) + + # Client program. + prog_c = ASTFProgram(stream=False) + prog_c.set_keepalive_msg(self.m_delay) + prog_c.send_msg(self.udp_data) + # No delay, PPS tests combine connect and data send (no data receive). + prog_c.set_var(u"var1", self.n_data) + prog_c.set_label(u"a:") + prog_c.send_msg(self.udp_data) + prog_c.jmp_nz(u"var1", u"a:") + # We should read the server response, + # but no reason to overload client workers even more. + + # Server program. + prog_s = ASTFProgram(stream=False) + prog_s.set_keepalive_msg(self.m_delay) + # If server closes too soon, new instances are started + # leading in too much replies. To prevent that, we need to recv all. + prog_s.recv_msg(1 + self.n_data) + # In packet loss scenarios, some instances never get here. + # This maybe increases server traffic duration, + # but no other way if we want to avoid + # TRex creating a second instance of the same server. + prog_s.send_msg(self.udp_data) + prog_s.set_var(u"var2", self.n_data) + prog_s.set_label(u"b:") + prog_s.send_msg(self.udp_data) + prog_s.jmp_nz(u"var2", u"b:") + # VPP never duplicates packets, + # so it is safe to close the server instance now. + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=self.limit, + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py index 6bf0d53d1f..ebcf17e59e 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-1024h.py @@ -25,6 +25,10 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up UDP session. +No delays, no data transfer. +Keepalive mechanism cannot be disabled, so it is at least set to long waits. """ from trex.astf.api import * @@ -53,8 +57,7 @@ class TrafficProfile(TrafficProfileBaseClass): # Headers length self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B udp - # Required UDP keepalive value for T-Rex - self.udp_keepalive = 2000 # 2s (2,000 msec) + # No need to set keepalive, both programs end just after start&send. def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -70,27 +73,18 @@ class TrafficProfile(TrafficProfileBaseClass): # client commands prog_c = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) # send REQ message prog_c.send_msg(self.udp_req) - # receive RES message - prog_c.recv_msg(1) - - prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # No need to process the response, seeing L2 counter is enough. + # Client program can end here. # server commands prog_s = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) - # receive REQ message - prog_s.recv_msg(1) + # When server instance is created means REQ is visible in L2 counter. + # No need to receive explicitly? # send RES message prog_s.send_msg(self.udp_res) - - prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # Server program can end here. # ip generators ip_gen_c = ASTFIPGenDist( diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h-pps.py new file mode 100644 index 0000000000..856f5b28a3 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h-pps.py @@ -0,0 +1,140 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / UDP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.63.255 + - Destination IP address range: 20.0.0.0 - 20.0.63.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self, **kwargs): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.63.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.63.255" + + self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B UDP + + self.udp_data = u"" + + self.n_data = 32 # TODO: set via input parameter + self.m_delay = 1200000 # delay 1200s (1,200,000 ms) + self.u_delay = 1000 * self.m_delay # delay 1200s (1,200,000,000 us) + self.limit = 1032192 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + if self.framesize == 64: + self.udp_data += self._gen_padding(self.headers_size, 72) + if self.framesize == 1518: + self.udp_data += self._gen_padding(self.headers_size, 1514) + + # Client program. + prog_c = ASTFProgram(stream=False) + prog_c.set_keepalive_msg(self.m_delay) + prog_c.send_msg(self.udp_data) + # No delay, PPS tests combine connect and data send (no data receive). + prog_c.set_var(u"var1", self.n_data) + prog_c.set_label(u"a:") + prog_c.send_msg(self.udp_data) + prog_c.jmp_nz(u"var1", u"a:") + # We should read the server response, + # but no reason to overload client workers even more. + + # Server program. + prog_s = ASTFProgram(stream=False) + prog_s.set_keepalive_msg(self.m_delay) + # If server closes too soon, new instances are started + # leading in too much replies. To prevent that, we need to recv all. + prog_s.recv_msg(1 + self.n_data) + # In packet loss scenarios, some instances never get here. + # This maybe increases server traffic duration, + # but no other way if we want to avoid + # TRex creating a second instance of the same server. + prog_s.send_msg(self.udp_data) + prog_s.set_var(u"var2", self.n_data) + prog_s.set_label(u"b:") + prog_s.send_msg(self.udp_data) + prog_s.jmp_nz(u"var2", u"b:") + # VPP never duplicates packets, + # so it is safe to close the server instance now. + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=self.limit, + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py index 9237831aa5..3f13cbdda3 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-16384h.py @@ -25,6 +25,10 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up UDP session. +No delays, no data transfer. +Keepalive mechanism cannot be disabled, so it is at least set to long waits. """ from trex.astf.api import * @@ -53,8 +57,7 @@ class TrafficProfile(TrafficProfileBaseClass): # Headers length self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B udp - # Required UDP keepalive value for T-Rex - self.udp_keepalive = 2000 # 2s (2,000 msec) + # No need to set keepalive, both programs end just after start&send. def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -70,27 +73,18 @@ class TrafficProfile(TrafficProfileBaseClass): # client commands prog_c = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) # send REQ message prog_c.send_msg(self.udp_req) - # receive RES message - prog_c.recv_msg(1) - - prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # No need to process the response, seeing L2 counter is enough. + # Client program can end here. # server commands prog_s = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) - # receive REQ message - prog_s.recv_msg(1) + # When server instance is created means REQ is visible in L2 counter. + # No need to receive explicitly? # send RES message prog_s.send_msg(self.udp_res) - - prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # Server program can end here. # ip generators ip_gen_c = ASTFIPGenDist( diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h-pps.py new file mode 100644 index 0000000000..f6f7fcfe3d --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h-pps.py @@ -0,0 +1,140 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / UDP + - Direction 0 --> 1: + - Source IP address range: 172.16.0.0 - 172.19.255.255 + - Destination IP address range: 20.16.0.0 - 20.19.255.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self, **kwargs): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"172.16.0.0" + self.p1_src_end_ip = u"172.19.255.255" + self.p1_dst_start_ip = u"20.16.0.0" + self.p1_dst_end_ip = u"20.19.255.255" + + self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B UDP + + self.udp_data = u"" + + self.n_data = 32 # TODO: set via input parameter + self.m_delay = 1200000 # delay 1200s (1,200,000 ms) + self.u_delay = 1000 * self.m_delay # delay 1200s (1,200,000,000 us) + self.limit = 16515072 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + if self.framesize == 64: + self.udp_data += self._gen_padding(self.headers_size, 72) + if self.framesize == 1518: + self.udp_data += self._gen_padding(self.headers_size, 1514) + + # Client program. + prog_c = ASTFProgram(stream=False) + prog_c.set_keepalive_msg(self.m_delay) + prog_c.send_msg(self.udp_data) + # No delay, PPS tests combine connect and data send (no data receive). + prog_c.set_var(u"var1", self.n_data) + prog_c.set_label(u"a:") + prog_c.send_msg(self.udp_data) + prog_c.jmp_nz(u"var1", u"a:") + # We should read the server response, + # but no reason to overload client workers even more. + + # Server program. + prog_s = ASTFProgram(stream=False) + prog_s.set_keepalive_msg(self.m_delay) + # If server closes too soon, new instances are started + # leading in too much replies. To prevent that, we need to recv all. + prog_s.recv_msg(1 + self.n_data) + # In packet loss scenarios, some instances never get here. + # This maybe increases server traffic duration, + # but no other way if we want to avoid + # TRex creating a second instance of the same server. + prog_s.send_msg(self.udp_data) + prog_s.set_var(u"var2", self.n_data) + prog_s.set_label(u"b:") + prog_s.send_msg(self.udp_data) + prog_s.jmp_nz(u"var2", u"b:") + # VPP never duplicates packets, + # so it is safe to close the server instance now. + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=self.limit, + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py index 728eba8a04..8149a27cb9 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-262144h.py @@ -25,6 +25,10 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up UDP session. +No delays, no data transfer. +Keepalive mechanism cannot be disabled, so it is at least set to long waits. """ from trex.astf.api import * @@ -53,8 +57,7 @@ class TrafficProfile(TrafficProfileBaseClass): # Headers length self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B udp - # Required UDP keepalive value for T-Rex - self.udp_keepalive = 2000 # 2s (2,000 msec) + # No need to set keepalive, both programs end just after start&send. def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -70,27 +73,18 @@ class TrafficProfile(TrafficProfileBaseClass): # client commands prog_c = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) # send REQ message prog_c.send_msg(self.udp_req) - # receive RES message - prog_c.recv_msg(1) - - prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # No need to process the response, seeing L2 counter is enough. + # Client program can end here. # server commands prog_s = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) - # receive REQ message - prog_s.recv_msg(1) + # When server instance is created means REQ is visible in L2 counter. + # No need to receive explicitly? # send RES message prog_s.send_msg(self.udp_res) - - prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # Server program can end here. # ip generators ip_gen_c = ASTFIPGenDist( diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h-pps.py new file mode 100644 index 0000000000..cd295b1164 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h-pps.py @@ -0,0 +1,140 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / UDP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.15.255 + - Destination IP address range: 20.0.0.0 - 20.0.15.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self, **kwargs): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.15.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.15.255" + + self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B UDP + + self.udp_data = u"" + + self.n_data = 32 # TODO: set via input parameter + self.m_delay = 1200000 # delay 1200s (1,200,000 ms) + self.u_delay = 1000 * self.m_delay # delay 1200s (1,200,000,000 us) + self.limit = 258048 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + if self.framesize == 64: + self.udp_data += self._gen_padding(self.headers_size, 72) + if self.framesize == 1518: + self.udp_data += self._gen_padding(self.headers_size, 1514) + + # Client program. + prog_c = ASTFProgram(stream=False) + prog_c.set_keepalive_msg(self.m_delay) + prog_c.send_msg(self.udp_data) + # No delay, PPS tests combine connect and data send (no data receive). + prog_c.set_var(u"var1", self.n_data) + prog_c.set_label(u"a:") + prog_c.send_msg(self.udp_data) + prog_c.jmp_nz(u"var1", u"a:") + # We should read the server response, + # but no reason to overload client workers even more. + + # Server program. + prog_s = ASTFProgram(stream=False) + prog_s.set_keepalive_msg(self.m_delay) + # If server closes too soon, new instances are started + # leading in too much replies. To prevent that, we need to recv all. + prog_s.recv_msg(1 + self.n_data) + # In packet loss scenarios, some instances never get here. + # This maybe increases server traffic duration, + # but no other way if we want to avoid + # TRex creating a second instance of the same server. + prog_s.send_msg(self.udp_data) + prog_s.set_var(u"var2", self.n_data) + prog_s.set_label(u"b:") + prog_s.send_msg(self.udp_data) + prog_s.jmp_nz(u"var2", u"b:") + # VPP never duplicates packets, + # so it is safe to close the server instance now. + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=self.limit, + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py index 0807175d36..cd81cb96ee 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-4096h.py @@ -25,6 +25,10 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up UDP session. +No delays, no data transfer. +Keepalive mechanism cannot be disabled, so it is at least set to long waits. """ from trex.astf.api import * @@ -53,8 +57,7 @@ class TrafficProfile(TrafficProfileBaseClass): # Headers length self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B udp - # Required UDP keepalive value for T-Rex - self.udp_keepalive = 2000 # 2s (2,000 msec) + # No need to set keepalive, both programs end just after start&send. def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -70,27 +73,18 @@ class TrafficProfile(TrafficProfileBaseClass): # client commands prog_c = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) # send REQ message prog_c.send_msg(self.udp_req) - # receive RES message - prog_c.recv_msg(1) - - prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # No need to process the response, seeing L2 counter is enough. + # Client program can end here. # server commands prog_s = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) - # receive REQ message - prog_s.recv_msg(1) + # When server instance is created means REQ is visible in L2 counter. + # No need to receive explicitly? # send RES message prog_s.send_msg(self.udp_res) - - prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # Server program can end here. # ip generators ip_gen_c = ASTFIPGenDist( diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h-pps.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h-pps.py new file mode 100644 index 0000000000..f6aaebcf30 --- /dev/null +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h-pps.py @@ -0,0 +1,140 @@ +# Copyright (c) 2020 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Traffic profile for T-rex advanced stateful (astf) traffic generator. +Traffic profile: + - Two streams sent in directions 0 --> 1 (client -> server, requests) and + 1 --> 0 (server -> client, responses) at the same time. + - Packet: ETH / IP / UDP + - Direction 0 --> 1: + - Source IP address range: 192.168.0.0 - 192.168.255.255 + - Destination IP address range: 20.0.0.0 - 20.0.255.255 + - Direction 1 --> 0: + - Source IP address range: destination IP address from packet received + on port 1 + - Destination IP address range: source IP address from packet received + on port 1 +""" + +from trex.astf.api import * +from profile_trex_astf_base_class import TrafficProfileBaseClass + + +class TrafficProfile(TrafficProfileBaseClass): + """Traffic profile.""" + + def __init__(self, **kwargs): + """Initialization and setting of profile parameters.""" + + super(TrafficProfileBaseClass, self).__init__() + + # IPs used in packet headers. + self.p1_src_start_ip = u"192.168.0.0" + self.p1_src_end_ip = u"192.168.255.255" + self.p1_dst_start_ip = u"20.0.0.0" + self.p1_dst_end_ip = u"20.0.255.255" + + self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B UDP + + self.udp_data = u"" + + self.n_data = 32 # TODO: set via input parameter + self.m_delay = 1200000 # delay 1200s (1,200,000 ms) + self.u_delay = 1000 * self.m_delay # delay 1200s (1,200,000,000 us) + self.limit = 4128768 + + def define_profile(self): + """Define profile to be used by advanced stateful traffic generator. + + This method MUST return: + + return ip_gen, templates + + :returns: IP generator and profile templates for ASTFProfile(). + :rtype: tuple + """ + if self.framesize == 64: + self.udp_data += self._gen_padding(self.headers_size, 72) + if self.framesize == 1518: + self.udp_data += self._gen_padding(self.headers_size, 1514) + + # Client program. + prog_c = ASTFProgram(stream=False) + prog_c.set_keepalive_msg(self.m_delay) + prog_c.send_msg(self.udp_data) + # No delay, PPS tests combine connect and data send (no data receive). + prog_c.set_var(u"var1", self.n_data) + prog_c.set_label(u"a:") + prog_c.send_msg(self.udp_data) + prog_c.jmp_nz(u"var1", u"a:") + # We should read the server response, + # but no reason to overload client workers even more. + + # Server program. + prog_s = ASTFProgram(stream=False) + prog_s.set_keepalive_msg(self.m_delay) + # If server closes too soon, new instances are started + # leading in too much replies. To prevent that, we need to recv all. + prog_s.recv_msg(1 + self.n_data) + # In packet loss scenarios, some instances never get here. + # This maybe increases server traffic duration, + # but no other way if we want to avoid + # TRex creating a second instance of the same server. + prog_s.send_msg(self.udp_data) + prog_s.set_var(u"var2", self.n_data) + prog_s.set_label(u"b:") + prog_s.send_msg(self.udp_data) + prog_s.jmp_nz(u"var2", u"b:") + # VPP never duplicates packets, + # so it is safe to close the server instance now. + + # ip generators + ip_gen_c = ASTFIPGenDist( + ip_range=[self.p1_src_start_ip, self.p1_src_end_ip], + distribution=u"seq" + ) + ip_gen_s = ASTFIPGenDist( + ip_range=[self.p1_dst_start_ip, self.p1_dst_end_ip], + distribution=u"seq" + ) + ip_gen = ASTFIPGen( + glob=ASTFIPGenGlobal(ip_offset=u"0.0.0.1"), + dist_client=ip_gen_c, + dist_server=ip_gen_s + ) + + # server association + s_assoc = ASTFAssociation(rules=ASTFAssociationRule(port=8080)) + + # template + temp_c = ASTFTCPClientTemplate( + program=prog_c, + ip_gen=ip_gen, + limit=self.limit, + port=8080 + ) + temp_s = ASTFTCPServerTemplate(program=prog_s, assoc=s_assoc) + template = ASTFTemplate(client_template=temp_c, server_template=temp_s) + + return ip_gen, template, None + + +def register(): + """Register this traffic profile to T-Rex. + + Do not change this function. + + :return: Traffic Profiles. + :rtype: Object + """ + return TrafficProfile() diff --git a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py index 85eaff005c..56215ddece 100644 --- a/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py +++ b/GPL/traffic_profiles/trex/trex-astf-ethip4udp-65536h.py @@ -25,6 +25,10 @@ Traffic profile: on port 1 - Destination IP address range: source IP address from packet received on port 1 + +This is a profile for CPS tests, it only sets up UDP session. +No delays, no data transfer. +Keepalive mechanism cannot be disabled, so it is at least set to long waits. """ from trex.astf.api import * @@ -53,8 +57,7 @@ class TrafficProfile(TrafficProfileBaseClass): # Headers length self.headers_size = 42 # 14B l2 + 20B ipv4 + 8B udp - # Required UDP keepalive value for T-Rex - self.udp_keepalive = 2000 # 2s (2,000 msec) + # No need to set keepalive, both programs end just after start&send. def define_profile(self): """Define profile to be used by advanced stateful traffic generator. @@ -70,27 +73,18 @@ class TrafficProfile(TrafficProfileBaseClass): # client commands prog_c = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) # send REQ message prog_c.send_msg(self.udp_req) - # receive RES message - prog_c.recv_msg(1) - - prog_c.delay(self.udp_keepalive * 1000) # delay is defined in usec + # No need to process the response, seeing L2 counter is enough. + # Client program can end here. # server commands prog_s = ASTFProgram(stream=False) - # set the keepalive timer for UDP flows to not close udp session - # immediately after packet exchange - prog_c.set_keepalive_msg(self.udp_keepalive) - # receive REQ message - prog_s.recv_msg(1) + # When server instance is created means REQ is visible in L2 counter. + # No need to receive explicitly? # send RES message prog_s.send_msg(self.udp_res) - - prog_s.delay(self.udp_keepalive * 1000) # delay is defined in usec + # Server program can end here. # ip generators ip_gen_c = ASTFIPGenDist( |