GPL/tools/trex/trex_stateless_profile.py

   1 #!/usr/bin/python3
   2
   3 # Copyright (c) 2020 Cisco and/or its affiliates.
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 """This module gets a traffic profile together with other parameters, reads
  17 the profile and sends the traffic. At the end, it measures the packet loss and
  18 latency.
  19 """
  20
  21 import argparse
  22 import json
  23 import sys
  24 import time
  25
  26 sys.path.insert(
  27     0, u"/opt/trex-core-2.73/scripts/automation/trex_control_plane/interactive/"
  28 )
  29 from trex.stl.api import *
  30
  31
  32 def fmt_latency(lat_min, lat_avg, lat_max, hdrh):
  33     """Return formatted, rounded latency.
  34
  35     :param lat_min: Min latency
  36     :param lat_avg: Average latency
  37     :param lat_max: Max latency
  38     :param hdrh: Base64 encoded compressed HDRHistogram object.
  39     :type lat_min: str
  40     :type lat_avg: str
  41     :type lat_max: str
  42     :type hdrh: str
  43     :return: Formatted and rounded output (hdrh unchanged) "min/avg/max/hdrh".
  44     :rtype: str
  45     """
  46     try:
  47         t_min = int(round(float(lat_min)))
  48     except ValueError:
  49         t_min = int(-1)
  50     try:
  51         t_avg = int(round(float(lat_avg)))
  52     except ValueError:
  53         t_avg = int(-1)
  54     try:
  55         t_max = int(round(float(lat_max)))
  56     except ValueError:
  57         t_max = int(-1)
  58
  59     return u"/".join(str(tmp) for tmp in (t_min, t_avg, t_max, hdrh))
  60
  61
  62 def simple_burst(
  63         profile_file, duration, framesize, rate, warmup_time, port_0, port_1,
  64         latency, async_start=False, traffic_directions=2, force=False):
  65     """Send traffic and measure packet loss and latency.
  66
  67     Procedure:
  68      - reads the given traffic profile with streams,
  69      - connects to the T-rex client,
  70      - resets the ports,
  71      - removes all existing streams,
  72      - adds streams from the traffic profile to the ports,
  73      - if the warm-up time is more than 0, sends the warm-up traffic, reads the
  74        statistics,
  75      - clears the statistics from the client,
  76      - starts the traffic,
  77      - waits for the defined time (or runs forever if async mode is defined),
  78      - stops the traffic,
  79      - reads and displays the statistics and
  80      - disconnects from the client.
  81
  82     :param profile_file: A python module with T-rex traffic profile.
  83     :param framesize: Frame size.
  84     :param duration: Duration of traffic run in seconds (-1=infinite).
  85     :param rate: Traffic rate [percentage, pps, bps].
  86     :param warmup_time: Traffic warm-up time in seconds, 0 = disable.
  87     :param port_0: Port 0 on the traffic generator.
  88     :param port_1: Port 1 on the traffic generator.
  89     :param latency: With latency stats.
  90     :param async_start: Start the traffic and exit.
  91     :param traffic_directions: Bidirectional (2) or unidirectional (1) traffic.
  92     :param force: Force start regardless of ports state.
  93     :type profile_file: str
  94     :type framesize: int or str
  95     :type duration: float
  96     :type rate: str
  97     :type warmup_time: float
  98     :type port_0: int
  99     :type port_1: int
 100     :type latency: bool
 101     :type async_start: bool
 102     :type traffic_directions: int
 103     :type force: bool
 104     """
 105     client = None
 106     total_rcvd = 0
 107     total_sent = 0
 108     approximated_duration = 0
 109     approximated_rate = 0
 110     lost_a = 0
 111     lost_b = 0
 112     lat_a = u"-1/-1/-1/"
 113     lat_b = u"-1/-1/-1/"
 114
 115     # Read the profile:
 116     try:
 117         print(f"### Profile file:\n{profile_file}")
 118         profile = STLProfile.load(
 119             profile_file, direction=0, port_id=0, framesize=framesize,
 120             rate=rate
 121         )
 122         streams = profile.get_streams()
 123     except STLError as err:
 124         print(f"Error while loading profile '{profile_file}' {err!r}")
 125         sys.exit(1)
 126
 127     try:
 128         # Create the client:
 129         client = STLClient()
 130         # Connect to server:
 131         client.connect()
 132         # Prepare our ports (the machine has 0 <--> 1 with static route):
 133         client.reset(ports=[port_0, port_1])
 134         client.remove_all_streams(ports=[port_0, port_1])
 135
 136         if u"macsrc" in profile_file:
 137             client.set_port_attr(ports=[port_0, port_1], promiscuous=True)
 138         if isinstance(framesize, int):
 139             last_stream_a = int((len(streams) - 2 ) / 2)
 140             last_stream_b = (last_stream_a * 2)
 141             client.add_streams(streams[0:last_stream_a], ports=[port_0])
 142             if traffic_directions > 1:
 143                 client.add_streams(
 144                     streams[last_stream_a:last_stream_b], ports=[port_1])
 145         elif isinstance(framesize, str):
 146             client.add_streams(streams[0:3], ports=[port_0])
 147             if traffic_directions > 1:
 148                 client.add_streams(streams[3:6], ports=[port_1])
 149         if latency:
 150             try:
 151                 if isinstance(framesize, int):
 152                     client.add_streams(streams[last_stream_b], ports=[port_0])
 153                     if traffic_directions > 1:
 154                         client.add_streams(
 155                             streams[last_stream_b + 1], ports=[port_1])
 156                 elif isinstance(framesize, str):
 157                     latency = False
 158             except STLError:
 159                 # Disable latency if NIC does not support requested stream type
 160                 print(u"##### FAILED to add latency streams #####")
 161                 latency = False
 162         ports = [port_0]
 163         if traffic_directions > 1:
 164             ports.append(port_1)
 165         # Warm-up phase:
 166         if warmup_time > 0:
 167             # Clear the stats before injecting:
 168             client.clear_stats()
 169
 170             # Choose rate and start traffic:
 171             client.start(ports=ports, mult=rate, duration=warmup_time,
 172                          force=force)
 173
 174             # Block until done:
 175             time_start = time.monotonic()
 176             client.wait_on_traffic(ports=ports, timeout=warmup_time+30)
 177             time_stop = time.monotonic()
 178             approximated_duration = time_stop - time_start
 179
 180             if client.get_warnings():
 181                 for warning in client.get_warnings():
 182                     print(warning)
 183
 184             # Read the stats after the test:
 185             stats = client.get_stats()
 186
 187             print(u"##### Warmup statistics #####")
 188             print(json.dumps(stats, indent=4, separators=(u",", u": ")))
 189
 190             lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"]
 191             if traffic_directions > 1:
 192                 lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"]
 193
 194             print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts")
 195             if traffic_directions > 1:
 196                 print(f"packets lost from {port_1} --> {port_0}: {lost_b} pkts")
 197
 198         # Clear the stats before injecting:
 199         client.clear_stats()
 200         lost_a = 0
 201         lost_b = 0
 202
 203         # Choose rate and start traffic:
 204         client.start(ports=ports, mult=rate, duration=duration, force=force)
 205
 206         if async_start:
 207             # For async stop, we need to export the current snapshot.
 208             xsnap0 = client.ports[0].get_xstats().reference_stats
 209             print(f"Xstats snapshot 0: {xsnap0!r}")
 210             if traffic_directions > 1:
 211                 xsnap1 = client.ports[1].get_xstats().reference_stats
 212                 print(f"Xstats snapshot 1: {xsnap1!r}")
 213         else:
 214             # Block until done:
 215             time_start = time.monotonic()
 216             client.wait_on_traffic(ports=ports, timeout=duration+30)
 217             time_stop = time.monotonic()
 218             approximated_duration = time_stop - time_start
 219
 220             if client.get_warnings():
 221                 for warning in client.get_warnings():
 222                     print(warning)
 223
 224             # Read the stats after the test
 225             stats = client.get_stats()
 226
 227             print(u"##### Statistics #####")
 228             print(json.dumps(stats, indent=4, separators=(u",", u": ")))
 229
 230             lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"]
 231             if traffic_directions > 1:
 232                 lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"]
 233
 234             # Stats index is not a port number, but "pgid".
 235             if latency:
 236                 lat_obj = stats[u"latency"][0][u"latency"]
 237                 lat_a = fmt_latency(
 238                     str(lat_obj[u"total_min"]), str(lat_obj[u"average"]),
 239                     str(lat_obj[u"total_max"]), str(lat_obj[u"hdrh"]))
 240                 if traffic_directions > 1:
 241                     lat_obj = stats[u"latency"][1][u"latency"]
 242                     lat_b = fmt_latency(
 243                         str(lat_obj[u"total_min"]), str(lat_obj[u"average"]),
 244                         str(lat_obj[u"total_max"]), str(lat_obj[u"hdrh"]))
 245
 246             if traffic_directions > 1:
 247                 total_sent = stats[0][u"opackets"] + stats[1][u"opackets"]
 248                 total_rcvd = stats[0][u"ipackets"] + stats[1][u"ipackets"]
 249             else:
 250                 total_sent = stats[port_0][u"opackets"]
 251                 total_rcvd = stats[port_1][u"ipackets"]
 252             try:
 253                 approximated_rate = total_sent / approximated_duration
 254             except ZeroDivisionError:
 255                 pass
 256
 257             print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts")
 258             if traffic_directions > 1:
 259                 print(f"packets lost from {port_1} --> {port_0}: {lost_b} pkts")
 260
 261     except STLError as ex_error:
 262         print(ex_error, file=sys.stderr)
 263         sys.exit(1)
 264
 265     finally:
 266         if async_start:
 267             if client:
 268                 client.disconnect(stop_traffic=False, release_ports=True)
 269         else:
 270             if client:
 271                 client.disconnect()
 272             print(
 273                 f"rate={rate!r}, totalReceived={total_rcvd}, "
 274                 f"totalSent={total_sent}, frameLoss={lost_a + lost_b}, "
 275                 f"targetDuration={duration!r}, "
 276                 f"approximatedDuration={approximated_duration!r}, "
 277                 f"approximatedRate={approximated_rate}, "
 278                 f"latencyStream0(usec)={lat_a}, latencyStream1(usec)={lat_b}, "
 279             )
 280
 281
 282 def main():
 283     """Main function for the traffic generator using T-rex.
 284
 285     It verifies the given command line arguments and runs "simple_burst"
 286     function.
 287     """
 288     parser = argparse.ArgumentParser()
 289     parser.add_argument(
 290         u"-p", u"--profile", required=True, type=str,
 291         help=u"Python traffic profile."
 292     )
 293     parser.add_argument(
 294         u"-d", u"--duration", required=True, type=float,
 295         help=u"Duration of traffic run."
 296     )
 297     parser.add_argument(
 298         u"-s", u"--frame_size", required=True,
 299         help=u"Size of a Frame without padding and IPG."
 300     )
 301     parser.add_argument(
 302         u"-r", u"--rate", required=True,
 303         help=u"Traffic rate with included units (%, pps)."
 304     )
 305     parser.add_argument(
 306         u"-w", u"--warmup_time", type=float, default=5.0,
 307         help=u"Traffic warm-up time in seconds, 0 = disable."
 308     )
 309     parser.add_argument(
 310         u"--port_0", required=True, type=int,
 311         help=u"Port 0 on the traffic generator."
 312     )
 313     parser.add_argument(
 314         u"--port_1", required=True, type=int,
 315         help=u"Port 1 on the traffic generator."
 316     )
 317     parser.add_argument(
 318         u"--async_start", action=u"store_true", default=False,
 319         help=u"Non-blocking call of the script."
 320     )
 321     parser.add_argument(
 322         u"--latency", action=u"store_true", default=False,
 323         help=u"Add latency stream."
 324     )
 325     parser.add_argument(
 326         u"--traffic_directions", type=int, default=2,
 327         help=u"Send bi- (2) or uni- (1) directional traffic."
 328     )
 329     parser.add_argument(
 330         u"--force", action=u"store_true", default=False,
 331         help=u"Force start regardless of ports state."
 332     )
 333
 334     args = parser.parse_args()
 335
 336     try:
 337         framesize = int(args.frame_size)
 338     except ValueError:
 339         framesize = args.frame_size
 340
 341     simple_burst(
 342         profile_file=args.profile, duration=args.duration, framesize=framesize,
 343         rate=args.rate, warmup_time=args.warmup_time, port_0=args.port_0,
 344         port_1=args.port_1, latency=args.latency, async_start=args.async_start,
 345         traffic_directions=args.traffic_directions, force=args.force
 346     )
 347
 348
 349 if __name__ == u"__main__":
 350     main()