diff options
65 files changed, 36898 insertions, 3625 deletions
@@ -1,4 +1,5 @@ -v1.80 +v1.82 + diff --git a/linux/ws_main.py b/linux/ws_main.py index 617bcf37..b0499842 100755 --- a/linux/ws_main.py +++ b/linux/ws_main.py @@ -118,6 +118,7 @@ main_src = SrcGroup(dir='src', 'utl_cpuu.cpp', 'msg_manager.cpp', 'publisher/trex_publisher.cpp', + 'latency.cpp', 'pal/linux/pal_utl.cpp', 'pal/linux/mbuf.cpp' diff --git a/linux_dpdk/ws_main.py b/linux_dpdk/ws_main.py index 89f41376..e5ac40fb 100755 --- a/linux_dpdk/ws_main.py +++ b/linux_dpdk/ws_main.py @@ -12,6 +12,7 @@ import shutil; import copy; import re import uuid +import subprocess # these variables are mandatory ('/' are converted automatically) @@ -95,6 +96,7 @@ main_src = SrcGroup(dir='src', 'global_io_mode.cpp', 'main_dpdk.cpp', 'bp_sim.cpp', + 'latency.cpp', 'platform_cfg.cpp', 'tuple_gen.cpp', 'rx_check.cpp', @@ -701,6 +703,15 @@ def get_build_num (): return s; def create_version_files (): + git_sha="N/A" + try: + r=commands.getstatusoutput("git log --pretty=format:'%H' -n 1") + if r[0]==0: + git_sha=r[1] + except : + pass; + + s ='' s +="#ifndef __TREX_VER_FILE__ \n" s +="#define __TREX_VER_FILE__ \n" @@ -711,6 +722,7 @@ def create_version_files (): s +='extern const char * get_build_date(void); \n' s +='extern const char * get_build_time(void); \n' s +='#define VERSION_UIID "%s" \n' % uuid.uuid1() + s +='#define VERSION_GIT_SHA "%s" \n' % git_sha s +='#define VERSION_BUILD_NUM "%s" \n' % get_build_num() s +="#ifdef __cplusplus \n" s +=" } \n" @@ -876,6 +888,12 @@ def publish_ext(bld): +def test (bld): + r=commands.getstatusoutput("git log --pretty=format:'%H' -n 1") + if r[0]==0: + print r[1] + + diff --git a/linux_dpdk/wscript b/linux_dpdk/wscript index be048bd8..459e2201 100755 --- a/linux_dpdk/wscript +++ b/linux_dpdk/wscript @@ -45,6 +45,9 @@ def publish_web(bld): def sync(bld): ws_main.sync(bld) +def test(bld): + ws_main.test(bld) + diff --git a/scripts/automation/trex_control_plane/client/trex_async_client.py b/scripts/automation/trex_control_plane/client/trex_async_client.py index 6793a4ca..00304886 100644 --- a/scripts/automation/trex_control_plane/client/trex_async_client.py +++ b/scripts/automation/trex_control_plane/client/trex_async_client.py @@ -21,13 +21,14 @@ from common.trex_stats import * from common.trex_streams import * # basic async stats class -class TrexAsyncStats(object): +class CTRexAsyncStats(object): def __init__ (self): self.ref_point = None self.current = {} self.last_update_ts = datetime.datetime.now() - def __format_num (self, size, suffix = ""): + @staticmethod + def format_num (size, suffix = ""): for unit in ['','K','M','G','T','P']: if abs(size) < 1000.0: @@ -45,9 +46,12 @@ class TrexAsyncStats(object): if self.ref_point == None: self.ref_point = self.current + + def clear(self): + self.ref_point = self.current - def get (self, field, format = False, suffix = ""): + def get(self, field, format=False, suffix=""): if not field in self.current: return "N/A" @@ -55,17 +59,16 @@ class TrexAsyncStats(object): if not format: return self.current[field] else: - return self.__format_num(self.current[field], suffix) - + return self.format_num(self.current[field], suffix) - def get_rel (self, field, format = False, suffix = ""): + def get_rel (self, field, format=False, suffix=""): if not field in self.current: return "N/A" if not format: return (self.current[field] - self.ref_point[field]) else: - return self.__format_num(self.current[field] - self.ref_point[field], suffix) + return self.format_num(self.current[field] - self.ref_point[field], suffix) # return true if new data has arrived in the past 2 seconds @@ -74,28 +77,28 @@ class TrexAsyncStats(object): return (delta_ms < 2000) # describes the general stats provided by TRex -class TrexAsyncStatsGeneral(TrexAsyncStats): +class CTRexAsyncStatsGeneral(CTRexAsyncStats): def __init__ (self): - super(TrexAsyncStatsGeneral, self).__init__() + super(CTRexAsyncStatsGeneral, self).__init__() # per port stats -class TrexAsyncStatsPort(TrexAsyncStats): +class CTRexAsyncStatsPort(CTRexAsyncStats): def __init__ (self): - super(TrexAsyncStatsPort, self).__init__() + super(CTRexAsyncStatsPort, self).__init__() def get_stream_stats (self, stream_id): return None # stats manager -class TrexAsyncStatsManager(): +class CTRexAsyncStatsManager(): def __init__ (self): - self.general_stats = TrexAsyncStatsGeneral() + self.general_stats = CTRexAsyncStatsGeneral() self.port_stats = {} - def get_general_stats (self): + def get_general_stats(self): return self.general_stats def get_port_stats (self, port_id): @@ -106,10 +109,10 @@ class TrexAsyncStatsManager(): return self.port_stats[str(port_id)] - def update (self, data): + def update(self, data): self.__handle_snapshot(data) - def __handle_snapshot (self, snapshot): + def __handle_snapshot(self, snapshot): general_stats = {} port_stats = {} @@ -140,7 +143,7 @@ class TrexAsyncStatsManager(): for port_id, data in port_stats.iteritems(): if not port_id in self.port_stats: - self.port_stats[port_id] = TrexAsyncStatsPort() + self.port_stats[port_id] = CTRexAsyncStatsPort() self.port_stats[port_id].update(data) @@ -149,49 +152,115 @@ class TrexAsyncStatsManager(): class CTRexAsyncClient(): - def __init__ (self, server, port, stateless_client): + def __init__ (self, server, port, stateless_client, prn_func = None): self.port = port self.server = server self.stateless_client = stateless_client + self.prn_func = prn_func self.raw_snapshot = {} - self.stats = TrexAsyncStatsManager() + self.stats = CTRexAsyncStatsManager() + + self.last_data_recv_ts = 0 + self.connected = False + + # connects the async channel + def connect (self): + + if self.connected: + self.disconnect() self.tr = "tcp://{0}:{1}".format(self.server, self.port) - print "\nConnecting To ZMQ Publisher At {0}".format(self.tr) + msg = "\nConnecting To ZMQ Publisher On {0}".format(self.tr) + + if self.prn_func: + self.prn_func(msg) + else: + print msg + + # Socket to talk to server + self.context = zmq.Context() + self.socket = self.context.socket(zmq.SUB) + + + # before running the thread - mark as active self.active = True - self.t = threading.Thread(target = self.run) + self.t = threading.Thread(target = self._run) # kill this thread on exit and don't add it to the join list self.t.setDaemon(True) self.t.start() + self.connected = True - def run (self): + # wait for data streaming from the server + timeout = time.time() + 5 + while not self.is_alive(): + time.sleep(0.01) + if time.time() > timeout: + self.disconnect() + return False, "*** [subscriber] - no data flow from server at : " + self.tr - # Socket to talk to server - self.context = zmq.Context() - self.socket = self.context.socket(zmq.SUB) + return True, "" + + # disconnect + def disconnect (self): + if not self.connected: + return + + # signal that the context was destroyed (exit the thread loop) + self.context.term() + + # mark for join and join + self.active = False + self.t.join() + + # done + self.connected = False + + # thread function + def _run (self): + + + # socket must be created on the same thread self.socket.connect(self.tr) self.socket.setsockopt(zmq.SUBSCRIBE, '') - self.socket.setsockopt(zmq.RCVTIMEO, 3000) + self.socket.setsockopt(zmq.RCVTIMEO, 5000) + + got_data = False while self.active: try: - line = self.socket.recv_string(); - self.stateless_client.on_async_alive() + line = self.socket.recv_string() + self.last_data_recv_ts = time.time() + + # signal once + if not got_data: + self.stateless_client.on_async_alive() + got_data = True + + # got a timeout - mark as not alive and retry except zmq.Again: - self.stateless_client.on_async_dead() + + # signal once + if got_data: + self.stateless_client.on_async_dead() + got_data = False + continue + except zmq.ContextTerminated: + # outside thread signaled us to exit + break + msg = json.loads(line) name = msg['name'] @@ -201,6 +270,17 @@ class CTRexAsyncClient(): self.__dispatch(name, type, data) + + # closing of socket must be from the same thread + self.socket.close(linger = 0) + + + # did we get info for the last 3 seconds ? + def is_alive (self): + if self.last_data_recv_ts == None: + return False + + return ( (time.time() - self.last_data_recv_ts) < 3 ) def get_stats (self): return self.stats @@ -208,12 +288,11 @@ class CTRexAsyncClient(): def get_raw_snapshot (self): return self.raw_snapshot - # dispatch the message to the right place def __dispatch (self, name, type, data): # stats if name == "trex-global": - self.stats.update(data) + self.stateless_client.handle_async_stats_update(data) # events elif name == "trex-event": self.stateless_client.handle_async_event(type, data) @@ -221,7 +300,3 @@ class CTRexAsyncClient(): pass - def stop (self): - self.active = False - self.t.join() - diff --git a/scripts/automation/trex_control_plane/client/trex_client.py b/scripts/automation/trex_control_plane/client/trex_client.py index 160abdec..49807014 100755 --- a/scripts/automation/trex_control_plane/client/trex_client.py +++ b/scripts/automation/trex_control_plane/client/trex_client.py @@ -88,7 +88,7 @@ class CTRexClient(object): finally: self.prompt_verbose_data() - def start_trex (self, f, d, block_to_success = True, timeout = 30, user = None, **trex_cmd_options): + def start_trex (self, f, d, block_to_success = True, timeout = 30, user = None, trex_development = False, **trex_cmd_options): """ Request to start a TRex run on server. @@ -125,13 +125,15 @@ class CTRexClient(object): user = user or self.__default_user try: d = int(d) - if d < 30: # specify a test should take at least 30 seconds long. + if d < 30 and not trex_development: # specify a test should take at least 30 seconds long. raise ValueError except ValueError: raise ValueError('d parameter must be integer, specifying how long TRex run, and must be larger than 30 secs.') trex_cmd_options.update( {'f' : f, 'd' : d} ) - + if not trex_cmd_options.get('l'): + self.result_obj.latency_checked = False + self.result_obj.clear_results() try: issue_time = time.time() @@ -544,7 +546,7 @@ class CTRexClient(object): Get TRex version details. :return: - Trex details (Version, User, Date, Uuid) as ordered dictionary + Trex details (Version, User, Date, Uuid, Git SHA) as ordered dictionary :raises: + :exc:`trex_exceptions.TRexRequestDenied`, in case TRex version could not be determined. @@ -556,9 +558,11 @@ class CTRexClient(object): version_dict = OrderedDict() result_lines = binascii.a2b_base64(self.server.get_trex_version()).split('\n') for line in result_lines: + if not line: + continue key, value = line.strip().split(':', 1) version_dict[key.strip()] = value.strip() - for key in ('Version', 'User', 'Date', 'Uuid'): + for key in ('Version', 'User', 'Date', 'Uuid', 'Git SHA'): if key not in version_dict: raise Exception('get_trex_version: got server response without key: {0}'.format(key)) return version_dict @@ -767,6 +771,7 @@ class CTRexResult(object): """ self._history = deque(maxlen = max_history_size) self.clear_results() + self.latency_checked = True def __repr__(self): return ("Is valid history? {arg}\n".format( arg = self.is_valid_hist() ) + @@ -1032,18 +1037,19 @@ class CTRexResult(object): self._done_warmup = True # handle latency data - latency_pre = "trex-latency" - self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-")#None # TBC - # support old typo - if self._max_latency is None: - latency_pre = "trex-latecny" - self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-") - - self._avg_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), "avg-")#None # TBC - self._avg_latency = CTRexResult.__avg_all_and_rename_keys(self._avg_latency) - - avg_win_latency_list = self.get_value_list("{latency}.data".format(latency = latency_pre), "avg-") - self._avg_window_latency = CTRexResult.__calc_latency_win_stats(avg_win_latency_list) + if self.latency_checked: + latency_pre = "trex-latency" + self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-")#None # TBC + # support old typo + if self._max_latency is None: + latency_pre = "trex-latecny" + self._max_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), ".*max-") + + self._avg_latency = self.get_last_value("{latency}.data".format(latency = latency_pre), "avg-")#None # TBC + self._avg_latency = CTRexResult.__avg_all_and_rename_keys(self._avg_latency) + + avg_win_latency_list = self.get_value_list("{latency}.data".format(latency = latency_pre), "avg-") + self._avg_window_latency = CTRexResult.__calc_latency_win_stats(avg_win_latency_list) tx_pkts = CTRexResult.__get_value_by_path(latest_dump, "trex-global.data.m_total_tx_pkts") rx_pkts = CTRexResult.__get_value_by_path(latest_dump, "trex-global.data.m_total_rx_pkts") diff --git a/scripts/automation/trex_control_plane/client/trex_port.py b/scripts/automation/trex_control_plane/client/trex_port.py new file mode 100644 index 00000000..4f82e86a --- /dev/null +++ b/scripts/automation/trex_control_plane/client/trex_port.py @@ -0,0 +1,411 @@ + +from collections import namedtuple +from common.trex_types import * +from common import trex_stats + +# describes a single port +class Port(object): + STATE_DOWN = 0 + STATE_IDLE = 1 + STATE_STREAMS = 2 + STATE_TX = 3 + STATE_PAUSE = 4 + PortState = namedtuple('PortState', ['state_id', 'state_name']) + STATES_MAP = {STATE_DOWN: "DOWN", + STATE_IDLE: "IDLE", + STATE_STREAMS: "IDLE", + STATE_TX: "ACTIVE", + STATE_PAUSE: "PAUSE"} + + + def __init__ (self, port_id, speed, driver, user, comm_link): + self.port_id = port_id + self.state = self.STATE_IDLE + self.handler = None + self.comm_link = comm_link + self.transmit = comm_link.transmit + self.transmit_batch = comm_link.transmit_batch + self.user = user + self.driver = driver + self.speed = speed + self.streams = {} + self.profile = None + + self.port_stats = trex_stats.CPortStats(self) + + + def err(self, msg): + return RC_ERR("port {0} : {1}".format(self.port_id, msg)) + + def ok(self, data = "ACK"): + return RC_OK(data) + + def get_speed_bps (self): + return (self.speed * 1000 * 1000 * 1000) + + # take the port + def acquire(self, force = False): + params = {"port_id": self.port_id, + "user": self.user, + "force": force} + + command = RpcCmdData("acquire", params) + rc = self.transmit(command.method, command.params) + if rc.success: + self.handler = rc.data + return self.ok() + else: + return self.err(rc.data) + + # release the port + def release(self): + params = {"port_id": self.port_id, + "handler": self.handler} + + command = RpcCmdData("release", params) + rc = self.transmit(command.method, command.params) + self.handler = None + + if rc.success: + return self.ok() + else: + return self.err(rc.data) + + def is_acquired(self): + return (self.handler != None) + + def is_active(self): + return(self.state == self.STATE_TX ) or (self.state == self.STATE_PAUSE) + + def is_transmitting (self): + return (self.state == self.STATE_TX) + + def is_paused (self): + return (self.state == self.STATE_PAUSE) + + + def sync(self): + params = {"port_id": self.port_id} + + command = RpcCmdData("get_port_status", params) + rc = self.transmit(command.method, command.params) + if not rc.success: + return self.err(rc.data) + + # sync the port + port_state = rc.data['state'] + + if port_state == "DOWN": + self.state = self.STATE_DOWN + elif port_state == "IDLE": + self.state = self.STATE_IDLE + elif port_state == "STREAMS": + self.state = self.STATE_STREAMS + elif port_state == "TX": + self.state = self.STATE_TX + elif port_state == "PAUSE": + self.state = self.STATE_PAUSE + else: + raise Exception("port {0}: bad state received from server '{1}'".format(self.port_id, sync_data['state'])) + + return self.ok() + + + # return TRUE if write commands + def is_port_writable (self): + # operations on port can be done on state idle or state streams + return ((self.state == self.STATE_IDLE) or (self.state == self.STATE_STREAMS)) + + # add stream to the port + def add_stream (self, stream_id, stream_obj): + + if not self.is_port_writable(): + return self.err("Please stop port before attempting to add streams") + + + params = {"handler": self.handler, + "port_id": self.port_id, + "stream_id": stream_id, + "stream": stream_obj} + + rc, data = self.transmit("add_stream", params) + if not rc: + r = self.err(data) + print r.good() + + # add the stream + self.streams[stream_id] = stream_obj + + # the only valid state now + self.state = self.STATE_STREAMS + + return self.ok() + + # add multiple streams + def add_streams (self, streams_list): + batch = [] + + for stream in streams_list: + params = {"handler": self.handler, + "port_id": self.port_id, + "stream_id": stream.stream_id, + "stream": stream.stream} + + cmd = RpcCmdData('add_stream', params) + batch.append(cmd) + + rc, data = self.transmit_batch(batch) + + if not rc: + return self.err(data) + + # add the stream + for stream in streams_list: + self.streams[stream.stream_id] = stream.stream + + # the only valid state now + self.state = self.STATE_STREAMS + + return self.ok() + + # remove stream from port + def remove_stream (self, stream_id): + + if not stream_id in self.streams: + return self.err("stream {0} does not exists".format(stream_id)) + + params = {"handler": self.handler, + "port_id": self.port_id, + "stream_id": stream_id} + + + rc, data = self.transmit("remove_stream", params) + if not rc: + return self.err(data) + + self.streams[stream_id] = None + + self.state = self.STATE_STREAMS if len(self.streams > 0) else self.STATE_IDLE + + return self.ok() + + # remove all the streams + def remove_all_streams (self): + + params = {"handler": self.handler, + "port_id": self.port_id} + + rc, data = self.transmit("remove_all_streams", params) + if not rc: + return self.err(data) + + self.streams = {} + + self.state = self.STATE_IDLE + + return self.ok() + + # get a specific stream + def get_stream (self, stream_id): + if stream_id in self.streams: + return self.streams[stream_id] + else: + return None + + def get_all_streams (self): + return self.streams + + # start traffic + def start (self, mul, duration): + if self.state == self.STATE_DOWN: + return self.err("Unable to start traffic - port is down") + + if self.state == self.STATE_IDLE: + return self.err("Unable to start traffic - no streams attached to port") + + if self.state == self.STATE_TX: + return self.err("Unable to start traffic - port is already transmitting") + + params = {"handler": self.handler, + "port_id": self.port_id, + "mul": mul, + "duration": duration} + + rc, data = self.transmit("start_traffic", params) + if not rc: + return self.err(data) + + self.state = self.STATE_TX + + return self.ok() + + # stop traffic + # with force ignores the cached state and sends the command + def stop (self, force = False): + + if (not force) and (self.state != self.STATE_TX) and (self.state != self.STATE_PAUSE): + return self.err("port is not transmitting") + + params = {"handler": self.handler, + "port_id": self.port_id} + + rc, data = self.transmit("stop_traffic", params) + if not rc: + return self.err(data) + + # only valid state after stop + self.state = self.STATE_STREAMS + + return self.ok() + + def pause (self): + + if (self.state != self.STATE_TX) : + return self.err("port is not transmitting") + + params = {"handler": self.handler, + "port_id": self.port_id} + + rc, data = self.transmit("pause_traffic", params) + if not rc: + return self.err(data) + + # only valid state after stop + self.state = self.STATE_PAUSE + + return self.ok() + + + def resume (self): + + if (self.state != self.STATE_PAUSE) : + return self.err("port is not in pause mode") + + params = {"handler": self.handler, + "port_id": self.port_id} + + rc, data = self.transmit("resume_traffic", params) + if not rc: + return self.err(data) + + # only valid state after stop + self.state = self.STATE_TX + + return self.ok() + + + def update (self, mul): + if (self.state != self.STATE_TX) : + return self.err("port is not transmitting") + + params = {"handler": self.handler, + "port_id": self.port_id, + "mul": mul} + + rc, data = self.transmit("update_traffic", params) + if not rc: + return self.err(data) + + return self.ok() + + + def validate (self): + + if (self.state == self.STATE_DOWN): + return self.err("port is down") + + if (self.state == self.STATE_IDLE): + return self.err("no streams attached to port") + + params = {"handler": self.handler, + "port_id": self.port_id} + + rc, data = self.transmit("validate", params) + if not rc: + return self.err(data) + + self.profile = data + + return self.ok() + + def get_profile (self): + return self.profile + + + def print_profile (self, mult, duration): + if not self.get_profile(): + return + + rate = self.get_profile()['rate'] + graph = self.get_profile()['graph'] + + print format_text("Profile Map Per Port\n", 'underline', 'bold') + + factor = mult_to_factor(mult, rate['max_bps'], rate['max_pps'], rate['max_line_util']) + + print "Profile max BPS (base / req): {:^12} / {:^12}".format(format_num(rate['max_bps'], suffix = "bps"), + format_num(rate['max_bps'] * factor, suffix = "bps")) + + print "Profile max PPS (base / req): {:^12} / {:^12}".format(format_num(rate['max_pps'], suffix = "pps"), + format_num(rate['max_pps'] * factor, suffix = "pps"),) + + print "Profile line util. (base / req): {:^12} / {:^12}".format(format_percentage(rate['max_line_util'] * 100), + format_percentage(rate['max_line_util'] * factor * 100)) + + + # duration + exp_time_base_sec = graph['expected_duration'] / (1000 * 1000) + exp_time_factor_sec = exp_time_base_sec / factor + + # user configured a duration + if duration > 0: + if exp_time_factor_sec > 0: + exp_time_factor_sec = min(exp_time_factor_sec, duration) + else: + exp_time_factor_sec = duration + + + print "Duration (base / req): {:^12} / {:^12}".format(format_time(exp_time_base_sec), + format_time(exp_time_factor_sec)) + print "\n" + + + def get_port_state_name(self): + return self.STATES_MAP.get(self.state, "Unknown") + + ################# stats handler ###################### + def generate_port_stats(self): + return self.port_stats.generate_stats() + pass + + def generate_port_status(self): + return {"port-type": self.driver, + "maximum": "{speed} Gb/s".format(speed=self.speed), + "port-status": self.get_port_state_name() + } + + def clear_stats(self): + return self.port_stats.clear_stats() + + def invalidate_stats(self): + return self.port_stats.invalidate() + + + ################# events handler ###################### + def async_event_port_stopped (self): + self.state = self.STATE_STREAMS + + + def async_event_port_started (self): + self.state = self.STATE_TX + + + def async_event_port_paused (self): + self.state = self.STATE_PAUSE + + + def async_event_port_resumed (self): + self.state = self.STATE_TX + + def async_event_forced_acquired (self): + self.handler = None diff --git a/scripts/automation/trex_control_plane/client/trex_stateless_client.py b/scripts/automation/trex_control_plane/client/trex_stateless_client.py index c1dea9eb..899805cf 100755 --- a/scripts/automation/trex_control_plane/client/trex_stateless_client.py +++ b/scripts/automation/trex_control_plane/client/trex_stateless_client.py @@ -10,409 +10,88 @@ except ImportError: from client_utils.jsonrpc_client import JsonRpcClient, BatchMessage from client_utils.packet_builder import CTRexPktBuilder import json -from common.trex_stats import * + from common.trex_streams import * from collections import namedtuple from common.text_opts import * -import parsing_opts +from common import trex_stats +from client_utils import parsing_opts, text_tables import time import datetime +import re +import random +from trex_port import Port +from common.trex_types import * from trex_async_client import CTRexAsyncClient -RpcCmdData = namedtuple('RpcCmdData', ['method', 'params']) - -class RpcResponseStatus(namedtuple('RpcResponseStatus', ['success', 'id', 'msg'])): - __slots__ = () - def __str__(self): - return "{id:^3} - {msg} ({stat})".format(id=self.id, - msg=self.msg, - stat="success" if self.success else "fail") - -# simple class to represent complex return value -class RC: - - def __init__ (self, rc = None, data = None): - self.rc_list = [] - - if (rc != None) and (data != None): - tuple_rc = namedtuple('RC', ['rc', 'data']) - self.rc_list.append(tuple_rc(rc, data)) - - def add (self, rc): - self.rc_list += rc.rc_list - - def good (self): - return all([x.rc for x in self.rc_list]) - - def bad (self): - return not self.good() - - def data (self): - return all([x.data if x.rc else "" for x in self.rc_list]) - - def err (self): - return all([x.data if not x.rc else "" for x in self.rc_list]) - - def annotate (self, desc = None): - if desc: - print format_text('\n{:<40}'.format(desc), 'bold'), - - if self.bad(): - # print all the errors - print "" - for x in self.rc_list: - if not x.rc: - print format_text("\n{0}".format(x.data), 'bold') - - print "" - print format_text("[FAILED]\n", 'red', 'bold') - - - else: - print format_text("[SUCCESS]\n", 'green', 'bold') - - -def RC_OK(): - return RC(True, "") -def RC_ERR (err): - return RC(False, err) - - -LoadedStreamList = namedtuple('LoadedStreamList', ['loaded', 'compiled']) - -# describes a stream DB -class CStreamsDB(object): - - def __init__(self): - self.stream_packs = {} - - def load_yaml_file (self, filename): - - stream_pack_name = filename - if stream_pack_name in self.get_loaded_streams_names(): - self.remove_stream_packs(stream_pack_name) - - stream_list = CStreamList() - loaded_obj = stream_list.load_yaml(filename) - try: - compiled_streams = stream_list.compile_streams() - rc = self.load_streams(stream_pack_name, - LoadedStreamList(loaded_obj, - [StreamPack(v.stream_id, v.stream.dump()) - for k, v in compiled_streams.items()])) +########## utlity ############ +def mult_to_factor (mult, max_bps, max_pps, line_util): + if mult['type'] == 'raw': + return mult['value'] - except Exception as e: - return None + if mult['type'] == 'bps': + return mult['value'] / max_bps - return self.get_stream_pack(stream_pack_name) + if mult['type'] == 'pps': + return mult['value'] / max_pps - def load_streams(self, name, LoadedStreamList_obj): - if name in self.stream_packs: - return False - else: - self.stream_packs[name] = LoadedStreamList_obj - return True + if mult['type'] == 'percentage': + return mult['value'] / line_util - def remove_stream_packs(self, *names): - removed_streams = [] - for name in names: - removed = self.stream_packs.pop(name) - if removed: - removed_streams.append(name) - return removed_streams - def clear(self): - self.stream_packs.clear() - def get_loaded_streams_names(self): - return self.stream_packs.keys() +class CTRexStatelessClient(object): + """docstring for CTRexStatelessClient""" - def stream_pack_exists (self, name): - return name in self.get_loaded_streams_names() + # verbose levels + VERBOSE_SILENCE = 0 + VERBOSE_REGULAR = 1 + VERBOSE_HIGH = 2 + + def __init__(self, username, server="localhost", sync_port = 5050, async_port = 4500, virtual=False): + super(CTRexStatelessClient, self).__init__() - def get_stream_pack(self, name): - if not self.stream_pack_exists(name): - return None - else: - return self.stream_packs.get(name) - - -# describes a single port -class Port(object): - STATE_DOWN = 0 - STATE_IDLE = 1 - STATE_STREAMS = 2 - STATE_TX = 3 - STATE_PAUSE = 4 - - def __init__ (self, port_id, speed, driver, user, transmit): - self.port_id = port_id - self.state = self.STATE_IDLE - self.handler = None - self.transmit = transmit - self.user = user - self.driver = driver - self.speed = speed - self.streams = {} - - def err(self, msg): - return RC_ERR("port {0} : {1}".format(self.port_id, msg)) - - def ok(self): - return RC_OK() + self.user = username - def get_speed_bps (self): - return (self.speed * 1000 * 1000 * 1000) + self.comm_link = CTRexStatelessClient.CCommLink(server, sync_port, virtual, self.prn_func) - # take the port - def acquire(self, force = False): - params = {"port_id": self.port_id, - "user": self.user, - "force": force} + # default verbose level + self.verbose = self.VERBOSE_REGULAR - command = RpcCmdData("acquire", params) - rc = self.transmit(command.method, command.params) - if rc.success: - self.handler = rc.data - return self.ok() - else: - return self.err(rc.data) + self.ports = {} + self._connection_info = {"server": server, + "sync_port": sync_port, + "async_port": async_port} + self.system_info = {} + self.server_version = {} + self.__err_log = None + self.async_client = CTRexAsyncClient(server, async_port, self, self.prn_func) - # release the port - def release(self): - params = {"port_id": self.port_id, - "handler": self.handler} + self.streams_db = CStreamsDB() + self.global_stats = trex_stats.CGlobalStats(self._connection_info, + self.server_version, + self.ports) + self.stats_generator = trex_stats.CTRexStatsGenerator(self.global_stats, + self.ports) - command = RpcCmdData("release", params) - rc = self.transmit(command.method, command.params) - if rc.success: - self.handler = rc.data - return self.ok() - else: - return self.err(rc.data) - - def is_acquired(self): - return (self.handler != None) - - def is_active(self): - return(self.state == self.STATE_TX ) or (self.state == self.STATE_PAUSE) - - def sync(self, sync_data): - self.handler = sync_data['handler'] - port_state = sync_data['state'].upper() - if port_state == "DOWN": - self.state = self.STATE_DOWN - elif port_state == "IDLE": - self.state = self.STATE_IDLE - elif port_state == "STREAMS": - self.state = self.STATE_STREAMS - elif port_state == "TX": - self.state = self.STATE_TX - elif port_state == "PAUSE": - self.state = self.STATE_PAUSE - else: - raise Exception("port {0}: bad state received from server '{1}'".format(self.port_id, sync_data['state'])) + self.events = [] - return self.ok() + self.read_only = False + self.connected = False - # return TRUE if write commands - def is_port_writable (self): - # operations on port can be done on state idle or state streams - return ((self.state == self.STATE_IDLE) or (self.state == self.STATE_STREAMS)) - - # add stream to the port - def add_stream (self, stream_id, stream_obj): - - if not self.is_port_writable(): - return self.err("Please stop port before attempting to add streams") - - - params = {"handler": self.handler, - "port_id": self.port_id, - "stream_id": stream_id, - "stream": stream_obj} - - rc, data = self.transmit("add_stream", params) - if not rc: - r = self.err(data) - print r.good() - - # add the stream - self.streams[stream_id] = stream_obj - - # the only valid state now - self.state = self.STATE_STREAMS - - return self.ok() - - # remove stream from port - def remove_stream (self, stream_id): - - if not stream_id in self.streams: - return self.err("stream {0} does not exists".format(stream_id)) - - params = {"handler": self.handler, - "port_id": self.port_id, - "stream_id": stream_id} - - - rc, data = self.transmit("remove_stream", params) - if not rc: - return self.err(data) - - self.streams[stream_id] = None - - return self.ok() - - # remove all the streams - def remove_all_streams (self): - - params = {"handler": self.handler, - "port_id": self.port_id} - - rc, data = self.transmit("remove_all_streams", params) - if not rc: - return self.err(data) - - self.streams = {} - - return self.ok() - - # get a specific stream - def get_stream (self, stream_id): - if stream_id in self.streams: - return self.streams[stream_id] - else: - return None - - def get_all_streams (self): - return self.streams - - # start traffic - def start (self, mul, duration): - if self.state == self.STATE_DOWN: - return self.err("Unable to start traffic - port is down") - - if self.state == self.STATE_IDLE: - return self.err("Unable to start traffic - no streams attached to port") - - if self.state == self.STATE_TX: - return self.err("Unable to start traffic - port is already transmitting") - - params = {"handler": self.handler, - "port_id": self.port_id, - "mul": mul, - "duration": duration} - - rc, data = self.transmit("start_traffic", params) - if not rc: - return self.err(data) - - self.state = self.STATE_TX - - return self.ok() - - # stop traffic - # with force ignores the cached state and sends the command - def stop (self, force = False): - - if (not force) and (self.state != self.STATE_TX) and (self.state != self.STATE_PAUSE): - return self.err("port is not transmitting") - - params = {"handler": self.handler, - "port_id": self.port_id} - - rc, data = self.transmit("stop_traffic", params) - if not rc: - return self.err(data) - - # only valid state after stop - self.state = self.STATE_STREAMS - - return self.ok() - - def pause (self): - - if (self.state != self.STATE_TX) : - return self.err("port is not transmitting") - - params = {"handler": self.handler, - "port_id": self.port_id} - - rc, data = self.transmit("pause_traffic", params) - if not rc: - return self.err(data) - - # only valid state after stop - self.state = self.STATE_PAUSE - - return self.ok() - - - def resume (self): - - if (self.state != self.STATE_PAUSE) : - return self.err("port is not in pause mode") - - params = {"handler": self.handler, - "port_id": self.port_id} - - rc, data = self.transmit("resume_traffic", params) - if not rc: - return self.err(data) - - # only valid state after stop - self.state = self.STATE_TX - - return self.ok() - - - def update (self, mul): - if (self.state != self.STATE_TX) : - return self.err("port is not transmitting") - - params = {"handler": self.handler, - "port_id": self.port_id, - "mul": mul} - - rc, data = self.transmit("update_traffic", params) - if not rc: - return self.err(data) - - return self.ok() - - ################# events handler ###################### - def async_event_port_stopped (self): - self.state = self.STATE_STREAMS - - -class CTRexStatelessClient(object): - """docstring for CTRexStatelessClient""" - - def __init__(self, username, server="localhost", sync_port = 5050, async_port = 4500, virtual=False): - super(CTRexStatelessClient, self).__init__() - self.user = username - self.comm_link = CTRexStatelessClient.CCommLink(server, sync_port, virtual) - self.verbose = False - self.ports = [] - self._conn_handler = {} - self._active_ports = set() - self._system_info = None - self._server_version = None - self.__err_log = None - - self._async_client = CTRexAsyncClient(server, async_port, self) - self.streams_db = CStreamsDB() - self.connected = False + # returns the port object + def get_port (self, port_id): + return self.ports.get(port_id, None) - self.events = [] + def get_server (self): + return self.comm_link.get_server() ################# events handler ###################### def add_event_log (self, msg, ev_type, show = False): @@ -427,7 +106,37 @@ class CTRexStatelessClient(object): self.events.append("{:<10} - {:^8} - {:}".format(st, prefix, format_text(msg, 'bold'))) if show: - print format_text("\n{:^8} - {:}".format(prefix, format_text(msg, 'bold'))) + self.prn_func(format_text("\n{:^8} - {:}".format(prefix, format_text(msg, 'bold')))) + + + def handle_async_stats_update(self, dump_data): + global_stats = {} + port_stats = {} + + # filter the values per port and general + for key, value in dump_data.iteritems(): + # match a pattern of ports + m = re.search('(.*)\-([0-8])', key) + if m: + port_id = int(m.group(2)) + field_name = m.group(1) + if self.ports.has_key(port_id): + if not port_id in port_stats: + port_stats[port_id] = {} + port_stats[port_id][field_name] = value + else: + continue + else: + # no port match - general stats + global_stats[key] = value + + # update the general object with the snapshot + self.global_stats.update(global_stats) + # update all ports + for port_id, data in port_stats.iteritems(): + self.ports[port_id].port_stats.update(data) + + def handle_async_event (self, type, data): # DP stopped @@ -438,6 +147,7 @@ class CTRexStatelessClient(object): if (type == 0): port_id = int(data['port_id']) ev = "Port {0} has started".format(port_id) + self.async_event_port_started(port_id) # port stopped elif (type == 1): @@ -448,21 +158,47 @@ class CTRexStatelessClient(object): self.async_event_port_stopped(port_id) - # server stopped + # port paused elif (type == 2): - ev = "Server has stopped" - self.async_event_server_stopped() - show_event = True + port_id = int(data['port_id']) + ev = "Port {0} has paused".format(port_id) - # port finished traffic + # call the handler + self.async_event_port_paused(port_id) + + # port resumed elif (type == 3): port_id = int(data['port_id']) + ev = "Port {0} has resumed".format(port_id) + + # call the handler + self.async_event_port_resumed(port_id) + + # port finished traffic + elif (type == 4): + port_id = int(data['port_id']) ev = "Port {0} job done".format(port_id) # call the handler self.async_event_port_stopped(port_id) show_event = True + # port was stolen... + elif (type == 5): + port_id = int(data['port_id']) + ev = "Port {0} was forcely taken".format(port_id) + + # call the handler + self.async_event_port_forced_acquired(port_id) + show_event = True + + # server stopped + elif (type == 100): + ev = "Server has stopped" + self.async_event_server_stopped() + show_event = True + + else: # unknown event - ignore return @@ -474,8 +210,26 @@ class CTRexStatelessClient(object): def async_event_port_stopped (self, port_id): self.ports[port_id].async_event_port_stopped() + + def async_event_port_started (self, port_id): + self.ports[port_id].async_event_port_started() + + + def async_event_port_paused (self, port_id): + self.ports[port_id].async_event_port_paused() + + + def async_event_port_resumed (self, port_id): + self.ports[port_id].async_event_port_resumed() + + + def async_event_port_forced_acquired (self, port_id): + self.ports[port_id].async_event_forced_acquired() + self.read_only = True + def async_event_server_stopped (self): - self.disconnect() + self.connected = False + def get_events (self): return self.events @@ -485,6 +239,24 @@ class CTRexStatelessClient(object): ############# helper functions section ############## + # measure time for functions + def timing(f): + def wrap(*args): + time1 = time.time() + ret = f(*args) + + # don't want to print on error + if ret.bad(): + return ret + + delta = time.time() - time1 + print format_time(delta) + "\n" + + return ret + + return wrap + + def validate_port_list(self, port_id_list): if not isinstance(port_id_list, list): print type(port_id_list) @@ -517,27 +289,38 @@ class CTRexStatelessClient(object): ############ boot up section ################ # connection sequence - def connect(self): + # mode can be RW - read / write, RWF - read write with force , RO - read only + def connect(self, mode = "RW"): + + if self.is_connected(): + self.disconnect() + + # clear this flag self.connected = False - # connect + # connect sync channel rc, data = self.comm_link.connect() if not rc: return RC_ERR(data) + # connect async channel + rc, data = self.async_client.connect() + if not rc: + return RC_ERR(data) + # version rc, data = self.transmit("get_version") if not rc: return RC_ERR(data) self.server_version = data + self.global_stats.server_version = data # cache system info rc, data = self.transmit("get_system_info") if not rc: return RC_ERR(data) - self.system_info = data # cache supported commands @@ -551,44 +334,74 @@ class CTRexStatelessClient(object): for port_id in xrange(self.get_port_count()): speed = self.system_info['ports'][port_id]['speed'] driver = self.system_info['ports'][port_id]['driver'] - self.ports.append(Port(port_id, speed, driver, self.user, self.transmit)) - # acquire all ports - rc = self.acquire() - if rc.bad(): - return rc + self.ports[port_id] = Port(port_id, speed, driver, self.user, self.comm_link) + - rc = self.sync_with_server() + # sync the ports + rc = self.sync_ports() if rc.bad(): return rc - self.connected = True + # acquire all ports + if mode == "RW": + rc = self.acquire(force = False) + + # fallback to read only if failed + if rc.bad(): + rc.annotate(show_status = False) + print format_text("Switching to read only mode - only few commands will be available", 'bold') + + self.release(self.get_acquired_ports()) + self.read_only = True + else: + self.read_only = False + elif mode == "RWF": + rc = self.acquire(force = True) + if rc.bad(): + return rc + self.read_only = False + + elif mode == "RO": + # no acquire on read only + rc = RC_OK() + self.read_only = True + + + + self.connected = True return RC_OK() + + def is_read_only (self): + return self.read_only + def is_connected (self): return self.connected and self.comm_link.is_connected def disconnect(self): - self.connected = False + # release any previous acquired ports + if self.is_connected(): + self.release(self.get_acquired_ports()) + self.comm_link.disconnect() + self.async_client.disconnect() + + self.connected = False + return RC_OK() def on_async_dead (self): - if self.is_connected(): + if self.connected: msg = 'lost connection to server' self.add_event_log(msg, 'local', True) - - self.disconnect() + self.connected = False def on_async_alive (self): - if not self.is_connected(): - msg = 'server connection restored' - self.add_event_log(msg, 'local', True) - - self.cmd_connect() + pass ########### cached queries (no server traffic) ########### @@ -612,7 +425,7 @@ class CTRexStatelessClient(object): return port_ids def get_stats_async (self): - return self._async_client.get_stats() + return self.async_client.get_stats() def get_connection_port (self): return self.comm_link.port @@ -620,17 +433,50 @@ class CTRexStatelessClient(object): def get_connection_ip (self): return self.comm_link.server - def get_acquired_ports(self): - return [port.port_id for port in self.ports if port.is_acquired()] + def get_all_ports (self): + return [port_id for port_id, port_obj in self.ports.iteritems()] + def get_acquired_ports(self): + return [port_id + for port_id, port_obj in self.ports.iteritems() + if port_obj.is_acquired()] def get_active_ports(self): - return [port.port_id for port in self.ports if port.is_active()] + return [port_id + for port_id, port_obj in self.ports.iteritems() + if port_obj.is_active()] + + def get_paused_ports (self): + return [port_id + for port_id, port_obj in self.ports.iteritems() + if port_obj.is_paused()] + + def get_transmitting_ports (self): + return [port_id + for port_id, port_obj in self.ports.iteritems() + if port_obj.is_transmitting()] def set_verbose(self, mode): - self.comm_link.set_verbose(mode) + + # on high - enable link verbose + if mode == self.VERBOSE_HIGH: + self.comm_link.set_verbose(True) + else: + self.comm_link.set_verbose(False) + self.verbose = mode + + def check_verbose (self, level): + return (self.verbose >= level) + + def get_verbose (self): + return self.verbose + + def prn_func (self, msg, level = VERBOSE_REGULAR): + if self.check_verbose(level): + print msg + ############# server actions ################ # ping server @@ -639,21 +485,23 @@ class CTRexStatelessClient(object): return RC(rc, info) - def sync_with_server(self, sync_streams=False): - rc, data = self.transmit("sync_user", {"user": self.user, "sync_streams": sync_streams}) - if not rc: - return RC_ERR(data) - for port_info in data: - rc = self.ports[port_info['port_id']].sync(port_info) - if rc.bad(): - return rc + def get_global_stats(self): + rc, info = self.transmit("get_global_stats") + return RC(rc, info) - return RC_OK() + ########## port commands ############## + def sync_ports (self, port_id_list = None, force = False): + port_id_list = self.__ports(port_id_list) + rc = RC() + + for port_id in port_id_list: + rc.add(self.ports[port_id].sync()) + + return rc - ########## port commands ############## # acquire ports, if port_list is none - get all def acquire (self, port_id_list = None, force = False): port_id_list = self.__ports(port_id_list) @@ -672,7 +520,7 @@ class CTRexStatelessClient(object): rc = RC() for port_id in port_id_list: - rc.add(self.ports[port_id].release(force)) + rc.add(self.ports[port_id].release()) return rc @@ -689,15 +537,16 @@ class CTRexStatelessClient(object): return rc + def add_stream_pack(self, stream_pack_list, port_id_list = None): port_id_list = self.__ports(port_id_list) rc = RC() - for stream_pack in stream_pack_list: - rc.add(self.add_stream(stream_pack.stream_id, stream_pack.stream, port_id_list)) - + for port_id in port_id_list: + rc.add(self.ports[port_id].add_streams(stream_pack_list)) + return rc @@ -794,6 +643,17 @@ class CTRexStatelessClient(object): return rc + def validate (self, port_id_list = None): + port_id_list = self.__ports(port_id_list) + + rc = RC() + + for port_id in port_id_list: + rc.add(self.ports[port_id].validate()) + + return rc + + def get_port_stats(self, port_id=None): pass @@ -805,16 +665,19 @@ class CTRexStatelessClient(object): return self.comm_link.transmit(method_name, params) + def transmit_batch(self, batch_list): + return self.comm_link.transmit_batch(batch_list) ######################### Console (high level) API ######################### + @timing def cmd_ping(self): rc = self.ping() rc.annotate("Pinging the server on '{0}' port '{1}': ".format(self.get_connection_ip(), self.get_connection_port())) return rc - def cmd_connect(self): - rc = self.connect() + def cmd_connect(self, mode = "RW"): + rc = self.connect(mode) rc.annotate() return rc @@ -827,12 +690,6 @@ class CTRexStatelessClient(object): def cmd_reset(self): - # sync with the server - rc = self.sync_with_server() - rc.annotate("Syncing with the server:") - if rc.bad(): - return rc - rc = self.acquire(force = True) rc.annotate("Force acquiring all ports:") if rc.bad(): @@ -863,7 +720,7 @@ class CTRexStatelessClient(object): active_ports = list(set(self.get_active_ports()).intersection(port_id_list)) if not active_ports: - msg = "No active traffic on porvided ports" + msg = "No active traffic on provided ports" print format_text(msg, 'bold') return RC_ERR(msg) @@ -877,52 +734,53 @@ class CTRexStatelessClient(object): # update cmd def cmd_update (self, port_id_list, mult): - # find the relveant ports + # find the relevant ports active_ports = list(set(self.get_active_ports()).intersection(port_id_list)) if not active_ports: - msg = "No active traffic on porvided ports" + msg = "No active traffic on provided ports" print format_text(msg, 'bold') return RC_ERR(msg) rc = self.update_traffic(mult, active_ports) rc.annotate("Updating traffic on port(s) {0}:".format(port_id_list)) - if rc.bad(): - return rc + + return rc + + # clear stats + def cmd_clear(self, port_id_list): + + for port_id in port_id_list: + self.ports[port_id].clear_stats() + + self.global_stats.clear_stats() return RC_OK() + def cmd_invalidate (self, port_id_list): + for port_id in port_id_list: + self.ports[port_id].invalidate_stats() + + self.global_stats.invalidate() + + return RC_OK() + # pause cmd def cmd_pause (self, port_id_list): - # find the relveant ports + # find the relevant ports active_ports = list(set(self.get_active_ports()).intersection(port_id_list)) if not active_ports: - msg = "No active traffic on porvided ports" + msg = "No active traffic on provided ports" print format_text(msg, 'bold') return RC_ERR(msg) rc = self.pause_traffic(active_ports) rc.annotate("Pausing traffic on port(s) {0}:".format(port_id_list)) - if rc.bad(): - return rc - - return RC_OK() - - def cmd_pause_line (self, line): - '''Pause active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser(self, - "pause", - self.cmd_stop_line.__doc__, - parsing_opts.PORT_LIST_WITH_ALL) - - opts = parser.parse_args(line.split()) - if opts is None: - return RC_ERR("bad command line paramters") + return rc - return self.cmd_pause(opts.ports) # resume cmd @@ -938,28 +796,11 @@ class CTRexStatelessClient(object): rc = self.resume_traffic(active_ports) rc.annotate("Resume traffic on port(s) {0}:".format(port_id_list)) - if rc.bad(): - return rc - - return RC_OK() - - - def cmd_resume_line (self, line): - '''Resume active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser(self, - "resume", - self.cmd_stop_line.__doc__, - parsing_opts.PORT_LIST_WITH_ALL) - - opts = parser.parse_args(line.split()) - if opts is None: - return RC_ERR("bad command line paramters") - - return self.cmd_resume(opts.ports) + return rc # start cmd - def cmd_start (self, port_id_list, stream_list, mult, force, duration): + def cmd_start (self, port_id_list, stream_list, mult, force, duration, dry): active_ports = list(set(self.get_active_ports()).intersection(port_id_list)) @@ -981,20 +822,67 @@ class CTRexStatelessClient(object): rc = self.add_stream_pack(stream_list.compiled, port_id_list) - rc.annotate("Attaching streams to port(s) {0}:".format(port_id_list)) + rc.annotate("Attaching {0} streams to port(s) {1}:".format(len(stream_list.compiled), port_id_list)) if rc.bad(): return rc + # when not on dry - start the traffic , otherwise validate only + if not dry: + rc = self.start_traffic(mult, duration, port_id_list) + rc.annotate("Starting traffic on port(s) {0}:".format(port_id_list)) - # finally, start the traffic - rc = self.start_traffic(mult, duration, port_id_list) - rc.annotate("Starting traffic on port(s) {0}:".format(port_id_list)) - if rc.bad(): return rc + else: + rc = self.validate(port_id_list) + rc.annotate("Validating traffic profile on port(s) {0}:".format(port_id_list)) + + if rc.bad(): + return rc + + # show a profile on one port for illustration + self.ports[port_id_list[0]].print_profile(mult, duration) + + return rc + + + # validate port(s) profile + def cmd_validate (self, port_id_list): + rc = self.validate(port_id_list) + rc.annotate("Validating streams on port(s) {0}:".format(port_id_list)) + return rc + + + # stats + def cmd_stats(self, port_id_list, stats_mask=set()): + stats_opts = trex_stats.ALL_STATS_OPTS.intersection(stats_mask) + + stats_obj = {} + for stats_type in stats_opts: + stats_obj.update(self.stats_generator.generate_single_statistic(port_id_list, stats_type)) + return stats_obj - return RC_OK() ############## High Level API With Parser ################ + + def cmd_connect_line (self, line): + '''Connects to the TRex server''' + # define a parser + parser = parsing_opts.gen_parser(self, + "connect", + self.cmd_connect_line.__doc__, + parsing_opts.FORCE) + + opts = parser.parse_args(line.split()) + + if opts is None: + return RC_ERR("bad command line parameters") + + if opts.force: + rc = self.cmd_connect(mode = "RWF") + else: + rc = self.cmd_connect(mode = "RW") + + @timing def cmd_start_line (self, line): '''Start selected traffic in specified ports on TRex\n''' # define a parser @@ -1006,16 +894,20 @@ class CTRexStatelessClient(object): parsing_opts.FORCE, parsing_opts.STREAM_FROM_PATH_OR_FILE, parsing_opts.DURATION, - parsing_opts.MULTIPLIER_STRICT) + parsing_opts.MULTIPLIER_STRICT, + parsing_opts.DRY_RUN) opts = parser.parse_args(line.split()) if opts is None: - return RC_ERR("bad command line paramters") + return RC_ERR("bad command line parameters") + if opts.dry: + print format_text("\n*** DRY RUN ***", 'bold') + if opts.db: - stream_list = self.stream_db.get_stream_pack(opts.db) + stream_list = self.streams_db.get_stream_pack(opts.db) rc = RC(stream_list != None) rc.annotate("Load stream pack (from DB):") if rc.bad(): @@ -1035,8 +927,24 @@ class CTRexStatelessClient(object): # if total was set - divide it between the ports opts.mult['value'] = opts.mult['value'] / len(opts.ports) - return self.cmd_start(opts.ports, stream_list, opts.mult, opts.force, opts.duration) + return self.cmd_start(opts.ports, stream_list, opts.mult, opts.force, opts.duration, opts.dry) + + @timing + def cmd_resume_line (self, line): + '''Resume active traffic in specified ports on TRex\n''' + parser = parsing_opts.gen_parser(self, + "resume", + self.cmd_stop_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + if opts is None: + return RC_ERR("bad command line parameters") + + return self.cmd_resume(opts.ports) + + @timing def cmd_stop_line (self, line): '''Stop active traffic in specified ports on TRex\n''' parser = parsing_opts.gen_parser(self, @@ -1046,11 +954,27 @@ class CTRexStatelessClient(object): opts = parser.parse_args(line.split()) if opts is None: - return RC_ERR("bad command line paramters") + return RC_ERR("bad command line parameters") return self.cmd_stop(opts.ports) + @timing + def cmd_pause_line (self, line): + '''Pause active traffic in specified ports on TRex\n''' + parser = parsing_opts.gen_parser(self, + "pause", + self.cmd_stop_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + if opts is None: + return RC_ERR("bad command line parameters") + + return self.cmd_pause(opts.ports) + + + @timing def cmd_update_line (self, line): '''Update port(s) speed currently active\n''' parser = parsing_opts.gen_parser(self, @@ -1071,11 +995,74 @@ class CTRexStatelessClient(object): return self.cmd_update(opts.ports, opts.mult) - + @timing def cmd_reset_line (self, line): return self.cmd_reset() + def cmd_clear_line (self, line): + '''Clear cached local statistics\n''' + # define a parser + parser = parsing_opts.gen_parser(self, + "clear", + self.cmd_clear_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + + if opts is None: + return RC_ERR("bad command line parameters") + return self.cmd_clear(opts.ports) + + + def cmd_stats_line (self, line): + '''Fetch statistics from TRex server by port\n''' + # define a parser + parser = parsing_opts.gen_parser(self, + "stats", + self.cmd_stats_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL, + parsing_opts.STATS_MASK) + + opts = parser.parse_args(line.split()) + + if opts is None: + return RC_ERR("bad command line parameters") + + # determine stats mask + mask = self._get_mask_keys(**self._filter_namespace_args(opts, trex_stats.ALL_STATS_OPTS)) + if not mask: + # set to show all stats if no filter was given + mask = trex_stats.ALL_STATS_OPTS + + stats = self.cmd_stats(opts.ports, mask) + + # print stats to screen + for stat_type, stat_data in stats.iteritems(): + text_tables.print_table_with_header(stat_data.text_table, stat_type) + + + return RC_OK() + + + + @timing + def cmd_validate_line (self, line): + '''validates port(s) stream configuration\n''' + + parser = parsing_opts.gen_parser(self, + "validate", + self.cmd_validate_line.__doc__, + parsing_opts.PORT_LIST_WITH_ALL) + + opts = parser.parse_args(line.split()) + if opts is None: + return RC_ERR("bad command line paramters") + + rc = self.cmd_validate(opts.ports) + return rc + + def cmd_exit_line (self, line): print format_text("Exiting\n", 'bold') # a way to exit @@ -1092,7 +1079,7 @@ class CTRexStatelessClient(object): opts = parser.parse_args(line.split()) if opts is None: - return RC_ERR("bad command line paramters") + return RC_ERR("bad command line parameters") delay_sec = opts.duration if (opts.duration > 0) else 1 @@ -1151,17 +1138,33 @@ class CTRexStatelessClient(object): return True + + ################################# + # ------ private methods ------ # + @staticmethod + def _get_mask_keys(ok_values={True}, **kwargs): + masked_keys = set() + for key, val in kwargs.iteritems(): + if val in ok_values: + masked_keys.add(key) + return masked_keys + + @staticmethod + def _filter_namespace_args(namespace, ok_values): + return {k: v for k, v in namespace.__dict__.items() if k in ok_values} + + ################################# # ------ private classes ------ # class CCommLink(object): """describes the connectivity of the stateless client method""" - def __init__(self, server="localhost", port=5050, virtual=False): + def __init__(self, server="localhost", port=5050, virtual=False, prn_func = None): super(CTRexStatelessClient.CCommLink, self).__init__() self.virtual = virtual self.server = server self.port = port self.verbose = False - self.rpc_link = JsonRpcClient(self.server, self.port) + self.rpc_link = JsonRpcClient(self.server, self.port, prn_func) @property def is_connected(self): @@ -1170,6 +1173,9 @@ class CTRexStatelessClient(object): else: return True + def get_server (self): + return self.server + def set_verbose(self, mode): self.verbose = mode return self.rpc_link.set_verbose(mode) @@ -1211,5 +1217,3 @@ class CTRexStatelessClient(object): if __name__ == "__main__": pass - - diff --git a/scripts/automation/trex_control_plane/client_utils/external_packages.py b/scripts/automation/trex_control_plane/client_utils/external_packages.py index e2bb37a5..3c6eb449 100755 --- a/scripts/automation/trex_control_plane/client_utils/external_packages.py +++ b/scripts/automation/trex_control_plane/client_utils/external_packages.py @@ -9,7 +9,8 @@ PATH_TO_PYTHON_LIB = os.path.abspath(os.path.join(ROOT_PATH, os.pardir, os.pard CLIENT_UTILS_MODULES = ['zmq', 'dpkt-1.8.6', - 'PyYAML-3.01/lib' + 'PyYAML-3.01/lib', + 'texttable-0.8.4' ] def import_client_utils_modules(): diff --git a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py index b826f02f..ce98fbc6 100755 --- a/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py +++ b/scripts/automation/trex_control_plane/client_utils/jsonrpc_client.py @@ -37,7 +37,7 @@ class BatchMessage(object): msg = json.dumps(self.batch_list) - rc, resp_list = self.rpc_client.send_raw_msg(msg, block = False) + rc, resp_list = self.rpc_client.send_raw_msg(msg) if len(self.batch_list) == 1: return CmdResponse(True, [CmdResponse(rc, resp_list)]) else: @@ -47,7 +47,7 @@ class BatchMessage(object): # JSON RPC v2.0 client class JsonRpcClient(object): - def __init__ (self, default_server, default_port): + def __init__ (self, default_server, default_port, prn_func = None): self.verbose = False self.connected = False @@ -56,6 +56,8 @@ class JsonRpcClient(object): self.server = default_server self.id_gen = general_utils.random_id_gen() + self.prn_func = prn_func + def get_connection_details (self): rc = {} rc['server'] = self.server @@ -112,7 +114,7 @@ class JsonRpcClient(object): def invoke_rpc_method (self, method_name, params = {}): if not self.connected: - return False, "Not connected to server" + return CmdResponse(False, "Not connected to server") id, msg = self.create_jsonrpc_v2(method_name, params) @@ -130,11 +132,10 @@ class JsonRpcClient(object): self.socket.send(msg) break except zmq.Again: - sleep(0.1) tries += 1 if tries > 10: self.disconnect() - return CmdResponse(False, "Failed to send message to server") + return CmdResponse(False, "*** [RPC] - Failed to send message to server") tries = 0 @@ -143,11 +144,10 @@ class JsonRpcClient(object): response = self.socket.recv() break except zmq.Again: - sleep(0.1) tries += 1 if tries > 10: self.disconnect() - return CmdResponse(False, "Failed to get server response") + return CmdResponse(False, "*** [RPC] - Failed to get server response") self.verbose_msg("Server Response:\n\n" + self.pretty_json(response) + "\n") @@ -174,7 +174,7 @@ class JsonRpcClient(object): def process_single_response (self, response_json): if (response_json.get("jsonrpc") != "2.0"): - return False, "Malfromed Response ({0})".format(str(response)) + return False, "Malformed Response ({0})".format(str(response_json)) # error reported by server if ("error" in response_json): @@ -185,7 +185,7 @@ class JsonRpcClient(object): # if no error there should be a result if ("result" not in response_json): - return False, "Malformed Response ({0})".format(str(response)) + return False, "Malformed Response ({0})".format(str(response_json)) return True, response_json["result"] @@ -203,7 +203,8 @@ class JsonRpcClient(object): else: return False, "Not connected to server" - def connect(self, server=None, port=None): + + def connect(self, server = None, port = None, prn_func = None): if self.connected: self.disconnect() @@ -215,7 +216,11 @@ class JsonRpcClient(object): # Socket to talk to server self.transport = "tcp://{0}:{1}".format(self.server, self.port) - print "\nConnecting To RPC Server On {0}".format(self.transport) + msg = "\nConnecting To RPC Server On {0}".format(self.transport) + if self.prn_func: + self.prn_func(msg) + else: + print msg self.socket = self.context.socket(zmq.REQ) try: @@ -223,8 +228,8 @@ class JsonRpcClient(object): except zmq.error.ZMQError as e: return False, "ZMQ Error: Bad server or port name: " + str(e) - self.socket.setsockopt(zmq.SNDTIMEO, 5) - self.socket.setsockopt(zmq.RCVTIMEO, 5) + self.socket.setsockopt(zmq.SNDTIMEO, 1000) + self.socket.setsockopt(zmq.RCVTIMEO, 1000) self.connected = True diff --git a/scripts/automation/trex_control_plane/console/parsing_opts.py b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py index d7bf583a..6f9b4c6d 100755 --- a/scripts/automation/trex_control_plane/console/parsing_opts.py +++ b/scripts/automation/trex_control_plane/client_utils/parsing_opts.py @@ -20,7 +20,14 @@ SERVER_IP = 8 STREAM_FROM_PATH_OR_FILE = 9 DURATION = 10 FORCE = 11 -TOTAL = 12 +DRY_RUN = 12 +XTERM = 13 +TOTAL = 14 + +GLOBAL_STATS = 50 +PORT_STATS = 51 +PORT_STATUS = 52 +STATS_MASK = 53 # list of ArgumentGroup types MUTEX = 1 @@ -198,13 +205,43 @@ OPTIONS_DB = {MULTIPLIER: ArgumentPack(['-m', '--multiplier'], {'metavar': 'SERVER', 'help': "server IP"}), + DRY_RUN: ArgumentPack(['-n', '--dry'], + {'action': 'store_true', + 'dest': 'dry', + 'default': False, + 'help': "Dry run - no traffic will be injected"}), + + + XTERM: ArgumentPack(['-x', '--xterm'], + {'action': 'store_true', + 'dest': 'xterm', + 'default': False, + 'help': "Starts TUI in xterm window"}), + + GLOBAL_STATS: ArgumentPack(['-g'], + {'action': 'store_true', + 'help': "Fetch only global statistics"}), + + PORT_STATS: ArgumentPack(['-p'], + {'action': 'store_true', + 'help': "Fetch only port statistics"}), + + PORT_STATUS: ArgumentPack(['--ps'], + {'action': 'store_true', + 'help': "Fetch only port status data"}), + + # advanced options PORT_LIST_WITH_ALL: ArgumentGroup(MUTEX, [PORT_LIST, ALL_PORTS], {'required': True}), STREAM_FROM_PATH_OR_FILE: ArgumentGroup(MUTEX, [FILE_PATH, FILE_FROM_DB], - {'required': True}) + {'required': True}), + STATS_MASK: ArgumentGroup(MUTEX, [GLOBAL_STATS, + PORT_STATS, + PORT_STATUS], + {}) } diff --git a/scripts/automation/trex_control_plane/client_utils/text_tables.py b/scripts/automation/trex_control_plane/client_utils/text_tables.py new file mode 100644 index 00000000..2debca38 --- /dev/null +++ b/scripts/automation/trex_control_plane/client_utils/text_tables.py @@ -0,0 +1,34 @@ + +import external_packages +from texttable import Texttable +from common.text_opts import format_text + +class TRexTextTable(Texttable): + + def __init__(self): + Texttable.__init__(self) + # set class attributes so that it'll be more like TRex standard output + self.set_chars(['-', '|', '-', '-']) + self.set_deco(Texttable.HEADER | Texttable.VLINES) + +class TRexTextInfo(Texttable): + + def __init__(self): + Texttable.__init__(self) + # set class attributes so that it'll be more like TRex standard output + self.set_chars(['-', ':', '-', '-']) + self.set_deco(Texttable.VLINES) + +def generate_trex_stats_table(): + pass + +def print_table_with_header(texttable_obj, header=""): + header = header.replace("_", " ").title() + print format_text(header, 'cyan', 'underline') + "\n" + print texttable_obj.draw() + "\n" + + pass + +if __name__ == "__main__": + pass + diff --git a/scripts/automation/trex_control_plane/common/text_opts.py b/scripts/automation/trex_control_plane/common/text_opts.py index 06c2c056..5a86149c 100755 --- a/scripts/automation/trex_control_plane/common/text_opts.py +++ b/scripts/automation/trex_control_plane/common/text_opts.py @@ -19,6 +19,50 @@ TEXT_CODES = {'bold': {'start': '\x1b[1m', 'end': '\x1b[24m'}} +def format_num (size, suffix = ""): + for unit in ['','K','M','G','T','P']: + if abs(size) < 1000.0: + return "%3.2f %s%s" % (size, unit, suffix) + size /= 1000.0 + + return "NaN" + +def format_time (t_sec): + if t_sec < 0: + return "infinite" + + if t_sec < 1: + # low numbers + for unit in ['ms', 'usec', 'ns']: + t_sec *= 1000.0 + if t_sec >= 1.0: + return '{:,.2f} [{:}]'.format(t_sec, unit) + + return "NaN" + + else: + # seconds + if t_sec < 60.0: + return '{:,.2f} [{:}]'.format(t_sec, 'sec') + + # minutes + t_sec /= 60.0 + if t_sec < 60.0: + return '{:,.2f} [{:}]'.format(t_sec, 'minutes') + + # hours + t_sec /= 60.0 + if t_sec < 24.0: + return '{:,.2f} [{:}]'.format(t_sec, 'hours') + + # days + t_sec /= 24.0 + return '{:,.2f} [{:}]'.format(t_sec, 'days') + + +def format_percentage (size): + return "%0.2f %%" % (size) + def bold(text): return text_attribute(text, 'bold') diff --git a/scripts/automation/trex_control_plane/common/trex_stats.py b/scripts/automation/trex_control_plane/common/trex_stats.py index b7e768c1..20255f41 100755 --- a/scripts/automation/trex_control_plane/common/trex_stats.py +++ b/scripts/automation/trex_control_plane/common/trex_stats.py @@ -1,59 +1,305 @@ #!/router/bin/python +from collections import namedtuple, OrderedDict +from client_utils import text_tables +from common.text_opts import format_text +from client.trex_async_client import CTRexAsyncStats import copy +import datetime +import time +import re +GLOBAL_STATS = 'g' +PORT_STATS = 'p' +PORT_STATUS = 'ps' +ALL_STATS_OPTS = {GLOBAL_STATS, PORT_STATS, PORT_STATUS} +COMPACT = {GLOBAL_STATS, PORT_STATS} -class CTRexStatsManager(object): +ExportableStats = namedtuple('ExportableStats', ['raw_data', 'text_table']) - def __init__(self, *args): - for stat_type in args: - # register stat handler for each stats type - setattr(self, stat_type, CTRexStatsManager.CSingleStatsHandler()) - def __getitem__(self, item): - stats_obj = getattr(self, item) - if stats_obj: - return stats_obj.get_stats() +class CTRexStatsGenerator(object): + """ + This object is responsible of generating stats from objects maintained at + CTRexStatelessClient and the ports. + """ + + def __init__(self, global_stats_ref, ports_dict_ref): + self._global_stats = global_stats_ref + self._ports_dict = ports_dict_ref + + def generate_single_statistic(self, port_id_list, statistic_type): + if statistic_type == GLOBAL_STATS: + return self._generate_global_stats() + elif statistic_type == PORT_STATS: + return self._generate_port_stats(port_id_list) + pass + elif statistic_type == PORT_STATUS: + return self._generate_port_status(port_id_list) else: - return None + # ignore by returning empty object + return {} - class CSingleStatsHandler(object): + def _generate_global_stats(self): + # stats_obj = self._async_stats.get_general_stats() + stats_data = self._global_stats.generate_stats() - def __init__(self): - self._stats = {} + # build table representation + stats_table = text_tables.TRexTextInfo() + stats_table.set_cols_align(["l", "l"]) + stats_table.add_rows([[k.replace("_", " ").title(), v] + for k, v in stats_data.iteritems()], + header=False) + + return {"global_statistics": ExportableStats(stats_data, stats_table)} + + def _generate_port_stats(self, port_id_list): + relevant_ports = self.__get_relevant_ports(port_id_list) + + return_stats_data = {} + per_field_stats = OrderedDict([("owner", []), + ("state", []), + ("--", []), + ("opackets", []), + ("obytes", []), + ("ipackets", []), + ("ibytes", []), + ("ierrors", []), + ("oerrors", []), + ("tx-bytes", []), + ("rx-bytes", []), + ("tx-pkts", []), + ("rx-pkts", []), + ("---", []), + ("Tx bps", []), + ("Rx bps", []), + ("----", []), + ("Tx pps", []), + ("Rx pps", []) + ] + ) + + for port_obj in relevant_ports: + # fetch port data + port_stats = port_obj.generate_port_stats() + + # populate to data structures + return_stats_data[port_obj.port_id] = port_stats + self.__update_per_field_dict(port_stats, per_field_stats) + + stats_table = text_tables.TRexTextTable() + stats_table.set_cols_align(["l"] + ["r"]*len(relevant_ports)) + stats_table.set_cols_width([10] + [20] * len(relevant_ports)) + stats_table.set_cols_dtype(['t'] + ['t'] * len(relevant_ports)) + + stats_table.add_rows([[k] + v + for k, v in per_field_stats.iteritems()], + header=False) + stats_table.header(["port"] + [port.port_id + for port in relevant_ports]) + + return {"port_statistics": ExportableStats(return_stats_data, stats_table)} + + def _generate_port_status(self, port_id_list): + relevant_ports = self.__get_relevant_ports(port_id_list) + + return_stats_data = {} + per_field_status = OrderedDict([("port-type", []), + ("maximum", []), + ("port-status", []) + ] + ) + + for port_obj in relevant_ports: + # fetch port data + # port_stats = self._async_stats.get_port_stats(port_obj.port_id) + port_status = port_obj.generate_port_status() + + # populate to data structures + return_stats_data[port_obj.port_id] = port_status + + self.__update_per_field_dict(port_status, per_field_status) + + stats_table = text_tables.TRexTextTable() + stats_table.set_cols_align(["l"] + ["c"]*len(relevant_ports)) + stats_table.set_cols_width([10] + [20] * len(relevant_ports)) + + stats_table.add_rows([[k] + v + for k, v in per_field_status.iteritems()], + header=False) + stats_table.header(["port"] + [port.port_id + for port in relevant_ports]) + + return {"port_status": ExportableStats(return_stats_data, stats_table)} + + def __get_relevant_ports(self, port_id_list): + # fetch owned ports + ports = [port_obj + for _, port_obj in self._ports_dict.iteritems() + if port_obj.port_id in port_id_list] + + # display only the first FOUR options, by design + if len(ports) > 4: + print format_text("[WARNING]: ", 'magenta', 'bold'), format_text("displaying up to 4 ports", 'magenta') + ports = ports[:4] + return ports + + def __update_per_field_dict(self, dict_src_data, dict_dest_ref): + for key, val in dict_src_data.iteritems(): + if key in dict_dest_ref: + dict_dest_ref[key].append(val) - def update(self, obj_id, stats_obj): - assert isinstance(stats_obj, CTRexStats) - self._stats[obj_id] = stats_obj - def get_stats(self, obj_id=None): - if obj_id: - return copy.copy(self._stats.pop(obj_id)) - else: - return copy.copy(self._stats) class CTRexStats(object): - def __init__(self, **kwargs): - for k, v in kwargs.items(): - setattr(self, k, v) + """ This is an abstract class to represent a stats object """ + + def __init__(self): + self.reference_stats = None + self.latest_stats = {} + self.last_update_ts = time.time() + + + def __getitem__(self, item): + # override this to allow quick and clean access to fields + if not item in self.latest_stats: + return "N/A" + + # item must exist + m = re.search('_(([a-z])ps)$', item) + if m: + # this is a non-relative item + unit = m.group(2) + if unit == "b": + return self.get(item, format=True, suffix="b/sec") + elif unit == "p": + return self.get(item, format=True, suffix="pkt/sec") + else: + return self.get(item, format=True, suffix=m.group(1)) + + m = re.search('^[i|o](a-z+)$', item) + if m: + # this is a non-relative item + type = m.group(1) + if type == "bytes": + return self.get_rel(item, format=True, suffix="B") + elif type == "packets": + return self.get_rel(item, format=True, suffix="pkts") + else: + # do not format with suffix + return self.get_rel(item, format=True) + + # can't match to any known pattern, return N/A + return "N/A" + + @staticmethod + def format_num(size, suffix = ""): + if type(size) == str: + return "N/A" + + for unit in ['','K','M','G','T','P']: + if abs(size) < 1000.0: + return "%3.2f %s%s" % (size, unit, suffix) + size /= 1000.0 + return "NaN" + + def generate_stats(self): + # must be implemented by designated classes (such as port/ global stats) + raise NotImplementedError() + + def update(self, snapshot): + # update + self.latest_stats = snapshot + + diff_time = time.time() - self.last_update_ts + + # 3 seconds is too much - this is the new reference + if (self.reference_stats == None) or (diff_time > 3): + self.reference_stats = self.latest_stats + + self.last_update_ts = time.time() + + def clear_stats(self): + self.reference_stats = self.latest_stats + + def invalidate (self): + self.latest_stats = {} + + def get(self, field, format=False, suffix=""): + if not field in self.latest_stats: + return "N/A" + if not format: + return self.latest_stats[field] + else: + return self.format_num(self.latest_stats[field], suffix) + + def get_rel(self, field, format=False, suffix=""): + if not field in self.latest_stats: + return "N/A" + + if not format: + return (self.latest_stats[field] - self.reference_stats[field]) + else: + return self.format_num(self.latest_stats[field] - self.reference_stats[field], suffix) class CGlobalStats(CTRexStats): - def __init__(self, **kwargs): - super(CGlobalStats, self).__init__(kwargs) - pass + pass + + def __init__(self, connection_info, server_version, ports_dict_ref): + super(CGlobalStats, self).__init__() + self.connection_info = connection_info + self.server_version = server_version + self._ports_dict = ports_dict_ref + def generate_stats(self): + return OrderedDict([("connection", "{host}, Port {port}".format(host=self.connection_info.get("server"), + port=self.connection_info.get("sync_port"))), + ("version", "{ver}, UUID: {uuid}".format(ver=self.server_version.get("version", "N/A"), + uuid="N/A")), + ("cpu_util", "{0}%".format(self.get("m_cpu_util"))), + ("total_tx", self.get("m_tx_bps", format=True, suffix="b/sec")), + ("total_rx", self.get("m_rx_bps", format=True, suffix="b/sec")), + ("total_pps", self.format_num(self.get("m_tx_pps") + self.get("m_rx_pps"), + suffix="pkt/sec")), + ("total_streams", sum([len(port_obj.streams) + for _, port_obj in self._ports_dict.iteritems()])), + ("active_ports", sum([port_obj.is_active() + for _, port_obj in self._ports_dict.iteritems()])) + ] + ) class CPortStats(CTRexStats): - def __init__(self, **kwargs): - super(CPortStats, self).__init__(kwargs) - pass + pass + + def __init__(self, port_obj): + super(CPortStats, self).__init__() + self._port_obj = port_obj + + def generate_stats(self): + return {"owner": self._port_obj.user, + "state": self._port_obj.get_port_state_name(), + "--": "", + "opackets" : self.get_rel("opackets"), + "obytes" : self.get_rel("obytes"), + "ipackets" : self.get_rel("ipackets"), + "ibytes" : self.get_rel("ibytes"), + "ierrors" : self.get_rel("ierrors"), + "oerrors" : self.get_rel("oerrors"), + + "tx-bytes": self.get_rel("obytes", format = True, suffix = "B"), + "rx-bytes": self.get_rel("ibytes", format = True, suffix = "B"), + "tx-pkts": self.get_rel("opackets", format = True, suffix = "pkts"), + "rx-pkts": self.get_rel("ipackets", format = True, suffix = "pkts"), + "---": "", + "Tx bps": self.get("m_total_tx_bps", format = True, suffix = "bps"), + "Rx bps": self.get("m_total_rx_bps", format = True, suffix = "bps"), + "----": "", + "Tx pps": self.get("m_total_tx_pps", format = True, suffix = "pps"), + "Rx pps": self.get("m_total_rx_pps", format = True, suffix = "pps"), + } -class CStreamStats(CTRexStats): - def __init__(self, **kwargs): - super(CStreamStats, self).__init__(kwargs) - pass if __name__ == "__main__": diff --git a/scripts/automation/trex_control_plane/common/trex_streams.py b/scripts/automation/trex_control_plane/common/trex_streams.py index bb4c72ca..86eee1f4 100755 --- a/scripts/automation/trex_control_plane/common/trex_streams.py +++ b/scripts/automation/trex_control_plane/common/trex_streams.py @@ -10,18 +10,31 @@ import copy import os StreamPack = namedtuple('StreamPack', ['stream_id', 'stream']) +LoadedStreamList = namedtuple('LoadedStreamList', ['loaded', 'compiled']) class CStreamList(object): def __init__(self): - self.streams_list = {} + self.streams_list = OrderedDict() self.yaml_loader = CTRexYAMLLoader(os.path.join(os.path.dirname(os.path.realpath(__file__)), "rpc_defaults.yaml")) + def generate_numbered_name (self, name): + prefix = name.rstrip('01234567890') + suffix = name[len(prefix):] + if suffix == "": + n = "_1" + else: + n = int(suffix) + 1 + return prefix + str(n) + def append_stream(self, name, stream_obj): assert isinstance(stream_obj, CStream) - if name in self.streams_list: - raise NameError("A stream with this name already exists on this list.") + + # if name exists simply add numbered suffix to it + while name in self.streams_list: + name = self.generate_numbered_name(name) + self.streams_list[name]=stream_obj return name @@ -70,6 +83,7 @@ class CStreamList(object): stream_ids = {} for idx, stream_name in enumerate(self.streams_list): stream_ids[stream_name] = idx + # next, iterate over the streams and transform them from working with names to ids. # with that build a new dict with old stream_name as the key, and StreamPack as the stored value compiled_streams = {} @@ -241,5 +255,61 @@ class CStream(object): raise RuntimeError("CStream object isn't loaded with data. Use 'load_data' method.") -if __name__ == "__main__": - pass + +# describes a stream DB +class CStreamsDB(object): + + def __init__(self): + self.stream_packs = {} + + def load_yaml_file(self, filename): + + stream_pack_name = filename + if stream_pack_name in self.get_loaded_streams_names(): + self.remove_stream_packs(stream_pack_name) + + stream_list = CStreamList() + loaded_obj = stream_list.load_yaml(filename) + + try: + compiled_streams = stream_list.compile_streams() + rc = self.load_streams(stream_pack_name, + LoadedStreamList(loaded_obj, + [StreamPack(v.stream_id, v.stream.dump()) + for k, v in compiled_streams.items()])) + + except Exception as e: + return None + + return self.get_stream_pack(stream_pack_name) + + def load_streams(self, name, LoadedStreamList_obj): + if name in self.stream_packs: + return False + else: + self.stream_packs[name] = LoadedStreamList_obj + return True + + def remove_stream_packs(self, *names): + removed_streams = [] + for name in names: + removed = self.stream_packs.pop(name) + if removed: + removed_streams.append(name) + return removed_streams + + def clear(self): + self.stream_packs.clear() + + def get_loaded_streams_names(self): + return self.stream_packs.keys() + + def stream_pack_exists (self, name): + return name in self.get_loaded_streams_names() + + def get_stream_pack(self, name): + if not self.stream_pack_exists(name): + return None + else: + return self.stream_packs.get(name) + diff --git a/scripts/automation/trex_control_plane/common/trex_types.py b/scripts/automation/trex_control_plane/common/trex_types.py new file mode 100644 index 00000000..3de36e4c --- /dev/null +++ b/scripts/automation/trex_control_plane/common/trex_types.py @@ -0,0 +1,66 @@ + +from collections import namedtuple +from common.text_opts import * + +RpcCmdData = namedtuple('RpcCmdData', ['method', 'params']) + +class RpcResponseStatus(namedtuple('RpcResponseStatus', ['success', 'id', 'msg'])): + __slots__ = () + def __str__(self): + return "{id:^3} - {msg} ({stat})".format(id=self.id, + msg=self.msg, + stat="success" if self.success else "fail") + +# simple class to represent complex return value +class RC(): + + def __init__ (self, rc = None, data = None): + self.rc_list = [] + + if (rc != None) and (data != None): + tuple_rc = namedtuple('RC', ['rc', 'data']) + self.rc_list.append(tuple_rc(rc, data)) + + def add (self, rc): + self.rc_list += rc.rc_list + + def good (self): + return all([x.rc for x in self.rc_list]) + + def bad (self): + return not self.good() + + def data (self): + return [x.data if x.rc else "" for x in self.rc_list] + + def err (self): + return [x.data if not x.rc else "" for x in self.rc_list] + + def annotate (self, desc = None, show_status = True): + if desc: + print format_text('\n{:<60}'.format(desc), 'bold'), + else: + print "" + + if self.bad(): + # print all the errors + print "" + for x in self.rc_list: + if not x.rc: + print format_text("\n{0}".format(x.data), 'bold') + + print "" + if show_status: + print format_text("[FAILED]\n", 'red', 'bold') + + + else: + if show_status: + print format_text("[SUCCESS]\n", 'green', 'bold') + + +def RC_OK(data = ""): + return RC(True, data) +def RC_ERR (err): + return RC(False, err) + diff --git a/scripts/automation/trex_control_plane/console/old_console.py b/scripts/automation/trex_control_plane/console/old_console.py deleted file mode 100644 index 9d61a3a6..00000000 --- a/scripts/automation/trex_control_plane/console/old_console.py +++ /dev/null @@ -1,958 +0,0 @@ - -# main console object -class TRexConsole1(cmd.Cmd): - """Trex Console""" - - def __init__(self, stateless_client, verbose): - cmd.Cmd.__init__(self) - - self.stateless_client = stateless_client - - self.do_connect("") - - self.intro = "\n-=TRex Console v{ver}=-\n".format(ver=__version__) - self.intro += "\nType 'help' or '?' for supported actions\n" - - self.verbose = False - self._silent = True - - self.postcmd(False, "") - - self.user_streams = {} - self.streams_db = CStreamsDB() - - - # a cool hack - i stole this function and added space - def completenames(self, text, *ignored): - dotext = 'do_'+text - return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)] - - - # set verbose on / off - def do_verbose(self, line): - '''Shows or set verbose mode\n''' - if line == "": - print "\nverbose is " + ("on\n" if self.verbose else "off\n") - - elif line == "on": - self.verbose = True - self.stateless_client.set_verbose(True) - print green("\nverbose set to on\n") - - elif line == "off": - self.verbose = False - self.stateless_client.set_verbose(False) - print green("\nverbose set to off\n") - - else: - print magenta("\nplease specify 'on' or 'off'\n") - - # query the server for registered commands - def do_query_server(self, line): - '''query the RPC server for supported remote commands\n''' - - res_ok, msg = self.stateless_client.get_supported_cmds() - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print "\nRPC server supports the following commands:\n" - for func in msg: - if func: - print func - print '' - print format_text("[SUCCESS]\n", 'green', 'bold') - return - - def do_ping(self, line): - '''Pings the RPC server\n''' - - print "\n-> Pinging RPC server" - - res_ok, msg = self.stateless_client.ping() - if res_ok: - print format_text("[SUCCESS]\n", 'green', 'bold') - else: - print "\n*** " + msg + "\n" - return - - def do_force_acquire(self, line): - '''Acquires ports by force\n''' - - self.do_acquire(line, True) - - def complete_force_acquire(self, text, line, begidx, endidx): - return self.port_auto_complete(text, line, begidx, endidx, acquired=False) - - def extract_port_ids_from_line(self, line): - return {int(x) for x in line.split()} - - def extract_port_ids_from_list(self, port_list): - return {int(x) for x in port_list} - - def parse_ports_from_line (self, line): - port_list = set() - if line: - for port_id in line.split(' '): - if (not port_id.isdigit()) or (int(port_id) < 0) or (int(port_id) >= self.stateless_client.get_port_count()): - print "Please provide a list of ports separated by spaces between 0 and {0}".format(self.stateless_client.get_port_count() - 1) - return None - - port_list.add(int(port_id)) - - port_list = list(port_list) - - else: - port_list = [i for i in xrange(0, self.stateless_client.get_port_count())] - - return port_list - - - def do_acquire(self, line, force=False): - '''Acquire ports\n''' - - # make sure that the user wants to acquire all - args = line.split() - if len(args) < 1: - print magenta("Please provide a list of ports separated by spaces, or specify 'all' to acquire all available ports") - return - - if args[0] == "all": - ask = ConfirmMenu('Are you sure you want to acquire all ports ? ') - rc = ask.show() - if rc == False: - print yellow("[ABORTED]\n") - return - else: - port_list = self.stateless_client.get_port_ids() - else: - port_list = self.extract_port_ids_from_line(line) - - # rc, resp_list = self.stateless_client.take_ownership(port_list, force) - try: - res_ok, log = self.stateless_client.acquire(port_list, force) - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - except ValueError as e: - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - - - def port_auto_complete(self, text, line, begidx, endidx, acquired=True, active=False): - if acquired: - if not active: - ret_list = [x - for x in map(str, self.stateless_client.get_acquired_ports()) - if x.startswith(text)] - else: - ret_list = [x - for x in map(str, self.stateless_client.get_active_ports()) - if x.startswith(text)] - else: - ret_list = [x - for x in map(str, self.stateless_client.get_port_ids()) - if x.startswith(text)] - ret_list.append("all") - return ret_list - - - def complete_acquire(self, text, line, begidx, endidx): - return self.port_auto_complete(text, line, begidx, endidx, acquired=False) - - def do_release (self, line): - '''Release ports\n''' - - # if line: - # port_list = self.parse_ports_from_line(line) - # else: - # port_list = self.stateless_client.get_owned_ports() - args = line.split() - if len(args) < 1: - print "Please provide a list of ports separated by spaces, or specify 'all' to acquire all available ports" - if args[0] == "all": - ask = ConfirmMenu('Are you sure you want to release all acquired ports? ') - rc = ask.show() - if rc == False: - print yellow("[ABORTED]\n") - return - else: - port_list = self.stateless_client.get_acquired_ports() - else: - port_list = self.extract_port_ids_from_line(line) - - try: - res_ok, log = self.stateless_client.release(port_list) - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - except ValueError as e: - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - return - - def complete_release(self, text, line, begidx, endidx): - return self.port_auto_complete(text, line, begidx, endidx) - - def do_connect (self, line): - '''Connects to the server\n''' - - if line == "": - res_ok, msg = self.stateless_client.connect() - else: - sp = line.split() - if (len(sp) != 2): - print "\n[usage] connect [server] [port] or without parameters\n" - return - - res_ok, msg = self.stateless_client.connect(sp[0], sp[1]) - - if res_ok: - print format_text("[SUCCESS]\n", 'green', 'bold') - else: - print "\n*** " + msg + "\n" - print format_text("[FAILED]\n", 'red', 'bold') - return - - self.supported_rpc = self.stateless_client.get_supported_cmds().data - - # def do_rpc (self, line): - # '''Launches a RPC on the server\n''' - # - # if line == "": - # print "\nUsage: [method name] [param dict as string]\n" - # print "Example: rpc test_add {'x': 12, 'y': 17}\n" - # return - # - # sp = line.split(' ', 1) - # method = sp[0] - # - # params = None - # bad_parse = False - # if len(sp) > 1: - # - # try: - # params = ast.literal_eval(sp[1]) - # if not isinstance(params, dict): - # bad_parse = True - # - # except ValueError as e1: - # bad_parse = True - # except SyntaxError as e2: - # bad_parse = True - # - # if bad_parse: - # print "\nValue should be a valid dict: '{0}'".format(sp[1]) - # print "\nUsage: [method name] [param dict as string]\n" - # print "Example: rpc test_add {'x': 12, 'y': 17}\n" - # return - # - # res_ok, msg = self.stateless_client.transmit(method, params) - # if res_ok: - # print "\nServer Response:\n\n" + pretty_json(json.dumps(msg)) + "\n" - # else: - # print "\n*** " + msg + "\n" - # #print "Please try 'reconnect' to reconnect to server" - # - # - # def complete_rpc (self, text, line, begidx, endidx): - # return [x - # for x in self.supported_rpc - # if x.startswith(text)] - - def do_status (self, line): - '''Shows a graphical console\n''' - - if not self.stateless_client.is_connected(): - print "Not connected to server\n" - return - - self.do_verbose('off') - trex_status.show_trex_status(self.stateless_client) - - def do_quit(self, line): - '''Exit the client\n''' - return True - - def do_disconnect (self, line): - '''Disconnect from the server\n''' - if not self.stateless_client.is_connected(): - print "Not connected to server\n" - return - - res_ok, msg = self.stateless_client.disconnect() - if res_ok: - print format_text("[SUCCESS]\n", 'green', 'bold') - else: - print msg + "\n" - - def do_whoami (self, line): - '''Prints console user name\n''' - print "\n" + self.stateless_client.user + "\n" - - def postcmd(self, stop, line): - if self.stateless_client.is_connected(): - self.prompt = "TRex > " - else: - self.supported_rpc = None - self.prompt = "TRex (offline) > " - - return stop - - def default(self, line): - print "'{0}' is an unrecognized command. type 'help' or '?' for a list\n".format(line) - - # def do_help (self, line): - # '''Shows This Help Screen\n''' - # if line: - # try: - # func = getattr(self, 'help_' + line) - # except AttributeError: - # try: - # doc = getattr(self, 'do_' + line).__doc__ - # if doc: - # self.stdout.write("%s\n"%str(doc)) - # return - # except AttributeError: - # pass - # self.stdout.write("%s\n"%str(self.nohelp % (line,))) - # return - # func() - # return - # - # print "\nSupported Console Commands:" - # print "----------------------------\n" - # - # cmds = [x[3:] for x in self.get_names() if x.startswith("do_")] - # for cmd in cmds: - # if cmd == "EOF": - # continue - # - # try: - # doc = getattr(self, 'do_' + cmd).__doc__ - # if doc: - # help = str(doc) - # else: - # help = "*** Undocumented Function ***\n" - # except AttributeError: - # help = "*** Undocumented Function ***\n" - # - # print "{:<30} {:<30}".format(cmd + " - ", help) - - def do_stream_db_add(self, line): - '''Loads a YAML stream list serialization into user console \n''' - args = line.split() - if len(args) >= 2: - name = args[0] - yaml_path = args[1] - try: - multiplier = args[2] - except IndexError: - multiplier = 1 - stream_list = CStreamList() - loaded_obj = stream_list.load_yaml(yaml_path, multiplier) - # print self.stateless_client.pretty_json(json.dumps(loaded_obj)) - try: - compiled_streams = stream_list.compile_streams() - res_ok = self.streams_db.load_streams(name, LoadedStreamList(loaded_obj, - [StreamPack(v.stream_id, v.stream.dump()) - for k, v in compiled_streams.items()])) - if res_ok: - print green("Stream pack '{0}' loaded and added successfully\n".format(name)) - else: - print magenta("Picked name already exist. Please pick another name.\n") - except Exception as e: - print "adding new stream failed due to the following error:\n", str(e) - print format_text("[FAILED]\n", 'red', 'bold') - - return - else: - print magenta("please provide load name and YAML path, separated by space.\n" - "Optionally, you may provide a third argument to specify multiplier.\n") - - @staticmethod - def tree_autocomplete(text): - dir = os.path.dirname(text) - if dir: - path = dir - else: - path = "." - start_string = os.path.basename(text) - return [x - for x in os.listdir(path) - if x.startswith(start_string)] - - - def complete_stream_db_add(self, text, line, begidx, endidx): - arg_num = len(line.split()) - 1 - if arg_num == 2: - return TRexConsole.tree_autocomplete(line.split()[-1]) - else: - return [text] - - def do_stream_db_show(self, line): - '''Shows the loaded stream list named [name] \n''' - args = line.split() - if args: - list_name = args[0] - try: - stream = self.streams_db.get_stream_pack(list_name)#user_streams[list_name] - if len(args) >= 2 and args[1] == "full": - print pretty_json(json.dumps(stream.compiled)) - else: - print pretty_json(json.dumps(stream.loaded)) - except KeyError as e: - print "Unknown stream list name provided" - else: - print "Available stream packs:\n{0}".format(', '.join(sorted(self.streams_db.get_loaded_streams_names()))) - - def complete_stream_db_show(self, text, line, begidx, endidx): - return [x - for x in self.streams_db.get_loaded_streams_names() - if x.startswith(text)] - - def do_stream_db_remove(self, line): - '''Removes a single loaded stream packs from loaded stream pack repository\n''' - args = line.split() - if args: - removed_streams = self.streams_db.remove_stream_packs(*args) - if removed_streams: - print green("The following stream packs were removed:") - print bold(", ".join(sorted(removed_streams))) - print format_text("[SUCCESS]\n", 'green', 'bold') - else: - print red("No streams were removed. Make sure to provide valid stream pack names.") - else: - print magenta("Please provide stream pack name(s), separated with spaces.") - - def do_stream_db_clear(self, line): - '''Clears all loaded stream packs from loaded stream pack repository\n''' - self.streams_db.clear() - print format_text("[SUCCESS]\n", 'green', 'bold') - - - def complete_stream_db_remove(self, text, line, begidx, endidx): - return [x - for x in self.streams_db.get_loaded_streams_names() - if x.startswith(text)] - - - def do_attach(self, line): - '''Assign loaded stream pack into specified ports on TRex\n''' - args = line.split() - if len(args) >= 2: - stream_pack_name = args[0] - stream_list = self.streams_db.get_stream_pack(stream_pack_name) #user_streams[args[0]] - if not stream_list: - print "Provided stream list name '{0}' doesn't exists.".format(stream_pack_name) - print format_text("[FAILED]\n", 'red', 'bold') - return - if args[1] == "all": - ask = ConfirmMenu('Are you sure you want to release all acquired ports? ') - rc = ask.show() - if rc == False: - print yellow("[ABORTED]\n") - return - else: - port_list = self.stateless_client.get_acquired_ports() - else: - port_list = self.extract_port_ids_from_line(' '.join(args[1:])) - owned = set(self.stateless_client.get_acquired_ports()) - try: - if set(port_list).issubset(owned): - res_ok, log = self.stateless_client.add_stream_pack(stream_list.compiled, port_id=port_list) - # res_ok, msg = self.stateless_client.add_stream(port_list, stream_list.compiled) - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - return - else: - print "Not all desired ports are acquired.\n" \ - "Acquired ports are: {acq}\n" \ - "Requested ports: {req}\n" \ - "Missing ports: {miss}".format(acq=list(owned), - req=port_list, - miss=list(set(port_list).difference(owned))) - print format_text("[FAILED]\n", 'red', 'bold') - except ValueError as e: - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - else: - print magenta("Please provide list name and ports to attach to, " - "or specify 'all' to attach all owned ports.\n") - - def complete_attach(self, text, line, begidx, endidx): - arg_num = len(line.split()) - 1 - if arg_num == 1: - # return optional streams packs - if line.endswith(" "): - return self.port_auto_complete(text, line, begidx, endidx) - return [x - for x in self.streams_db.get_loaded_streams_names() - if x.startswith(text)] - elif arg_num >= 2: - # return optional ports to attach to - return self.port_auto_complete(text, line, begidx, endidx) - else: - return [text] - - def prompt_response(self, response_obj): - resp_list = response_obj if isinstance(response_obj, list) else [response_obj] - def format_return_status(return_status): - if return_status: - return green("OK") - else: - return red("FAIL") - - for response in resp_list: - response_str = "{id:^3} - {msg} ({stat})".format(id=response.id, - msg=response.msg, - stat=format_return_status(response.success)) - print response_str - return - - def do_remove_all_streams(self, line): - '''Acquire ports\n''' - - # make sure that the user wants to acquire all - args = line.split() - if len(args) < 1: - print magenta("Please provide a list of ports separated by spaces, " - "or specify 'all' to remove from all acquired ports") - return - if args[0] == "all": - ask = ConfirmMenu('Are you sure you want to remove all stream packs from all acquired ports? ') - rc = ask.show() - if rc == False: - print yellow("[ABORTED]\n") - return - else: - port_list = self.stateless_client.get_acquired_ports() - else: - port_list = self.extract_port_ids_from_line(line) - - # rc, resp_list = self.stateless_client.take_ownership(port_list, force) - try: - res_ok, log = self.stateless_client.remove_all_streams(port_list) - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - except ValueError as e: - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - - def complete_remove_all_streams(self, text, line, begidx, endidx): - return self.port_auto_complete(text, line, begidx, endidx) - - def do_start(self, line): - '''Start selected traffic in specified ports on TRex\n''' - # make sure that the user wants to acquire all - parser = parsing_opts.gen_parser("start", self.do_start.__doc__, - parsing_opts.PORT_LIST_WITH_ALL, - parsing_opts.FORCE, - parsing_opts.STREAM_FROM_PATH_OR_FILE, - parsing_opts.DURATION, - parsing_opts.MULTIPLIER) - opts = parser.parse_args(line.split()) - if opts is None: - # avoid further processing in this command - return - # print opts - port_list = self.extract_port_list(opts) - # print port_list - if opts.force: - # stop all active ports, if any - res_ok = self.stop_traffic(set(self.stateless_client.get_active_ports()).intersection(port_list)) - if not res_ok: - print yellow("[ABORTED]\n") - return - # remove all traffic from ports - res_ok = self.remove_all_streams(port_list) - if not res_ok: - print yellow("[ABORTED]\n") - return - # decide which traffic to use - stream_pack_name = None - if opts.db: - # use pre-loaded traffic - print format_text('{:<30}'.format("Load stream pack (from DB):"), 'bold'), - if opts.db not in self.streams_db.get_loaded_streams_names(): - print format_text("[FAILED]\n", 'red', 'bold') - print yellow("[ABORTED]\n") - return - else: - stream_pack_name = opts.db - else: - # try loading a YAML file - print format_text('{:<30}'.format("Load stream pack (from file):"), 'bold'), - stream_list = CStreamList() - loaded_obj = stream_list.load_yaml(opts.file[0]) - # print self.stateless_client.pretty_json(json.dumps(loaded_obj)) - try: - compiled_streams = stream_list.compile_streams() - res_ok = self.streams_db.load_streams(opts.file[1], - LoadedStreamList(loaded_obj, - [StreamPack(v.stream_id, v.stream.dump()) - for k, v in compiled_streams.items()])) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - print yellow("[ABORTED]\n") - return - print format_text("[SUCCESS]\n", 'green', 'bold') - stream_pack_name = opts.file[1] - except Exception as e: - print format_text("[FAILED]\n", 'red', 'bold') - print yellow("[ABORTED]\n") - res_ok = self.attach_to_port(stream_pack_name, port_list) - if not res_ok: - print yellow("[ABORTED]\n") - return - # finally, start the traffic - res_ok = self.start_traffic(opts.mult, port_list) - if not res_ok: - print yellow("[ABORTED]\n") - return - return - - def help_start(self): - self.do_start("-h") - - def do_stop(self, line): - '''Stop active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser("stop", self.do_stop.__doc__, - parsing_opts.PORT_LIST_WITH_ALL) - opts = parser.parse_args(line.split()) - if opts is None: - # avoid further processing in this command - return - port_list = self.extract_port_list(opts) - res_ok = self.stop_traffic(port_list) - return - - def do_pause(self, line): - '''Pause active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser("stop", self.do_stop.__doc__, - parsing_opts.PORT_LIST_WITH_ALL) - opts = parser.parse_args(line.split()) - if opts is None: - # avoid further processing in this command - return - port_list = self.extract_port_list(opts) - res_ok = self.stop_traffic(port_list) - return - - - def help_stop(self): - self.do_stop("-h") - - - def do_debug(self, line): - '''Enter DEBUG mode of the console to invoke smaller building blocks with server''' - i = DebugTRexConsole(self) - i.prompt = self.prompt[:-3] + ':' + blue('debug') + ' > ' - i.cmdloop() - - # aliasing - do_exit = do_EOF = do_q = do_quit - - # ----- utility methods ----- # - - def start_traffic(self, multiplier, port_list):#, silent=True): - print format_text('{:<30}'.format("Start traffic:"), 'bold'), - try: - res_ok, log = self.stateless_client.start_traffic(multiplier, port_id=port_list) - if not self._silent: - print '' - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return False - print format_text("[SUCCESS]\n", 'green', 'bold') - return True - except ValueError as e: - print '' - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - return False - - def attach_to_port(self, stream_pack_name, port_list): - print format_text('{:<30}'.format("Attaching traffic to ports:"), 'bold'), - stream_list = self.streams_db.get_stream_pack(stream_pack_name) #user_streams[args[0]] - if not stream_list: - print "Provided stream list name '{0}' doesn't exists.".format(stream_pack_name) - print format_text("[FAILED]\n", 'red', 'bold') - return - try: - res_ok, log = self.stateless_client.add_stream_pack(stream_list.compiled, port_id=port_list) - if not self._silent: - print '' - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return False - print format_text("[SUCCESS]\n", 'green', 'bold') - return True - except ValueError as e: - print '' - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - return False - - def stop_traffic(self, port_list): - print format_text('{:<30}'.format("Stop traffic:"), 'bold'), - try: - res_ok, log = self.stateless_client.stop_traffic(port_id=port_list) - if not self._silent: - print '' - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - return True - except ValueError as e: - print '' - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - - def remove_all_streams(self, port_list): - '''Remove all streams from given port_list''' - print format_text('{:<30}'.format("Remove all streams:"), 'bold'), - try: - res_ok, log = self.stateless_client.remove_all_streams(port_id=port_list) - if not self._silent: - print '' - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - return True - except ValueError as e: - print '' - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - - - - - - def extract_port_list(self, opts): - if opts.all_ports or "all" in opts.ports: - # handling all ports - port_list = self.stateless_client.get_acquired_ports() - else: - port_list = self.extract_port_ids_from_list(opts.ports) - return port_list - - def decode_multiplier(self, opts_mult): - pass - - -class DebugTRexConsole(cmd.Cmd): - - def __init__(self, trex_main_console): - cmd.Cmd.__init__(self) - self.trex_console = trex_main_console - self.stateless_client = self.trex_console.stateless_client - self.streams_db = self.trex_console.streams_db - self.register_main_console_methods() - self.do_silent("on") - pass - - # ----- super methods overriding ----- # - def completenames(self, text, *ignored): - dotext = 'do_'+text - return [a[3:]+' ' for a in self.get_names() if a.startswith(dotext)] - - def get_names(self): - result = cmd.Cmd.get_names(self) - result += self.trex_console.get_names() - return list(set(result)) - - def register_main_console_methods(self): - main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__))) - for name in main_names: - for prefix in 'do_', 'help_', 'complete_': - if name.startswith(prefix): - self.__dict__[name] = getattr(self.trex_console, name) - - # if (name[:3] == 'do_') or (name[:5] == 'help_') or (name[:9] == 'complete_'): - # chosen.append(name) - # self.__dict__[name] = getattr(self.trex_console, name) - # # setattr(self, name, classmethod(getattr(self.trex_console, name))) - - # print chosen - # self.get_names() - - # return result - - - # ----- DEBUGGING methods ----- # - # set silent on / off - def do_silent(self, line): - '''Shows or set silent mode\n''' - if line == "": - print "\nsilent mode is " + ("on\n" if self.trex_console._silent else "off\n") - - elif line == "on": - self.verbose = True - self.stateless_client.set_verbose(True) - print green("\nsilent set to on\n") - - elif line == "off": - self.verbose = False - self.stateless_client.set_verbose(False) - print green("\nsilent set to off\n") - - else: - print magenta("\nplease specify 'on' or 'off'\n") - - def do_quit(self, line): - '''Exit the debug client back to main console\n''' - self.do_silent("off") - return True - - def do_start_traffic(self, line): - '''Start pre-submitted traffic in specified ports on TRex\n''' - # make sure that the user wants to acquire all - parser = parsing_opts.gen_parser("start_traffic", self.do_start_traffic.__doc__, - parsing_opts.PORT_LIST_WITH_ALL, parsing_opts.MULTIPLIER) - opts = parser.parse_args(line.split()) - # print opts - # return - if opts is None: - # avoid further processing in this command - return - try: - port_list = self.trex_console.extract_port_list(opts) - return self.trex_console.start_traffic(opts.mult, port_list) - except Exception as e: - print e - return - - def do_stop_traffic(self, line): - '''Stop active traffic in specified ports on TRex\n''' - parser = parsing_opts.gen_parser("stop_traffic", self.do_stop_traffic.__doc__, - parsing_opts.PORT_LIST_WITH_ALL) - opts = parser.parse_args(line.split()) - # print opts - # return - if opts is None: - # avoid further processing in this command - return - try: - port_list = self.trex_console.extract_port_list(opts) - return self.trex_console.stop_traffic(port_list) - except Exception as e: - print e - return - - - def complete_stop_traffic(self, text, line, begidx, endidx): - return self.port_auto_complete(text, line, begidx, endidx, active=True) - - # return - # # return - # # if not opts.port_list: - # # print magenta("Please provide a list of ports separated by spaces, " - # # "or specify 'all' to start traffic on all acquired ports") - # # return - # - - - return - args = line.split() - if len(args) < 1: - print magenta("Please provide a list of ports separated by spaces, " - "or specify 'all' to start traffic on all acquired ports") - return - if args[0] == "all": - ask = ConfirmMenu('Are you sure you want to start traffic at all acquired ports? ') - rc = ask.show() - if rc == False: - print yellow("[ABORTED]\n") - return - else: - port_list = self.stateless_client.get_acquired_ports() - else: - port_list = self.extract_port_ids_from_line(line) - - try: - res_ok, log = self.stateless_client.start_traffic(1.0, port_id=port_list) - self.prompt_response(log) - if not res_ok: - print format_text("[FAILED]\n", 'red', 'bold') - return - print format_text("[SUCCESS]\n", 'green', 'bold') - except ValueError as e: - print magenta(str(e)) - print format_text("[FAILED]\n", 'red', 'bold') - - def complete_start_traffic(self, text, line, begidx, endidx): - # return self.port_auto_complete(text, line, begidx, endidx) - return [text] - - def help_start_traffic(self): - self.do_start_traffic("-h") - - def help_stop_traffic(self): - self.do_stop_traffic("-h") - - # def do_help(self): - - def do_rpc (self, line): - '''Launches a RPC on the server\n''' - - if line == "": - print "\nUsage: [method name] [param dict as string]\n" - print "Example: rpc test_add {'x': 12, 'y': 17}\n" - return - - sp = line.split(' ', 1) - method = sp[0] - - params = None - bad_parse = False - if len(sp) > 1: - - try: - params = ast.literal_eval(sp[1]) - if not isinstance(params, dict): - bad_parse = True - - except ValueError as e1: - bad_parse = True - except SyntaxError as e2: - bad_parse = True - - if bad_parse: - print "\nValue should be a valid dict: '{0}'".format(sp[1]) - print "\nUsage: [method name] [param dict as string]\n" - print "Example: rpc test_add {'x': 12, 'y': 17}\n" - return - - res_ok, msg = self.stateless_client.transmit(method, params) - if res_ok: - print "\nServer Response:\n\n" + pretty_json(json.dumps(msg)) + "\n" - else: - print "\n*** " + msg + "\n" - #print "Please try 'reconnect' to reconnect to server" - - - def complete_rpc (self, text, line, begidx, endidx): - return [x - for x in self.trex_console.supported_rpc - if x.startswith(text)] - - # aliasing - do_exit = do_EOF = do_q = do_quit - -# diff --git a/scripts/automation/trex_control_plane/console/trex_console.py b/scripts/automation/trex_control_plane/console/trex_console.py index e537c306..325ba514 100755 --- a/scripts/automation/trex_control_plane/console/trex_console.py +++ b/scripts/automation/trex_control_plane/console/trex_console.py @@ -17,7 +17,7 @@ See the License for the specific language governing permissions and limitations under the License. """ - +import subprocess import cmd import json import ast @@ -33,8 +33,9 @@ from common.trex_streams import * from client.trex_stateless_client import CTRexStatelessClient from common.text_opts import * from client_utils.general_utils import user_input, get_current_user -import trex_status -import parsing_opts +from client_utils import parsing_opts +import trex_tui +from functools import wraps __version__ = "1.1" @@ -113,13 +114,13 @@ class TRexGeneralCmd(cmd.Cmd): class TRexConsole(TRexGeneralCmd): """Trex Console""" - def __init__(self, stateless_client, acquire_all_ports=True, verbose=False): + def __init__(self, stateless_client, verbose=False): self.stateless_client = stateless_client TRexGeneralCmd.__init__(self) + self.tui = trex_tui.TrexTUI(stateless_client) self.verbose = verbose - self.acquire_all_ports = acquire_all_ports self.intro = "\n-=TRex Console v{ver}=-\n".format(ver=__version__) self.intro += "\nType 'help' or '?' for supported actions\n" @@ -129,9 +130,49 @@ class TRexConsole(TRexGeneralCmd): ################### internal section ######################## + def verify_connected(f): + @wraps(f) + def wrap(*args): + inst = args[0] + func_name = f.__name__ + if func_name.startswith("do_"): + func_name = func_name[3:] + + if not inst.stateless_client.is_connected(): + print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold') + return + + ret = f(*args) + return ret + + return wrap + + # TODO: remove this ugly duplication + def verify_connected_and_rw (f): + @wraps(f) + def wrap(*args): + inst = args[0] + func_name = f.__name__ + if func_name.startswith("do_"): + func_name = func_name[3:] + + if not inst.stateless_client.is_connected(): + print format_text("\n'{0}' cannot be executed on offline mode\n".format(func_name), 'bold') + return + + if inst.stateless_client.is_read_only(): + print format_text("\n'{0}' cannot be executed on read only mode\n".format(func_name), 'bold') + return + + ret = f(*args) + return ret + + return wrap + + def get_console_identifier(self): return "{context}_{server}".format(context=self.__class__.__name__, - server=self.stateless_client.get_system_info()['hostname']) + server=self.stateless_client.get_server()) def register_main_console_methods(self): main_names = set(self.trex_console.get_names()).difference(set(dir(self.__class__))) @@ -141,11 +182,18 @@ class TRexConsole(TRexGeneralCmd): self.__dict__[name] = getattr(self.trex_console, name) def postcmd(self, stop, line): - if self.stateless_client.is_connected(): - self.prompt = "TRex > " - else: - self.supported_rpc = None + + if not self.stateless_client.is_connected(): self.prompt = "TRex (offline) > " + self.supported_rpc = None + return stop + + if self.stateless_client.is_read_only(): + self.prompt = "TRex (read only) > " + return stop + + + self.prompt = "TRex > " return stop @@ -207,13 +255,9 @@ class TRexConsole(TRexGeneralCmd): ####################### shell commands ####################### + @verify_connected def do_ping (self, line): '''Ping the server\n''' - - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - rc = self.stateless_client.cmd_ping() if rc.bad(): return @@ -227,12 +271,12 @@ class TRexConsole(TRexGeneralCmd): elif line == "on": self.verbose = True - self.stateless_client.set_verbose(True) + self.stateless_client.set_verbose(self.stateless_client.VERBOSE_HIGH) print format_text("\nverbose set to on\n", 'green', 'bold') elif line == "off": self.verbose = False - self.stateless_client.set_verbose(False) + self.stateless_client.set_verbose(self.stateless_client.VERBOSE_REGULAR) print format_text("\nverbose set to off\n", 'green', 'bold') else: @@ -276,17 +320,13 @@ class TRexConsole(TRexGeneralCmd): def do_connect (self, line): '''Connects to the server\n''' - rc = self.stateless_client.cmd_connect() - if rc.bad(): - return + self.stateless_client.cmd_connect_line(line) def do_disconnect (self, line): '''Disconnect from the server\n''' - rc = self.stateless_client.cmd_disconnect() - if rc.bad(): - return + self.stateless_client.cmd_disconnect() ############### start @@ -303,13 +343,10 @@ class TRexConsole(TRexGeneralCmd): if (l > 2) and (s[l - 2] in file_flags): return TRexConsole.tree_autocomplete(s[l - 1]) + @verify_connected_and_rw def do_start(self, line): '''Start selected traffic in specified port(s) on TRex\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_start_line(line) @@ -317,62 +354,72 @@ class TRexConsole(TRexGeneralCmd): self.do_start("-h") ############# stop + @verify_connected_and_rw def do_stop(self, line): '''stops port(s) transmitting traffic\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_stop_line(line) def help_stop(self): self.do_stop("-h") ############# update + @verify_connected_and_rw def do_update(self, line): '''update speed of port(s)currently transmitting traffic\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_update_line(line) def help_update (self): self.do_update("-h") ############# pause + @verify_connected_and_rw def do_pause(self, line): '''pause port(s) transmitting traffic\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_pause_line(line) ############# resume + @verify_connected_and_rw def do_resume(self, line): '''resume port(s) transmitting traffic\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_resume_line(line) ########## reset + @verify_connected_and_rw def do_reset (self, line): '''force stop all ports\n''' + self.stateless_client.cmd_reset_line(line) - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') - return - self.stateless_client.cmd_reset() + ######### validate + @verify_connected + def do_validate (self, line): + '''validates port(s) stream configuration\n''' + + self.stateless_client.cmd_validate_line(line) + + + @verify_connected + def do_stats(self, line): + '''Fetch statistics from TRex server by port\n''' + self.stateless_client.cmd_stats_line(line) + + + def help_stats(self): + self.do_stats("-h") + + @verify_connected + def do_clear(self, line): + '''Clear cached local statistics\n''' + self.stateless_client.cmd_clear_line(line) + + def help_clear(self): + self.do_clear("-h") def help_events (self): @@ -404,15 +451,28 @@ class TRexConsole(TRexGeneralCmd): print format_text("\n\nEvent log was cleared\n\n") # tui + @verify_connected def do_tui (self, line): '''Shows a graphical console\n''' - if not self.stateless_client.is_connected(): - print format_text("\nNot connected to server\n", 'bold') + parser = parsing_opts.gen_parser(self, + "tui", + self.do_tui.__doc__, + parsing_opts.XTERM) + + opts = parser.parse_args(line.split()) + if opts is None: return - self.do_verbose('off') - trex_status.show_trex_status(self.stateless_client) + if opts.xterm: + subprocess.Popen(['xterm', '-geometry', '105x40', '-e', './trex-console', '-t']) + return + + save_verbose = self.stateless_client.get_verbose() + + self.stateless_client.set_verbose(self.stateless_client.VERBOSE_SILENCE) + self.tui.show() + self.stateless_client.set_verbose(save_verbose) # quit function def do_quit(self, line): @@ -504,6 +564,10 @@ def setParserOptions(): help = "Run the console in a batch mode with file", default = None) + parser.add_argument("-t", "--tui", dest="tui", + action="store_true", help="Starts with TUI mode", + default = False) + return parser @@ -513,10 +577,22 @@ def main(): # Stateless client connection stateless_client = CTRexStatelessClient(options.user, options.server, options.port, options.pub) - rc = stateless_client.cmd_connect() + + print "\nlogged as {0}".format(format_text(options.user, 'bold')) + + # TUI or no acquire will give us READ ONLY mode + if options.tui or not options.acquire: + rc = stateless_client.connect("RO") + else: + rc = stateless_client.connect("RW") + + # unable to connect - bye if rc.bad(): + rc.annotate() return + + # a script mode if options.batch: cont = stateless_client.run_script_file(options.batch[0]) if not cont: @@ -524,11 +600,17 @@ def main(): # console try: - console = TRexConsole(stateless_client, options.acquire, options.verbose) - console.cmdloop() + console = TRexConsole(stateless_client, options.verbose) + if options.tui: + console.do_tui("") + else: + console.cmdloop() + except KeyboardInterrupt as e: print "\n\n*** Caught Ctrl + C... Exiting...\n\n" - return + + finally: + stateless_client.disconnect() if __name__ == '__main__': main() diff --git a/scripts/automation/trex_control_plane/console/trex_status.py b/scripts/automation/trex_control_plane/console/trex_status.py index 869812a1..cdf3fb69 100644 --- a/scripts/automation/trex_control_plane/console/trex_status.py +++ b/scripts/automation/trex_control_plane/console/trex_status.py @@ -385,7 +385,7 @@ class TrexStatusCommands(): # # # -class TrexStatus(): +class CTRexStatus(): def __init__ (self, stdscr, stateless_client): self.stdscr = stdscr @@ -494,7 +494,7 @@ class TrexStatus(): self.stats_panel.panel.top() self.stats_panel.draw() - panel.update_panels(); + panel.update_panels() self.stdscr.refresh() sleep(0.01) @@ -506,7 +506,7 @@ def show_trex_status_internal (stdscr, stateless_client): global trex_status if trex_status == None: - trex_status = TrexStatus(stdscr, stateless_client) + trex_status = CTRexStatus(stdscr, stateless_client) trex_status.run() diff --git a/scripts/automation/trex_control_plane/console/trex_tui.py b/scripts/automation/trex_control_plane/console/trex_tui.py new file mode 100644 index 00000000..3a89097f --- /dev/null +++ b/scripts/automation/trex_control_plane/console/trex_tui.py @@ -0,0 +1,467 @@ +import termios +import sys +import os +import time +from common.text_opts import * +from common import trex_stats +from client_utils import text_tables +from collections import OrderedDict +import datetime + +class SimpleBar(object): + def __init__ (self, desc, pattern): + self.desc = desc + self.pattern = pattern + self.pattern_len = len(pattern) + self.index = 0 + + def show (self): + if self.desc: + print format_text("{0} {1}".format(self.desc, self.pattern[self.index]), 'bold') + else: + print format_text("{0}".format(self.pattern[self.index]), 'bold') + + self.index = (self.index + 1) % self.pattern_len + + +# base type of a panel +class TrexTUIPanel(object): + def __init__ (self, mng, name): + + self.mng = mng + self.name = name + self.stateless_client = mng.stateless_client + + + def show (self): + raise Exception("must implement this") + + def get_key_actions (self): + raise Exception("must implement this") + + def get_name (self): + return self.name + + +# dashboard panel +class TrexTUIDashBoard(TrexTUIPanel): + def __init__ (self, mng): + super(TrexTUIDashBoard, self).__init__(mng, "dashboard") + + self.key_actions = OrderedDict() + + self.key_actions['c'] = {'action': self.action_clear, 'legend': 'clear', 'show': True} + self.key_actions['p'] = {'action': self.action_pause, 'legend': 'pause', 'show': True} + self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True} + self.key_actions['+'] = {'action': self.action_raise, 'legend': 'up 5%', 'show': True} + self.key_actions['-'] = {'action': self.action_lower, 'legend': 'low 5%', 'show': True} + + self.ports = self.stateless_client.get_all_ports() + + + def show (self): + stats = self.stateless_client.cmd_stats(self.ports, trex_stats.COMPACT) + # print stats to screen + for stat_type, stat_data in stats.iteritems(): + text_tables.print_table_with_header(stat_data.text_table, stat_type) + + + def get_key_actions (self): + allowed = {} + + allowed['c'] = self.key_actions['c'] + + # thats it for read only + if self.stateless_client.is_read_only(): + return allowed + + if len(self.stateless_client.get_transmitting_ports()) > 0: + allowed['p'] = self.key_actions['p'] + allowed['+'] = self.key_actions['+'] + allowed['-'] = self.key_actions['-'] + + + if len(self.stateless_client.get_paused_ports()) > 0: + allowed['r'] = self.key_actions['r'] + + return allowed + + + ######### actions + def action_pause (self): + rc = self.stateless_client.pause_traffic(self.mng.ports) + + ports_succeeded = [] + for rc_single, port_id in zip(rc.rc_list, self.mng.ports): + if rc_single.rc: + ports_succeeded.append(port_id) + + if len(ports_succeeded) > 0: + return "paused traffic on port(s): {0}".format(ports_succeeded) + else: + return "" + + + def action_resume (self): + rc = self.stateless_client.resume_traffic(self.mng.ports) + + ports_succeeded = [] + for rc_single, port_id in zip(rc.rc_list, self.mng.ports): + if rc_single.rc: + ports_succeeded.append(port_id) + + if len(ports_succeeded) > 0: + return "resumed traffic on port(s): {0}".format(ports_succeeded) + else: + return "" + + + def action_raise (self): + mul = {'type': 'percentage', 'value': 5, 'op': 'add'} + rc = self.stateless_client.update_traffic(mul, self.mng.ports) + + ports_succeeded = [] + for rc_single, port_id in zip(rc.rc_list, self.mng.ports): + if rc_single.rc: + ports_succeeded.append(port_id) + + if len(ports_succeeded) > 0: + return "raised B/W by %5 on port(s): {0}".format(ports_succeeded) + else: + return "" + + def action_lower (self): + mul = {'type': 'percentage', 'value': 5, 'op': 'sub'} + rc = self.stateless_client.update_traffic(mul, self.mng.ports) + + ports_succeeded = [] + for rc_single, port_id in zip(rc.rc_list, self.mng.ports): + if rc_single.rc: + ports_succeeded.append(port_id) + + if len(ports_succeeded) > 0: + return "lowered B/W by %5 on port(s): {0}".format(ports_succeeded) + else: + return "" + + + def action_clear (self): + self.stateless_client.cmd_clear(self.mng.ports) + return "cleared all stats" + + +# port panel +class TrexTUIPort(TrexTUIPanel): + def __init__ (self, mng, port_id): + super(TrexTUIPort, self).__init__(mng, "port {0}".format(port_id)) + + self.port_id = port_id + self.port = self.mng.stateless_client.get_port(port_id) + + self.key_actions = OrderedDict() + + self.key_actions['c'] = {'action': self.action_clear, 'legend': 'clear', 'show': True} + self.key_actions['p'] = {'action': self.action_pause, 'legend': 'pause', 'show': True} + self.key_actions['r'] = {'action': self.action_resume, 'legend': 'resume', 'show': True} + self.key_actions['+'] = {'action': self.action_raise, 'legend': 'up 5%', 'show': True} + self.key_actions['-'] = {'action': self.action_lower, 'legend': 'low 5%', 'show': True} + + + def show (self): + stats = self.stateless_client.cmd_stats([self.port_id], trex_stats.COMPACT) + # print stats to screen + for stat_type, stat_data in stats.iteritems(): + text_tables.print_table_with_header(stat_data.text_table, stat_type) + + def get_key_actions (self): + + allowed = {} + + allowed['c'] = self.key_actions['c'] + + # thats it for read only + if self.stateless_client.is_read_only(): + return allowed + + if self.port.state == self.port.STATE_TX: + allowed['p'] = self.key_actions['p'] + allowed['+'] = self.key_actions['+'] + allowed['-'] = self.key_actions['-'] + + elif self.port.state == self.port.STATE_PAUSE: + allowed['r'] = self.key_actions['r'] + + + return allowed + + # actions + def action_pause (self): + rc = self.stateless_client.pause_traffic([self.port_id]) + if rc.good(): + return "port {0}: paused traffic".format(self.port_id) + else: + return "" + + def action_resume (self): + rc = self.stateless_client.resume_traffic([self.port_id]) + if rc.good(): + return "port {0}: resumed traffic".format(self.port_id) + else: + return "" + + def action_raise (self): + mul = {'type': 'percentage', 'value': 5, 'op': 'add'} + rc = self.stateless_client.update_traffic(mul, [self.port_id]) + + if rc.good(): + return "port {0}: raised B/W by 5%".format(self.port_id) + else: + return "" + + def action_lower (self): + mul = {'type': 'percentage', 'value': 5, 'op': 'sub'} + rc = self.stateless_client.update_traffic(mul, [self.port_id]) + + if rc.good(): + return "port {0}: lowered B/W by 5%".format(self.port_id) + else: + return "" + + def action_clear (self): + self.stateless_client.cmd_clear([self.port_id]) + return "port {0}: cleared stats".format(self.port_id) + +# log +class TrexTUILog(): + def __init__ (self): + self.log = [] + + def add_event (self, msg): + self.log.append("[{0}] {1}".format(str(datetime.datetime.now().time()), msg)) + + def show (self, max_lines = 4): + + cut = len(self.log) - max_lines + if cut < 0: + cut = 0 + + print format_text("\nLog:", 'bold', 'underline') + + for msg in self.log[cut:]: + print msg + + +# Panels manager (contains server panels) +class TrexTUIPanelManager(): + def __init__ (self, tui): + self.tui = tui + self.stateless_client = tui.stateless_client + self.ports = self.stateless_client.get_all_ports() + + + self.panels = {} + self.panels['dashboard'] = TrexTUIDashBoard(self) + + self.key_actions = OrderedDict() + self.key_actions['q'] = {'action': self.action_quit, 'legend': 'quit', 'show': True} + self.key_actions['g'] = {'action': self.action_show_dash, 'legend': 'dashboard', 'show': True} + + for port_id in self.ports: + self.key_actions[str(port_id)] = {'action': self.action_show_port(port_id), 'legend': 'port {0}'.format(port_id), 'show': False} + self.panels['port {0}'.format(port_id)] = TrexTUIPort(self, port_id) + + # start with dashboard + self.main_panel = self.panels['dashboard'] + + # log object + self.log = TrexTUILog() + + self.generate_legend() + + self.conn_bar = SimpleBar('status: ', ['|','/','-','\\']) + self.dis_bar = SimpleBar('status: ', ['X', ' ']) + self.show_log = False + + + def generate_legend (self): + self.legend = "\n{:<12}".format("browse:") + + for k, v in self.key_actions.iteritems(): + if v['show']: + x = "'{0}' - {1}, ".format(k, v['legend']) + self.legend += "{:}".format(x) + + self.legend += "'0-{0}' - port display".format(len(self.ports) - 1) + + + self.legend += "\n{:<12}".format(self.main_panel.get_name() + ":") + for k, v in self.main_panel.get_key_actions().iteritems(): + if v['show']: + x = "'{0}' - {1}, ".format(k, v['legend']) + self.legend += "{:}".format(x) + + + def print_connection_status (self): + if self.tui.get_state() == self.tui.STATE_ACTIVE: + self.conn_bar.show() + else: + self.dis_bar.show() + + def print_legend (self): + print format_text(self.legend, 'bold') + + + # on window switch or turn on / off of the TUI we call this + def init (self, show_log = False): + self.show_log = show_log + self.generate_legend() + + def show (self): + self.main_panel.show() + self.print_connection_status() + self.print_legend() + + if self.show_log: + self.log.show() + + + def handle_key (self, ch): + # check for the manager registered actions + if ch in self.key_actions: + msg = self.key_actions[ch]['action']() + + # check for main panel actions + elif ch in self.main_panel.get_key_actions(): + msg = self.main_panel.get_key_actions()[ch]['action']() + + else: + msg = "" + + self.generate_legend() + + if msg == None: + return False + else: + if msg: + self.log.add_event(msg) + return True + + + # actions + + def action_quit (self): + return None + + def action_show_dash (self): + self.main_panel = self.panels['dashboard'] + self.init(self.show_log) + return "" + + def action_show_port (self, port_id): + def action_show_port_x (): + self.main_panel = self.panels['port {0}'.format(port_id)] + self.init() + return "" + + return action_show_port_x + + + +# shows a textual top style window +class TrexTUI(): + + STATE_ACTIVE = 0 + STATE_LOST_CONT = 1 + STATE_RECONNECT = 2 + + def __init__ (self, stateless_client): + self.stateless_client = stateless_client + + self.pm = TrexTUIPanelManager(self) + + + + def handle_key_input (self): + # try to read a single key + ch = os.read(sys.stdin.fileno(), 1) + if ch != None and len(ch) > 0: + return (self.pm.handle_key(ch), True) + + else: + return (True, False) + + + def clear_screen (self): + os.system('clear') + + + + def show (self, show_log = False): + # init termios + old_settings = termios.tcgetattr(sys.stdin) + new_settings = termios.tcgetattr(sys.stdin) + new_settings[3] = new_settings[3] & ~(termios.ECHO | termios.ICANON) # lflags + new_settings[6][termios.VMIN] = 0 # cc + new_settings[6][termios.VTIME] = 0 # cc + termios.tcsetattr(sys.stdin, termios.TCSADRAIN, new_settings) + + self.pm.init(show_log) + + self.state = self.STATE_ACTIVE + self.draw_policer = 0 + + try: + while True: + # draw and handle user input + cont, force_draw = self.handle_key_input() + self.draw_screen(force_draw) + if not cont: + break + time.sleep(0.1) + + # regular state + if self.state == self.STATE_ACTIVE: + # if no connectivity - move to lost connecitivty + if not self.stateless_client.async_client.is_alive(): + self.stateless_client.cmd_invalidate(self.pm.ports) + self.state = self.STATE_LOST_CONT + + + # lost connectivity + elif self.state == self.STATE_LOST_CONT: + # got it back + if self.stateless_client.async_client.is_alive(): + # move to state reconnect + self.state = self.STATE_RECONNECT + + + # restored connectivity - try to reconnect + elif self.state == self.STATE_RECONNECT: + + rc = self.stateless_client.connect("RO") + if rc.good(): + self.state = self.STATE_ACTIVE + else: + # maybe we lost it again + self.state = self.STATE_LOST_CONT + + + finally: + # restore + termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_settings) + + print "" + + + # draw once + def draw_screen (self, force_draw = False): + + if (self.draw_policer >= 5) or (force_draw): + self.clear_screen() + self.pm.show() + self.draw_policer = 0 + else: + self.draw_policer += 1 + + def get_state (self): + return self.state diff --git a/scripts/automation/trex_control_plane/server/trex_server.py b/scripts/automation/trex_control_plane/server/trex_server.py index 7dee89e9..9868d6c8 100755 --- a/scripts/automation/trex_control_plane/server/trex_server.py +++ b/scripts/automation/trex_control_plane/server/trex_server.py @@ -26,6 +26,7 @@ from trex_launch_thread import AsynchronousTRexSession from zmq_monitor_thread import ZmqMonitorSession from argparse import ArgumentParser, RawTextHelpFormatter from json import JSONEncoder +import re # setup the logger @@ -167,15 +168,17 @@ class CTRexServer(object): logger.info("Processing get_trex_daemon_log() command.") return self._pull_file('/var/log/trex/trex_daemon_server.log') - # get Trex version from ./t-rex-64 --help (last 4 lines) + # get Trex version from ./t-rex-64 --help (last lines starting with "Version : ...") def get_trex_version (self, base64 = True): try: logger.info("Processing get_trex_version() command.") if not self.trex_version: help_print = subprocess.Popen(['./t-rex-64', '--help'], cwd = self.TREX_PATH, stdout=subprocess.PIPE, stderr=subprocess.PIPE) - help_print.wait() - help_print_stdout = help_print.stdout.read() - self.trex_version = binascii.b2a_base64('\n'.join(help_print_stdout.split('\n')[-5:-1])) + (stdout, stderr) = help_print.communicate() + search_result = re.search('\n\s*(Version\s*:.+)', stdout, re.DOTALL) + if not search_result: + raise Exception('Could not determine version from ./t-rex-64 --help') + self.trex_version = binascii.b2a_base64(search_result.group(1)) if base64: return self.trex_version else: @@ -340,11 +343,12 @@ class CTRexServer(object): Parameters ---------- - trex_cmd_options : str - Defines the exact command to run on the t-rex - Example: "-c 2 -m 0.500000 -d 100 -f cap2/sfr.yaml --nc -p -l 1000" + kwargs: dictionary + Dictionary of parameters for trex. For example: (c=1, nc=True, l_pkt_mode=3). + Notice that when sending command line parameters that has -, you need to replace it with _. + for example, to have on command line "--l-pkt-mode 3", you need to send l_pkt_mode=3 export_path : str - a full system path to which the results of the trex-run will be logged. + Full system path to which the results of the trex-run will be logged. """ if 'results_file_path' in kwargs: diff --git a/scripts/cap2/dns_no_delay.yaml b/scripts/cap2/dns_no_delay.yaml new file mode 100644 index 00000000..ab387d31 --- /dev/null +++ b/scripts/cap2/dns_no_delay.yaml @@ -0,0 +1,23 @@ +- duration : 10.0 + generator : + distribution : "seq" + clients_start : "16.0.0.1" + clients_end : "16.0.1.255" + servers_start : "48.0.0.1" + servers_end : "48.0.0.255" + clients_per_gb : 201 + min_clients : 101 + dual_port_mask : "1.0.0.0" + tcp_aging : 0 + udp_aging : 0 + mac : [0x00,0x00,0x00,0x01,0x00,0x00] + #vlan : { enable : 1 , vlan0 : 100 , vlan1 : 200 } + #mac_override_by_ip : true + cap_info : + - name: cap2/dns.pcap + cps : 1.0 + ipg : 10000 + rtt : 10000 + w : 1 + + diff --git a/scripts/cap2/imix_64_100k.yaml b/scripts/cap2/imix_64_100k.yaml new file mode 100644 index 00000000..0c2cfe14 --- /dev/null +++ b/scripts/cap2/imix_64_100k.yaml @@ -0,0 +1,70 @@ +# +# Simple IMIX test 64B +# +- duration : 3 + generator : + distribution : "seq" + clients_start : "16.0.0.1" + clients_end : "16.0.0.255" + servers_start : "48.0.0.1" + servers_end : "48.0.255.255" + clients_per_gb : 201 + min_clients : 101 + dual_port_mask : "1.0.0.0" + tcp_aging : 0 + udp_aging : 0 + mac : [0x0,0x0,0x0,0x1,0x0,0x00] +# +# the templates are duplicated in purpose , to utilized all DRAM BW and get better performance, we should do it automaticly +# but for now it like this , you should have at least 8 +# + cap_info : + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + - name: cap2/udp_64B.pcap + cps : 1000.0 + ipg : 10000 + rtt : 10000 + w : 1 + limit : 2000 + diff --git a/scripts/cfg/simple_cfg.yaml b/scripts/cfg/simple_cfg.yaml new file mode 100644 index 00000000..7b1dc393 --- /dev/null +++ b/scripts/cfg/simple_cfg.yaml @@ -0,0 +1,10 @@ +- port_limit : 2 # this option can limit the number of port of the platform + version : 2 + interfaces : ["03:00.0","03:00.1"] #the interfaces using ./dpdk_setup_ports.py -s + port_info : # set eh mac addr + - dest_mac : [0x00,0x00,0x00,0x01,0x00,0x00] # router mac addr should be taken from router + src_mac : [0x00,0x00,0x00,0x02,0x00,0x00] # source mac-addr - taken from ifconfig + - dest_mac : [0x00,0x00,0x00,0x03,0x00,0x00] # router mac addr taken from router + src_mac : [0x00,0x00,0x00,0x04,0x00,0x00] #source mac-addr taken from ifconfig + + diff --git a/scripts/external_libs/texttable-0.8.4/LICENSE b/scripts/external_libs/texttable-0.8.4/LICENSE new file mode 100644 index 00000000..65c5ca88 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/scripts/external_libs/texttable-0.8.4/PKG-INFO b/scripts/external_libs/texttable-0.8.4/PKG-INFO new file mode 100644 index 00000000..a3079ad9 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/PKG-INFO @@ -0,0 +1,23 @@ +Metadata-Version: 1.0 +Name: texttable +Version: 0.8.4 +Summary: module for creating simple ASCII tables +Home-page: https://github.com/foutaise/texttable/ +Author: Gerome Fournier +Author-email: jef(at)foutaise.org +License: LGPL +Download-URL: https://github.com/foutaise/texttable/archive/v0.8.4.tar.gz +Description: texttable is a module to generate a formatted text table, using ASCII + characters. +Platform: any +Classifier: Development Status :: 4 - Beta +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: End Users/Desktop +Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX +Classifier: Operating System :: MacOS +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Processing +Classifier: Topic :: Utilities diff --git a/scripts/external_libs/texttable-0.8.4/README.md b/scripts/external_libs/texttable-0.8.4/README.md new file mode 100644 index 00000000..0d9895e8 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/README.md @@ -0,0 +1,223 @@ +# texttable + +Python module for creating simple ASCII tables + +## Availability + +This module is available on [PypI](https://pypi.python.org/pypi/texttable/0.8.4), and has been packaged for several Linux/Unix platforms +([Debian](https://packages.debian.org/search?&searchon=names&keywords=python-texttable+), +[FreeBSD](https://www.freebsd.org/cgi/ports.cgi?query=texttable&stype=all), Fedora, Suse...). + +## Documentation + +``` +NAME + texttable - module for creating simple ASCII tables + +FILE + /usr/lib/python2.3/site-packages/texttable.py + +DESCRIPTION + + Example: + + table = Texttable() + table.set_cols_align(["l", "r", "c"]) + table.set_cols_valign(["t", "m", "b"]) + table.add_rows([["Name", "Age", "Nickname"], + ["Mr\nXavier\nHuon", 32, "Xav'"], + ["Mr\nBaptiste\nClement", 1, "Baby"]]) + print table.draw() + "\n" + + table = Texttable() + table.set_deco(Texttable.HEADER) + table.set_cols_dtype(['t', # text + 'f', # float (decimal) + 'e', # float (exponent) + 'i', # integer + 'a']) # automatic + table.set_cols_align(["l", "r", "r", "r", "l"]) + table.add_rows([["text", "float", "exp", "int", "auto"], + ["abcd", "67", 654, 89, 128.001], + ["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023], + ["lmn", 5e-78, 5e-78, 89.4, .000000000000128], + ["opqrstu", .023, 5e+78, 92., 12800000000000000000000]]) + print table.draw() + + Result: + + +----------+-----+----------+ + | Name | Age | Nickname | + +==========+=====+==========+ + | Mr | | | + | Xavier | 32 | | + | Huon | | Xav' | + +----------+-----+----------+ + | Mr | | | + | Baptiste | 1 | | + | Clement | | Baby | + +----------+-----+----------+ + + text float exp int auto + =========================================== + abcd 67.000 6.540e+02 89 128.001 + efgh 67.543 6.540e-01 90 1.280e+22 + ijkl 0.000 5.000e-78 89 0.000 + mnop 0.023 5.000e+78 92 1.280e+22 + +CLASSES + class Texttable + | Methods defined here: + | + | __init__(self, max_width=80) + | Constructor + | + | - max_width is an integer, specifying the maximum width of the table + | - if set to 0, size is unlimited, therefore cells won't be wrapped + | + | add_row(self, array) + | Add a row in the rows stack + | + | - cells can contain newlines and tabs + | + | add_rows(self, rows, header=True) + | Add several rows in the rows stack + | + | - The 'rows' argument can be either an iterator returning arrays, + | or a by-dimensional array + | - 'header' specifies if the first row should be used as the header + | of the table + | + | draw(self) + | Draw the table + | + | - the table is returned as a whole string + | + | header(self, array) + | Specify the header of the table + | + | reset(self) + | Reset the instance + | + | - reset rows and header + | + | set_chars(self, array) + | Set the characters used to draw lines between rows and columns + | + | - the array should contain 4 fields: + | + | [horizontal, vertical, corner, header] + | + | - default is set to: + | + | ['-', '|', '+', '='] + | + | set_cols_align(self, array) + | Set the desired columns alignment + | + | - the elements of the array should be either "l", "c" or "r": + | + | * "l": column flushed left + | * "c": column centered + | * "r": column flushed right + | + | set_cols_dtype(self, array) + | Set the desired columns datatype for the cols. + | + | - the elements of the array should be either "a", "t", "f", "e" or "i": + | + | * "a": automatic (try to use the most appropriate datatype) + | * "t": treat as text + | * "f": treat as float in decimal format + | * "e": treat as float in exponential format + | * "i": treat as int + | + | - by default, automatic datatyping is used for each column + | + | set_cols_valign(self, array) + | Set the desired columns vertical alignment + | + | - the elements of the array should be either "t", "m" or "b": + | + | * "t": column aligned on the top of the cell + | * "m": column aligned on the middle of the cell + | * "b": column aligned on the bottom of the cell + | + | set_cols_width(self, array) + | Set the desired columns width + | + | - the elements of the array should be integers, specifying the + | width of each column. For example: + | + | [10, 20, 5] + | + | set_deco(self, deco) + | Set the table decoration + | + | - 'deco' can be a combinaison of: + | + | Texttable.BORDER: Border around the table + | Texttable.HEADER: Horizontal line below the header + | Texttable.HLINES: Horizontal lines between rows + | Texttable.VLINES: Vertical lines between columns + | + | All of them are enabled by default + | + | - example: + | + | Texttable.BORDER | Texttable.HEADER + | + | set_precision(self, width) + | Set the desired precision for float/exponential formats + | + | - width must be an integer >= 0 + | + | - default value is set to 3 + | + | ---------------------------------------------------------------------- + | Data and other attributes defined here: + | + | BORDER = 1 + | + | HEADER = 2 + | + | HLINES = 4 + | + | VLINES = 8 + +DATA + __all__ = ['Texttable', 'ArraySizeError'] + __author__ = 'Gerome Fournier <jef(at)foutaise.org>' + __credits__ = 'Jeff Kowalczyk:\n - textwrap improved import\n ...:\... + __license__ = 'LGPL' + __version__ = '0.8.4' + +VERSION + 0.8.4 + +AUTHOR + Gerome Fournier <jef(at)foutaise.org> + +CREDITS + Jeff Kowalczyk: + - textwrap improved import + - comment concerning header output + + Anonymous: + - add_rows method, for adding rows in one go + + Sergey Simonenko: + - redefined len() function to deal with non-ASCII characters + + Roger Lew: + - columns datatype specifications + + Brian Peterson: + - better handling of unicode errors + + Frank Sachsenheim: + - add Python 2/3-compatibility + + Maximilian Hils: + - fix minor bug for Python 3 compatibility +``` diff --git a/scripts/external_libs/texttable-0.8.4/setup.py b/scripts/external_libs/texttable-0.8.4/setup.py new file mode 100644 index 00000000..eb8c9e3a --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/setup.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# +# texttable - module for creating simple ASCII tables +# Copyright (C) 2003-2015 Gerome Fournier <jef(at)foutaise.org> +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +DESCRIPTION = "module for creating simple ASCII tables" + +LONG_DESCRIPTION = """\ +texttable is a module to generate a formatted text table, using ASCII +characters.""" + +import sys + +from distutils.core import setup +if sys.version < '2.2.3': + from distutils.dist import DistributionMetadata + DistributionMetadata.classifiers = None + DistributionMetadata.download_url = None + +setup( + name = "texttable", + version = "0.8.4", + author = "Gerome Fournier", + author_email = "jef(at)foutaise.org", + url = "https://github.com/foutaise/texttable/", + download_url = "https://github.com/foutaise/texttable/archive/v0.8.4.tar.gz", + license = "LGPL", + py_modules = ["texttable"], + description = DESCRIPTION, + long_description = LONG_DESCRIPTION, + platforms = "any", + classifiers = [ + 'Development Status :: 4 - Beta', + 'Environment :: Console', + 'Intended Audience :: Developers', + 'Intended Audience :: End Users/Desktop', + 'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)', + 'Operating System :: Microsoft :: Windows', + 'Operating System :: POSIX', + 'Operating System :: MacOS', + 'Topic :: Software Development :: Libraries :: Python Modules', + 'Topic :: Text Processing', + 'Topic :: Utilities', + ] +) diff --git a/scripts/external_libs/texttable-0.8.4/texttable.py b/scripts/external_libs/texttable-0.8.4/texttable.py new file mode 100644 index 00000000..775a43e5 --- /dev/null +++ b/scripts/external_libs/texttable-0.8.4/texttable.py @@ -0,0 +1,607 @@ +#!/usr/bin/env python +# +# texttable - module for creating simple ASCII tables +# Copyright (C) 2003-2015 Gerome Fournier <jef(at)foutaise.org> +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +"""module for creating simple ASCII tables + + +Example: + + table = Texttable() + table.set_cols_align(["l", "r", "c"]) + table.set_cols_valign(["t", "m", "b"]) + table.add_rows([["Name", "Age", "Nickname"], + ["Mr\\nXavier\\nHuon", 32, "Xav'"], + ["Mr\\nBaptiste\\nClement", 1, "Baby"]]) + print table.draw() + "\\n" + + table = Texttable() + table.set_deco(Texttable.HEADER) + table.set_cols_dtype(['t', # text + 'f', # float (decimal) + 'e', # float (exponent) + 'i', # integer + 'a']) # automatic + table.set_cols_align(["l", "r", "r", "r", "l"]) + table.add_rows([["text", "float", "exp", "int", "auto"], + ["abcd", "67", 654, 89, 128.001], + ["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023], + ["lmn", 5e-78, 5e-78, 89.4, .000000000000128], + ["opqrstu", .023, 5e+78, 92., 12800000000000000000000]]) + print table.draw() + +Result: + + +----------+-----+----------+ + | Name | Age | Nickname | + +==========+=====+==========+ + | Mr | | | + | Xavier | 32 | | + | Huon | | Xav' | + +----------+-----+----------+ + | Mr | | | + | Baptiste | 1 | | + | Clement | | Baby | + +----------+-----+----------+ + + text float exp int auto + =========================================== + abcd 67.000 6.540e+02 89 128.001 + efgh 67.543 6.540e-01 90 1.280e+22 + ijkl 0.000 5.000e-78 89 0.000 + mnop 0.023 5.000e+78 92 1.280e+22 +""" + +__all__ = ["Texttable", "ArraySizeError"] + +__author__ = 'Gerome Fournier <jef(at)foutaise.org>' +__license__ = 'LGPL' +__version__ = '0.8.4' +__credits__ = """\ +Jeff Kowalczyk: + - textwrap improved import + - comment concerning header output + +Anonymous: + - add_rows method, for adding rows in one go + +Sergey Simonenko: + - redefined len() function to deal with non-ASCII characters + +Roger Lew: + - columns datatype specifications + +Brian Peterson: + - better handling of unicode errors + +Frank Sachsenheim: + - add Python 2/3-compatibility + +Maximilian Hils: + - fix minor bug for Python 3 compatibility +""" + +import sys +import string + +try: + if sys.version >= '2.3': + import textwrap + elif sys.version >= '2.2': + from optparse import textwrap + else: + from optik import textwrap +except ImportError: + sys.stderr.write("Can't import textwrap module!\n") + raise + +if sys.version >= '2.7': + from functools import reduce + +def len(iterable): + """Redefining len here so it will be able to work with non-ASCII characters + """ + if not isinstance(iterable, str): + return iterable.__len__() + + try: + if sys.version >= '3.0': + return len(str) + else: + return len(unicode(iterable, 'utf')) + except: + return iterable.__len__() + + +class ArraySizeError(Exception): + """Exception raised when specified rows don't fit the required size + """ + + def __init__(self, msg): + self.msg = msg + Exception.__init__(self, msg, '') + + def __str__(self): + return self.msg + + +class Texttable: + + BORDER = 1 + HEADER = 1 << 1 + HLINES = 1 << 2 + VLINES = 1 << 3 + + def __init__(self, max_width=80): + """Constructor + + - max_width is an integer, specifying the maximum width of the table + - if set to 0, size is unlimited, therefore cells won't be wrapped + """ + + if max_width <= 0: + max_width = False + self._max_width = max_width + self._precision = 3 + + self._deco = Texttable.VLINES | Texttable.HLINES | Texttable.BORDER | \ + Texttable.HEADER + self.set_chars(['-', '|', '+', '=']) + self.reset() + + def reset(self): + """Reset the instance + + - reset rows and header + """ + + self._hline_string = None + self._row_size = None + self._header = [] + self._rows = [] + + def set_chars(self, array): + """Set the characters used to draw lines between rows and columns + + - the array should contain 4 fields: + + [horizontal, vertical, corner, header] + + - default is set to: + + ['-', '|', '+', '='] + """ + + if len(array) != 4: + raise ArraySizeError("array should contain 4 characters") + array = [ x[:1] for x in [ str(s) for s in array ] ] + (self._char_horiz, self._char_vert, + self._char_corner, self._char_header) = array + + def set_deco(self, deco): + """Set the table decoration + + - 'deco' can be a combinaison of: + + Texttable.BORDER: Border around the table + Texttable.HEADER: Horizontal line below the header + Texttable.HLINES: Horizontal lines between rows + Texttable.VLINES: Vertical lines between columns + + All of them are enabled by default + + - example: + + Texttable.BORDER | Texttable.HEADER + """ + + self._deco = deco + + def set_cols_align(self, array): + """Set the desired columns alignment + + - the elements of the array should be either "l", "c" or "r": + + * "l": column flushed left + * "c": column centered + * "r": column flushed right + """ + + self._check_row_size(array) + self._align = array + + def set_cols_valign(self, array): + """Set the desired columns vertical alignment + + - the elements of the array should be either "t", "m" or "b": + + * "t": column aligned on the top of the cell + * "m": column aligned on the middle of the cell + * "b": column aligned on the bottom of the cell + """ + + self._check_row_size(array) + self._valign = array + + def set_cols_dtype(self, array): + """Set the desired columns datatype for the cols. + + - the elements of the array should be either "a", "t", "f", "e" or "i": + + * "a": automatic (try to use the most appropriate datatype) + * "t": treat as text + * "f": treat as float in decimal format + * "e": treat as float in exponential format + * "i": treat as int + + - by default, automatic datatyping is used for each column + """ + + self._check_row_size(array) + self._dtype = array + + def set_cols_width(self, array): + """Set the desired columns width + + - the elements of the array should be integers, specifying the + width of each column. For example: + + [10, 20, 5] + """ + + self._check_row_size(array) + try: + array = list(map(int, array)) + if reduce(min, array) <= 0: + raise ValueError + except ValueError: + sys.stderr.write("Wrong argument in column width specification\n") + raise + self._width = array + + def set_precision(self, width): + """Set the desired precision for float/exponential formats + + - width must be an integer >= 0 + + - default value is set to 3 + """ + + if not type(width) is int or width < 0: + raise ValueError('width must be an integer greater then 0') + self._precision = width + + def header(self, array): + """Specify the header of the table + """ + + self._check_row_size(array) + self._header = list(map(str, array)) + + def add_row(self, array): + """Add a row in the rows stack + + - cells can contain newlines and tabs + """ + + self._check_row_size(array) + + if not hasattr(self, "_dtype"): + self._dtype = ["a"] * self._row_size + + cells = [] + for i, x in enumerate(array): + cells.append(self._str(i, x)) + self._rows.append(cells) + + def add_rows(self, rows, header=True): + """Add several rows in the rows stack + + - The 'rows' argument can be either an iterator returning arrays, + or a by-dimensional array + - 'header' specifies if the first row should be used as the header + of the table + """ + + # nb: don't use 'iter' on by-dimensional arrays, to get a + # usable code for python 2.1 + if header: + if hasattr(rows, '__iter__') and hasattr(rows, 'next'): + self.header(rows.next()) + else: + self.header(rows[0]) + rows = rows[1:] + for row in rows: + self.add_row(row) + + def draw(self): + """Draw the table + + - the table is returned as a whole string + """ + + if not self._header and not self._rows: + return + self._compute_cols_width() + self._check_align() + out = "" + if self._has_border(): + out += self._hline() + if self._header: + out += self._draw_line(self._header, isheader=True) + if self._has_header(): + out += self._hline_header() + length = 0 + for row in self._rows: + length += 1 + out += self._draw_line(row) + if self._has_hlines() and length < len(self._rows): + out += self._hline() + if self._has_border(): + out += self._hline() + return out[:-1] + + def _str(self, i, x): + """Handles string formatting of cell data + + i - index of the cell datatype in self._dtype + x - cell data to format + """ + try: + f = float(x) + except: + return str(x) + + n = self._precision + dtype = self._dtype[i] + + if dtype == 'i': + return str(int(round(f))) + elif dtype == 'f': + return '%.*f' % (n, f) + elif dtype == 'e': + return '%.*e' % (n, f) + elif dtype == 't': + return str(x) + else: + if f - round(f) == 0: + if abs(f) > 1e8: + return '%.*e' % (n, f) + else: + return str(int(round(f))) + else: + if abs(f) > 1e8: + return '%.*e' % (n, f) + else: + return '%.*f' % (n, f) + + def _check_row_size(self, array): + """Check that the specified array fits the previous rows size + """ + + if not self._row_size: + self._row_size = len(array) + elif self._row_size != len(array): + raise ArraySizeError("array should contain %d elements" \ + % self._row_size) + + def _has_vlines(self): + """Return a boolean, if vlines are required or not + """ + + return self._deco & Texttable.VLINES > 0 + + def _has_hlines(self): + """Return a boolean, if hlines are required or not + """ + + return self._deco & Texttable.HLINES > 0 + + def _has_border(self): + """Return a boolean, if border is required or not + """ + + return self._deco & Texttable.BORDER > 0 + + def _has_header(self): + """Return a boolean, if header line is required or not + """ + + return self._deco & Texttable.HEADER > 0 + + def _hline_header(self): + """Print header's horizontal line + """ + + return self._build_hline(True) + + def _hline(self): + """Print an horizontal line + """ + + if not self._hline_string: + self._hline_string = self._build_hline() + return self._hline_string + + def _build_hline(self, is_header=False): + """Return a string used to separated rows or separate header from + rows + """ + horiz = self._char_horiz + if (is_header): + horiz = self._char_header + # compute cell separator + s = "%s%s%s" % (horiz, [horiz, self._char_corner][self._has_vlines()], + horiz) + # build the line + l = s.join([horiz * n for n in self._width]) + # add border if needed + if self._has_border(): + l = "%s%s%s%s%s\n" % (self._char_corner, horiz, l, horiz, + self._char_corner) + else: + l += "\n" + return l + + def _len_cell(self, cell): + """Return the width of the cell + + Special characters are taken into account to return the width of the + cell, such like newlines and tabs + """ + + cell_lines = cell.split('\n') + maxi = 0 + for line in cell_lines: + length = 0 + parts = line.split('\t') + for part, i in zip(parts, list(range(1, len(parts) + 1))): + length = length + len(part) + if i < len(parts): + length = (length//8 + 1) * 8 + maxi = max(maxi, length) + return maxi + + def _compute_cols_width(self): + """Return an array with the width of each column + + If a specific width has been specified, exit. If the total of the + columns width exceed the table desired width, another width will be + computed to fit, and cells will be wrapped. + """ + + if hasattr(self, "_width"): + return + maxi = [] + if self._header: + maxi = [ self._len_cell(x) for x in self._header ] + for row in self._rows: + for cell,i in zip(row, list(range(len(row)))): + try: + maxi[i] = max(maxi[i], self._len_cell(cell)) + except (TypeError, IndexError): + maxi.append(self._len_cell(cell)) + items = len(maxi) + length = reduce(lambda x, y: x+y, maxi) + if self._max_width and length + items * 3 + 1 > self._max_width: + maxi = [(self._max_width - items * 3 -1) // items \ + for n in range(items)] + self._width = maxi + + def _check_align(self): + """Check if alignment has been specified, set default one if not + """ + + if not hasattr(self, "_align"): + self._align = ["l"] * self._row_size + if not hasattr(self, "_valign"): + self._valign = ["t"] * self._row_size + + def _draw_line(self, line, isheader=False): + """Draw a line + + Loop over a single cell length, over all the cells + """ + + line = self._splitit(line, isheader) + space = " " + out = "" + for i in range(len(line[0])): + if self._has_border(): + out += "%s " % self._char_vert + length = 0 + for cell, width, align in zip(line, self._width, self._align): + length += 1 + cell_line = cell[i] + fill = width - len(cell_line) + if isheader: + align = "c" + if align == "r": + out += "%s " % (fill * space + cell_line) + elif align == "c": + out += "%s " % (int(fill/2) * space + cell_line \ + + int(fill/2 + fill%2) * space) + else: + out += "%s " % (cell_line + fill * space) + if length < len(line): + out += "%s " % [space, self._char_vert][self._has_vlines()] + out += "%s\n" % ['', self._char_vert][self._has_border()] + return out + + def _splitit(self, line, isheader): + """Split each element of line to fit the column width + + Each element is turned into a list, result of the wrapping of the + string to the desired width + """ + + line_wrapped = [] + for cell, width in zip(line, self._width): + array = [] + for c in cell.split('\n'): + try: + if sys.version >= '3.0': + c = str(c) + else: + c = unicode(c, 'utf') + except UnicodeDecodeError as strerror: + sys.stderr.write("UnicodeDecodeError exception for string '%s': %s\n" % (c, strerror)) + if sys.version >= '3.0': + c = str(c, 'utf', 'replace') + else: + c = unicode(c, 'utf', 'replace') + array.extend(textwrap.wrap(c, width)) + line_wrapped.append(array) + max_cell_lines = reduce(max, list(map(len, line_wrapped))) + for cell, valign in zip(line_wrapped, self._valign): + if isheader: + valign = "t" + if valign == "m": + missing = max_cell_lines - len(cell) + cell[:0] = [""] * int(missing / 2) + cell.extend([""] * int(missing / 2 + missing % 2)) + elif valign == "b": + cell[:0] = [""] * (max_cell_lines - len(cell)) + else: + cell.extend([""] * (max_cell_lines - len(cell))) + return line_wrapped + + +if __name__ == '__main__': + table = Texttable() + table.set_cols_align(["l", "r", "c"]) + table.set_cols_valign(["t", "m", "b"]) + table.add_rows([["Name", "Age", "Nickname"], + ["Mr\nXavier\nHuon", 32, "Xav'"], + ["Mr\nBaptiste\nClement", 1, "Baby"]]) + print(table.draw() + "\n") + + table = Texttable() + table.set_deco(Texttable.HEADER) + table.set_cols_dtype(['t', # text + 'f', # float (decimal) + 'e', # float (exponent) + 'i', # integer + 'a']) # automatic + table.set_cols_align(["l", "r", "r", "r", "l"]) + table.add_rows([["text", "float", "exp", "int", "auto"], + ["abcd", "67", 654, 89, 128.001], + ["efghijk", 67.5434, .654, 89.6, 12800000000000000000000.00023], + ["lmn", 5e-78, 5e-78, 89.4, .000000000000128], + ["opqrstu", .023, 5e+78, 92., 12800000000000000000000]]) + print(table.draw()) diff --git a/scripts/stl/imix_1pkt_2.yaml b/scripts/stl/imix_1pkt_2.yaml new file mode 100644 index 00000000..163631dc --- /dev/null +++ b/scripts/stl/imix_1pkt_2.yaml @@ -0,0 +1,38 @@ +### Single stream UDP packet, 64B ### +##################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []
\ No newline at end of file diff --git a/scripts/stl/imix_3pkt.yaml b/scripts/stl/imix_3pkt.yaml index 5405edb0..74ae41a8 100755 --- a/scripts/stl/imix_3pkt.yaml +++ b/scripts/stl/imix_3pkt.yaml @@ -7,7 +7,7 @@ binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC mode: type: continuous - pps: 100 + pps: 28 rx_stats: [] - name: udp_594B stream: @@ -16,7 +16,7 @@ binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC mode: type: continuous - pps: 100 + pps: 20 rx_stats: [] - name: udp_1518B stream: @@ -25,5 +25,5 @@ binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC mode: type: continuous - pps: 100 + pps: 4 rx_stats: []
\ No newline at end of file diff --git a/scripts/stl/imix_scale_1000.yaml b/scripts/stl/imix_scale_1000.yaml new file mode 100644 index 00000000..5b8d2123 --- /dev/null +++ b/scripts/stl/imix_scale_1000.yaml @@ -0,0 +1,28001 @@ +### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []
\ No newline at end of file diff --git a/scripts/stl/imix_scale_300.yaml b/scripts/stl/imix_scale_300.yaml new file mode 100644 index 00000000..9ab578ff --- /dev/null +++ b/scripts/stl/imix_scale_300.yaml @@ -0,0 +1,2801 @@ +### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []### Three-stream UDP packets, 64B, 594B and 1518B ### +##################################################### +- name: udp_64B + stream: + self_start: True + packet: + binary: stl/udp_64B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_594B + stream: + self_start: True + packet: + binary: stl/udp_594B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: [] +- name: udp_1518B + stream: + self_start: True + packet: + binary: stl/udp_1518B_no_crc.pcap # pcap should not include CRC + mode: + type: continuous + pps: 100 + rx_stats: []
\ No newline at end of file diff --git a/scripts/t-rex-64-debug b/scripts/t-rex-64-debug index 4f3761d9..dafa0796 100755..120000 --- a/scripts/t-rex-64-debug +++ b/scripts/t-rex-64-debug @@ -1,9 +1 @@ -#! /bin/bash -./trex-cfg -cd $(dirname $0) -export LD_LIBRARY_PATH=$PWD -saveterm="$(stty -g)" -./_$(basename $0) $@ -stty $saveterm - - +t-rex-64
\ No newline at end of file diff --git a/scripts/t-rex-64-debug-o b/scripts/t-rex-64-debug-o index 4f3761d9..dafa0796 100755..120000 --- a/scripts/t-rex-64-debug-o +++ b/scripts/t-rex-64-debug-o @@ -1,9 +1 @@ -#! /bin/bash -./trex-cfg -cd $(dirname $0) -export LD_LIBRARY_PATH=$PWD -saveterm="$(stty -g)" -./_$(basename $0) $@ -stty $saveterm - - +t-rex-64
\ No newline at end of file diff --git a/scripts/t-rex-64-o b/scripts/t-rex-64-o index 4f3761d9..dafa0796 100755..120000 --- a/scripts/t-rex-64-o +++ b/scripts/t-rex-64-o @@ -1,9 +1 @@ -#! /bin/bash -./trex-cfg -cd $(dirname $0) -export LD_LIBRARY_PATH=$PWD -saveterm="$(stty -g)" -./_$(basename $0) $@ -stty $saveterm - - +t-rex-64
\ No newline at end of file diff --git a/src/bp_gtest.cpp b/src/bp_gtest.cpp index f24464e3..005801c4 100755 --- a/src/bp_gtest.cpp +++ b/src/bp_gtest.cpp @@ -31,6 +31,7 @@ limitations under the License. #include "msg_manager.h" #include <common/cgen_map.h> #include "platform_cfg.h" +#include "latency.h" int test_policer(){ CPolicer policer; @@ -623,7 +624,6 @@ TEST_F(basic, test_pcap_mode1) { EXPECT_EQ_UINT32(1, res?1:0)<< "pass"; } - /* check override the low IPG */ TEST_F(basic, test_pcap_mode2) { @@ -638,154 +638,191 @@ TEST_F(basic, test_pcap_mode2) { EXPECT_EQ_UINT32(1, res?1:0)<< "pass"; } +#define l_pkt_test_s_ip 0x01020304 +#define l_pkt_test_d_ip 0x05060708 - - - -TEST_F(basic, latency1) { - CLatencyPktInfo l; - l.Create(); - - CParserOption * po =&CGlobalInfo::m_options; - po->preview.setVMode(3); - po->preview.setFileWrite(true); - - uint8_t mac[]={0,0,0,1,0,0}; - (void)mac; - - CErfIF erf_vif; - erf_vif.set_review_mode(&CGlobalInfo::m_options.preview); - - erf_vif.open_file("exp/sctp.erf"); - - - mac[0]=0; - mac[1]=0; - mac[2]=0; - mac[3]=1; - mac[4]=0; - mac[5]=0; - - - l.set_ip(0x10000000,0x20000000,0x01000000); - - int i; - /* simulate 8 ports */ - for (i=0;i<8; i++) { - rte_mbuf_t * m=l.generate_pkt(i); - erf_vif.send_node(l.getNode()); - rte_pktmbuf_free(m); - } - - erf_vif.close_file(); - - - l.Delete(); - - CErfCmp cmp; - cmp.dump=1; - - bool res=true; - - if ( cmp.compare("exp/sctp.erf","exp/sctp-ex.erf") != true ) { - res=false; +CLatencyPktMode * +latency_pkt_mod_create(uint8_t l_pkt_mode) { + switch (l_pkt_mode) { + default: + return new CLatencyPktModeSCTP(l_pkt_mode); + break; + case L_PKT_SUBMODE_NO_REPLY: + case L_PKT_SUBMODE_REPLY: + case L_PKT_SUBMODE_0_SEQ: + return new CLatencyPktModeICMP(l_pkt_mode); + break; } - EXPECT_EQ_UINT32((uint32_t)res?1:0, (uint32_t)1)<< "pass"; } - - -TEST_F(basic, latency2) { - CLatencyPktInfo l; +rte_mbuf_t * +create_latency_test_pkt(uint8_t l_pkt_mode, uint16_t &pkt_size, uint8_t port_id, uint8_t pkt_num) { + rte_mbuf_t * m; + CLatencyPktMode *c_l_pkt_mode; CCPortLatency port0; - l.Create(); - port0.Create(0,0,l.get_payload_offset(),l.get_pkt_size(),0); - - - uint8_t mac[]={0,0,0,1,0,0}; - (void)mac; - - mac[0]=0; - mac[1]=0; - mac[2]=0; - mac[3]=1; - mac[4]=0; - mac[5]=0; - - - l.set_ip(0x01000000,0x02000000,0x01000000); - - - int i; - for (i=0; i<100; i++) { - rte_mbuf_t * m=l.generate_pkt(0); - rte_pktmbuf_mtod(m, uint8_t*); - //utl_DumpBuffer(stdout,p,l.get_pkt_size(),0); - - port0.update_packet(m); + CLatencyPktInfo info; + CLatencyManager mgr; - rte_pktmbuf_mtod(m, uint8_t*); - //utl_DumpBuffer(stdout,p,l.get_pkt_size(),0); - //printf("offset is : %d \n",l.get_payload_offset()); + c_l_pkt_mode = latency_pkt_mod_create(l_pkt_mode); - CRx_check_header * rx_p; - bool res=port0.check_packet(m,rx_p); - EXPECT_EQ_UINT32((uint32_t)res?1:0, (uint32_t)1)<< "pass"; - if (!res ) { - printf(" ERROR \n"); + mgr.c_l_pkt_mode = c_l_pkt_mode; + info.Create(c_l_pkt_mode); + port0.Create(&mgr, 0, info.get_payload_offset(), info.get_l4_offset(), info.get_pkt_size(), 0); + info.set_ip(l_pkt_test_s_ip ,l_pkt_test_d_ip, 0x01000000); + m=info.generate_pkt(0); + while (pkt_num > 0) { + pkt_num--; + port0.update_packet(m, port_id); + } + pkt_size = info.get_pkt_size(); + port0.Delete(); + info.Delete(); + delete c_l_pkt_mode; + + return m; +} + +bool +verify_latency_pkt(uint8_t *p, uint8_t proto, uint16_t icmp_seq, uint8_t icmp_type) { + EthernetHeader *eth = (EthernetHeader *)p; + IPHeader *ip = (IPHeader *)(p + 14); + uint8_t srcmac[]={0,0,0,1,0,0}; + uint8_t dstmac[]={0,0,0,1,0,0}; + latency_header * h; + + // eth + EXPECT_EQ_UINT32(eth->getNextProtocol(), 0x0800)<< "Failed ethernet next protocol check"; + EXPECT_EQ_UINT32(memcmp(p, srcmac, 6), 0)<< "Failed ethernet source MAC check"; + EXPECT_EQ_UINT32(memcmp(p, dstmac, 6), 0)<< "Failed ethernet dest MAC check"; + // IP + EXPECT_EQ_UINT32(ip->getSourceIp(), l_pkt_test_s_ip)<< "Failed IP src check"; + EXPECT_EQ_UINT32(ip->getDestIp(), l_pkt_test_d_ip)<< "Failed IP dst check"; + EXPECT_EQ_UINT32(ip->getProtocol(), proto)<< "Failed IP protocol check"; + EXPECT_EQ_UINT32(ip->isChecksumOK()?0:1, 0)<< "Failed IP checksum check"; + EXPECT_EQ_UINT32(ip->getTimeToLive(), 0xff)<< "Failed IP ttl check"; + EXPECT_EQ_UINT32(ip->getTotalLength(), 48)<< "Failed IP total length check"; + + // payload + h=(latency_header *)(p+42); + EXPECT_EQ_UINT32(h->magic, LATENCY_MAGIC)<< "Failed latency magic check"; + + if (proto == 0x84) + return true; + // ICMP + ICMPHeader *icmp = (ICMPHeader *)(p + 34); + EXPECT_EQ_UINT32(icmp->isCheckSumOk(28)?0:1, 0)<< "Failed ICMP checksum verification"; + EXPECT_EQ_UINT32(icmp->getSeqNum(), icmp_seq)<< "Failed ICMP sequence number check"; + EXPECT_EQ_UINT32(icmp->getType(), icmp_type)<< "Failed ICMP type check"; + EXPECT_EQ_UINT32(icmp->getCode(), 0)<< "Failed ICMP code check"; + EXPECT_EQ_UINT32(icmp->getId(), 0xaabb)<< "Failed ICMP ID check"; + + return true; +} + +bool +test_latency_pkt_rcv(rte_mbuf_t *m, uint8_t l_pkt_mode, uint8_t port_num, uint16_t num_pkt, bool exp_pkt_ok + , uint16_t exp_tx_seq, uint16_t exp_rx_seq) { + CLatencyPktMode *c_l_pkt_mode; + CCPortLatency port; + CLatencyPktInfo info; + CLatencyManager mgr; + CRx_check_header *rxc; + CGlobalInfo::m_options.m_l_pkt_mode = l_pkt_mode; + + c_l_pkt_mode = latency_pkt_mod_create(l_pkt_mode); + mgr.c_l_pkt_mode = c_l_pkt_mode; + info.Create(c_l_pkt_mode); + port.Create(&mgr, 0, info.get_payload_offset(), info.get_l4_offset(), info.get_pkt_size(), 0); + bool pkt_ok = port.check_packet(m, rxc); + + while (num_pkt > 0) { + num_pkt--; + if (port.can_send_packet(port_num)) { + port.update_packet(m, 0); } - rte_pktmbuf_free(m); } - port0.DumpCounters(stdout); - EXPECT_EQ_UINT32(port0.m_pkt_ok, (uint32_t)100)<< "pass"; - port0.Delete(); - l.Delete(); + EXPECT_EQ_UINT32(pkt_ok ?0:1, exp_pkt_ok?0:1)<< "Failed packet OK check"; + EXPECT_EQ_UINT32(port.get_icmp_tx_seq(), exp_tx_seq)<< "Failed tx check"; + EXPECT_EQ_UINT32(port.get_icmp_rx_seq(), exp_rx_seq)<< "Failed rx check"; + // if packet is bad, check_packet raise the error counter + EXPECT_EQ_UINT32(port.m_unsup_prot, exp_pkt_ok?0:1)<< "Failed unsupported packets count"; + + return true; } -TEST_F(basic, latency3) { - CLatencyPktInfo l; - CCPortLatency port0; - l.Create(); - port0.Create(0,0,l.get_payload_offset(),l.get_pkt_size(),0); +// Testing latency packet generation +TEST_F(basic, latency1) { + uint8_t *p; + rte_mbuf_t * m; + uint16_t pkt_size; + // SCTP packet + m = create_latency_test_pkt(0, pkt_size, 0, 1); + p=rte_pktmbuf_mtod(m, uint8_t*); + verify_latency_pkt(p, 0x84, 0, 0); + rte_pktmbuf_free(m); - uint8_t mac[]={0,0,0,1,0,0}; - (void)mac; + m = create_latency_test_pkt(L_PKT_SUBMODE_NO_REPLY, pkt_size, 1, 2); + p=rte_pktmbuf_mtod(m, uint8_t*); + verify_latency_pkt(p, 0x01, 2, 8); + rte_pktmbuf_free(m); + // ICMP reply mode client side + m = create_latency_test_pkt(L_PKT_SUBMODE_REPLY, pkt_size, 0, 3); + p = rte_pktmbuf_mtod(m, uint8_t*); + verify_latency_pkt(p, 0x01, 3, 8); + rte_pktmbuf_free(m); - mac[0]=0; - mac[1]=0; - mac[2]=0; - mac[3]=1; - mac[4]=0; - mac[5]=0; + // ICMP reply mode server side + m = create_latency_test_pkt(L_PKT_SUBMODE_REPLY, pkt_size, 1, 4); + p=rte_pktmbuf_mtod(m, uint8_t*); + verify_latency_pkt(p, 0x01, 4, 0); + rte_pktmbuf_free(m); + m = create_latency_test_pkt(L_PKT_SUBMODE_0_SEQ, pkt_size, 1, 5); + p=rte_pktmbuf_mtod(m, uint8_t*); + verify_latency_pkt(p, 0x01, 0, 8); + rte_pktmbuf_free(m); +} - l.set_ip(0x01000000,0x02000000,0x01000000); +// Testing latency packet receive path +TEST_F(basic, latency2) { + rte_mbuf_t *m; + uint16_t pkt_size; + uint8_t port_id = 0; + uint8_t pkt_num = 1; + uint8_t l_pkt_mode; - uint8_t *p; - rte_mbuf_t * m=l.generate_pkt(0); - port0.update_packet(m); - p=rte_pktmbuf_mtod(m, uint8_t*); - memset(p,0,l.get_pkt_size()); + l_pkt_mode = 0; + m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num); + test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, true, 1, 0); - CRx_check_header * rx_p; - bool res=port0.check_packet(m,rx_p); - EXPECT_EQ_UINT32((uint32_t)res?0:1, (uint32_t)1)<< "pass"; - if (!res ) { - printf(" OK \n"); - } - rte_pktmbuf_free(m); - EXPECT_EQ_UINT32(port0.m_unsup_prot, (uint32_t)1)<< "pass"; + l_pkt_mode = L_PKT_SUBMODE_NO_REPLY; + m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num); + test_latency_pkt_rcv(m, l_pkt_mode, 1, 2, true, 3, 1); - port0.Delete(); - l.Delete(); -} + // reply mode server + l_pkt_mode = L_PKT_SUBMODE_REPLY; + m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num); + test_latency_pkt_rcv(m, l_pkt_mode, 1, 2, true, 2, 1); + // reply mode client + l_pkt_mode = L_PKT_SUBMODE_REPLY; + m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num); + test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, true, 3, 1); + l_pkt_mode = L_PKT_SUBMODE_0_SEQ; + m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num); + test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, true, 0, 0); + // bad packet + m = create_latency_test_pkt(l_pkt_mode, pkt_size, port_id, pkt_num); + EthernetHeader *eth = (EthernetHeader *)rte_pktmbuf_mtod(m, uint8_t*); + eth->setNextProtocol(0x5); + test_latency_pkt_rcv(m, l_pkt_mode, 0, 2, false, 1, 0); +} class CDummyLatencyHWBase : public CPortLatencyHWBase { public: @@ -835,21 +872,8 @@ public: uint8_t m_port_id; }; - - -TEST_F(basic, latency4) { - - uint8_t mac[]={0,0,0,1,0,0}; - (void)mac; - - mac[0]=0; - mac[1]=0; - mac[2]=0; - mac[3]=1; - mac[4]=0; - mac[5]=0; - - +// Testing latency statistics functions +TEST_F(basic, latency3) { CLatencyManager mg; CLatencyManagerCfg cfg; CDummyLatencyHWBase dports[MAX_LATENCY_PORTS]; @@ -882,7 +906,6 @@ TEST_F(basic, latency4) { mg.Delete(); } - TEST_F(basic, hist1) { CTimeHistogram hist1; @@ -902,8 +925,6 @@ TEST_F(basic, hist1) { hist1.Delete(); } - - TEST_F(basic, rtsp1) { CTestBasic t1; diff --git a/src/bp_sim.cpp b/src/bp_sim.cpp index ed729c75..84dd9c56 100755 --- a/src/bp_sim.cpp +++ b/src/bp_sim.cpp @@ -20,6 +20,7 @@ limitations under the License. */ #include "bp_sim.h" +#include "latency.h" #include "utl_json.h" #include "utl_yaml.h" #include "msg_manager.h" @@ -1311,7 +1312,6 @@ bool CPacketIndication::ConvertPacketToIpv6InPlace(CCapPktRaw * pkt, return (true); } - void CPacketIndication::ProcessPacket(CPacketParser *parser, CCapPktRaw * pkt){ _ProcessPacket(parser,pkt); @@ -1320,8 +1320,6 @@ void CPacketIndication::ProcessPacket(CPacketParser *parser, } } - - /* process packet */ void CPacketIndication::_ProcessPacket(CPacketParser *parser, CCapPktRaw * pkt){ @@ -4730,900 +4728,10 @@ int CErfIF::send_node(CGenNode * node){ return (0); } - int CErfIF::flush_tx_queue(void){ return (0); } - - -const uint8_t sctp_pkt[]={ - - 0x00,0x04,0x96,0x08,0xe0,0x40, - 0x00,0x0e,0x2e,0x24,0x37,0x5f, - 0x08,0x00, - - 0x45,0x02,0x00,0x30, - 0x00,0x00,0x40,0x00, - 0x40,0x84,0xbd,0x04, - 0x9b,0xe6,0x18,0x9b, //sIP - 0xcb,0xff,0xfc,0xc2, //DIP - - 0x80,0x44,//SPORT - 0x00,0x50,//DPORT - - 0x00,0x00,0x00,0x00, //checksum - - 0x11,0x22,0x33,0x44, // magic - 0x00,0x00,0x00,0x00, //64 bit counter - 0x00,0x00,0x00,0x00, - 0x00,0x01,0xa0,0x00, //seq - 0x00,0x00,0x00,0x00, - -}; - -// 20+8+20` - -void CLatencyPktInfo::Create(){ - m_packet = new CCapPktRaw( sizeof(sctp_pkt) ); - m_packet->pkt_cnt=0; - m_packet->time_sec=0; - m_packet->time_nsec=0; - memcpy(m_packet->raw,sctp_pkt,sizeof(sctp_pkt)); - m_packet->pkt_len=sizeof(sctp_pkt); - - m_pkt_indication.m_packet =m_packet; - - m_pkt_indication.m_ether = (EthernetHeader *)m_packet->raw; - m_pkt_indication.l3.m_ipv4=(IPHeader *)(m_packet->raw+14); - m_pkt_indication.m_is_ipv6 = false; - m_pkt_indication.l4.m_udp=(UDPHeader *)m_packet->raw+14+20; - m_pkt_indication.m_payload=(uint8_t *)m_packet->raw+14+20+16; - m_pkt_indication.m_payload_len=0; - m_pkt_indication.m_packet_padding=4; - - - m_pkt_indication.m_ether_offset =0; - m_pkt_indication.m_ip_offset =14; - m_pkt_indication.m_udp_tcp_offset = 34; - m_pkt_indication.m_payload_offset = 34+8; - - CPacketDescriptor * lpd=&m_pkt_indication.m_desc; - lpd->Clear(); - lpd->SetInitSide(true); - lpd->SetSwapTuple(false); - lpd->SetIsValidPkt(true); - lpd->SetIsUdp(true); - lpd->SetIsLastPkt(true); - m_pkt_info.Create(&m_pkt_indication); - - memset(&m_dummy_node,0,sizeof(m_dummy_node)); - - m_dummy_node.set_socket_id( CGlobalInfo::m_socket.port_to_socket(0) ); - - m_dummy_node.m_time =0.1; - m_dummy_node.m_pkt_info = &m_pkt_info; - m_dummy_node.m_dest_ip = 0; - m_dummy_node.m_src_ip = 0; - m_dummy_node.m_src_port = 0x11; - m_dummy_node.m_flow_id =0; - m_dummy_node.m_flags =CGenNode::NODE_FLAGS_LATENCY; - -} - - -rte_mbuf_t * CLatencyPktInfo::generate_pkt(int port_id,uint32_t extern_ip){ - - bool is_client_to_serever=(port_id%2==0)?true:false; - - int dual_port_index=(port_id>>1); - uint32_t c=m_client_ip.v4; - uint32_t s=m_server_ip.v4; - if ( extern_ip ){ - c=extern_ip; - } - - if (!is_client_to_serever) { - /*swap */ - uint32_t t=c; - c=s; - s=t; - } - uint32_t mask=dual_port_index*m_dual_port_mask; - if ( extern_ip==0 ){ - c+=mask; - } - s+=mask; - m_dummy_node.m_src_ip = c; - m_dummy_node.m_dest_ip = s; - - rte_mbuf_t * m=m_pkt_info.generate_new_mbuf(&m_dummy_node); - return (m); - - -} - - -void CLatencyPktInfo::set_ip(uint32_t src, - uint32_t dst, - uint32_t dual_port_mask){ - - m_client_ip.v4=src; - m_server_ip.v4=dst; - m_dual_port_mask=dual_port_mask; - -} - - -void CLatencyPktInfo::Delete(){ - m_pkt_info.Delete(); - delete m_packet; -} - -void CCPortLatency::reset(){ - m_rx_seq =m_tx_seq; - m_pad = 0; - - m_tx_pkt_err=0; - m_tx_pkt_ok =0; - m_pkt_ok=0; - m_rx_check=0; - m_no_magic=0; - m_unsup_prot=0; - m_no_id=0; - m_seq_error=0; - m_length_error=0; - m_no_ipv4_option=0; - m_hist.Reset(); -} - - -static uint8_t nat_is_port_can_send(uint8_t port_id){ - uint8_t client_index = (port_id %2); - return (client_index ==0 ?1:0); -} - - -bool CCPortLatency::Create(CLatencyManager * parent, - uint8_t id, - uint16_t offset, - uint16_t pkt_size, - CCPortLatency * rx_port){ - m_parent = parent; - m_id = id; - m_tx_seq =0x12345678; - m_offset = offset; - m_pkt_size = pkt_size; - m_rx_port = rx_port; - m_nat_can_send = nat_is_port_can_send(m_id); - m_nat_learn = m_nat_can_send; - m_nat_external_ip=0; - - m_hist.Create(); - reset(); - return (true); -} - -void CCPortLatency::Delete(){ - m_hist.Delete(); -} - -void CCPortLatency::update_packet(rte_mbuf_t * m){ - uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*); - /* update mac addr dest/src 12 bytes */ - memcpy(p,CGlobalInfo::m_options.get_dst_src_mac_addr(m_id),12); - - latency_header * h=(latency_header *)(p+m_offset); - h->magic = LATENCY_MAGIC | m_id ; - h->time_stamp = os_get_hr_tick_64(); - h->seq = m_tx_seq; - m_tx_seq++; -} - - -void CCPortLatency::DumpShortHeader(FILE *fd){ - - - fprintf(fd," if| tx_ok , rx_ok , rx ,error, average , max , Jitter , max window \n"); - fprintf(fd," | , , check, , latency(usec),latency (usec) ,(usec) , \n"); - fprintf(fd," ---------------------------------------------------------------------------------------------------------------- \n"); -} - - - -std::string CCPortLatency::get_field(std::string name,float f){ - char buff[200]; - sprintf(buff,"\"%s-%d\":%.1f,",name.c_str(),m_id,f); - return (std::string(buff)); -} - - -void CCPortLatency::dump_json_v2(std::string & json ){ - char buff[200]; - sprintf(buff,"\"port-%d\": {",m_id); - json+=std::string(buff); - m_hist.dump_json("hist",json); - dump_counters_json(json); - json+="},"; -} - -void CCPortLatency::dump_json(std::string & json ){ - json += get_field("avg",m_hist.get_average_latency() ); - json += get_field("max",m_hist.get_max_latency() ); - json += get_field("c-max",m_hist.get_max_latency_last_update() ); - json += get_field("error",(float)(m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error) ); - json += get_field("jitter",(float)get_jitter_usec() ); -} - - -void CCPortLatency::DumpShort(FILE *fd){ - - m_hist.update(); - fprintf(fd,"%8lu,%8lu,%10lu,%4lu,", - m_tx_pkt_ok, - m_pkt_ok, - m_rx_check, - m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error+m_no_ipv4_option+m_tx_pkt_err - ); - - fprintf(fd," %8.0f ,%8.0f,%8d ", - m_hist.get_average_latency(), - m_hist.get_max_latency(), - get_jitter_usec() - ); - fprintf(fd," | "); - m_hist.DumpWinMax(fd); - -} - -#define DPL_J(f) json+=add_json(#f,f); -#define DPL_J_LAST(f) json+=add_json(#f,f,true); - -void CCPortLatency::dump_counters_json(std::string & json ){ - - json+="\"stats\" : {"; - DPL_J(m_tx_pkt_ok); - DPL_J(m_tx_pkt_err); - DPL_J(m_pkt_ok); - DPL_J(m_unsup_prot); - DPL_J(m_no_magic); - DPL_J(m_no_id); - DPL_J(m_seq_error); - DPL_J(m_length_error); - DPL_J(m_no_ipv4_option); - json+=add_json("m_jitter",get_jitter_usec()); - /* must be last */ - DPL_J_LAST(m_rx_check); - json+="}"; - - -} - -void CCPortLatency::DumpCounters(FILE *fd){ - #define DP_A1(f) if (f) fprintf(fd," %-40s : %llu \n",#f, (unsigned long long)f) - - fprintf(fd," counter \n"); - fprintf(fd," -----------\n"); - - DP_A1(m_tx_pkt_err); - DP_A1(m_tx_pkt_ok); - DP_A1(m_pkt_ok); - DP_A1(m_unsup_prot); - DP_A1(m_no_magic); - DP_A1(m_no_id); - DP_A1(m_seq_error); - DP_A1(m_length_error); - DP_A1(m_rx_check); - DP_A1(m_no_ipv4_option); - - - fprintf(fd," -----------\n"); - m_hist.Dump(fd); - fprintf(fd," %-40s : %lu \n","jitter", (ulong)get_jitter_usec()); -} - -bool CCPortLatency::dump_packet(rte_mbuf_t * m){ - fprintf(stdout," %f.03 dump packet ..\n",now_sec()); - uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*); - uint16_t pkt_size=rte_pktmbuf_pkt_len(m); - utl_DumpBuffer(stdout,p,pkt_size,0); - return (0); - - - - if (pkt_size < ( sizeof(CRx_check_header)+14+20) ) { - assert(0); - } - CRx_check_header * lp=(CRx_check_header *)(p+pkt_size-sizeof(CRx_check_header)); - - lp->dump(stdout); - - - uint16_t vlan_offset=0; - if ( unlikely( CGlobalInfo::m_options.preview.get_vlan_mode_enable() ) ){ - vlan_offset=4; - } - - (void)vlan_offset; - -// utl_DumpBuffer(stdout,p,pkt_size,0); - return (0); - -} - -bool CCPortLatency::check_rx_check(rte_mbuf_t * m){ - m_rx_check++; - return (true); -} - -bool CCPortLatency::do_learn(uint32_t external_ip){ - m_nat_learn=true; - m_nat_can_send=true; - m_nat_external_ip=external_ip; - return (true); -} - -bool CCPortLatency::check_packet(rte_mbuf_t * m,CRx_check_header * & rx_p){ - - CSimplePacketParser parser(m); - if ( !parser.Parse() ){ - m_unsup_prot++; // Unsupported protocol - return (false); - } - - uint16_t pkt_size=rte_pktmbuf_pkt_len(m); - /* check if CRC was extracted */ - if ( parser.getPktSize() == pkt_size-4) { - // CRC was not extracted by driver (VM E1000 driver issue) extract it - pkt_size=pkt_size-4; - } - - uint16_t vlan_offset=parser.m_vlan_offset; - uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*); - - rx_p = (CRx_check_header *)0; - - if ( !parser.IsLatencyPkt() ){ - - #ifdef NAT_TRACE_ - printf(" %.3f RX : got packet !!! \n",now_sec() ); - #endif - - /* ipv6+rx-check */ - if ( parser.m_ipv6 ) { - /* if we have ipv6 packet */ - if (parser.m_protocol == RX_CHECK_V6_OPT_TYPE) { - if ( get_is_rx_check_mode() ){ - m_rx_check++; - rx_p=(CRx_check_header *)((uint8_t*)parser.m_ipv6 +IPv6Header::DefaultSize); - return (true); - } - - } - m_seq_error++; - return (false); - } - - uint8_t opt_len = parser.m_ipv4->getOptionLen(); - uint8_t *opt_ptr = parser.m_ipv4->getOption(); - /* Process IP option header(s) */ - while ( opt_len != 0 ) { - switch (*opt_ptr) { - case RX_CHECK_V4_OPT_TYPE: - /* rx-check option header */ - if ( ( !get_is_rx_check_mode() ) || - (opt_len < RX_CHECK_LEN) ) { - m_seq_error++; - return (false); - } - m_rx_check++; - rx_p=(CRx_check_header *)opt_ptr; - opt_len -= RX_CHECK_LEN; - opt_ptr += RX_CHECK_LEN; - break; - case CNatOption::noIPV4_OPTION: - /* NAT learn option header */ - CNatOption *lp; - if ( ( !CGlobalInfo::is_learn_mode() ) || - (opt_len < CNatOption::noOPTION_LEN) ) { - m_seq_error++; - return (false); - } - lp = (CNatOption *)opt_ptr; - if ( !lp->is_valid_ipv4_magic() ) { - m_no_ipv4_option++; - return (false); - } - m_parent->get_nat_manager()->handle_packet_ipv4(lp,parser.m_ipv4); - opt_len -= CNatOption::noOPTION_LEN; - opt_ptr += CNatOption::noOPTION_LEN; - break; - default: - m_seq_error++; - return (false); - } // End of switch - } // End of while - - return (true); - } // End of check for non-latency packet - - if ( CGlobalInfo::is_learn_mode() && (m_nat_learn ==false) ) { - do_learn(parser.m_ipv4->getSourceIp()); - } - - if ( (pkt_size-vlan_offset) != m_pkt_size ) { - m_length_error++; - return (false); - } - - latency_header * h=(latency_header *)(p+m_offset+vlan_offset); - - if ( (h->magic & 0xffffff00) != LATENCY_MAGIC ){ - m_no_magic++; - return (false); - } - - if ( h->seq != m_rx_seq ){ - m_seq_error++; - m_rx_seq =h->seq +1; - return (false); - }else{ - m_rx_seq++; - } - m_pkt_ok++; - uint64_t d = (os_get_hr_tick_64() - h->time_stamp ); - dsec_t ctime=ptime_convert_hr_dsec(d); - m_hist.Add(ctime); - m_jitter.calc(ctime); - return (true); -} - -void CLatencyManager::Delete(){ - m_pkt_gen.Delete(); - - if ( get_is_rx_check_mode() ) { - m_rx_check_manager.Delete(); - } - if ( CGlobalInfo::is_learn_mode() ){ - m_nat_check_manager.Delete(); - } - m_cpu_cp_u.Delete(); -} - -/* 0->1 - 1->0 - 2->3 - 3->2 -*/ -static uint8_t swap_port(uint8_t port_id){ - uint8_t offset= ((port_id>>1)<<1); - uint8_t client_index = (port_id %2); - return (offset + (client_index ^ 1)); -} - - - -bool CLatencyManager::Create(CLatencyManagerCfg * cfg){ - m_max_ports=cfg->m_max_ports; - assert (m_max_ports<=MAX_LATENCY_PORTS); - assert ((m_max_ports%2)==0); - m_port_mask =0xffffffff; - m_do_stop =false; - m_is_active =false; - m_pkt_gen.Create(); - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - CCPortLatency * lpo=&m_ports[swap_port(i)].m_port; - - lp->m_io=cfg->m_ports[i]; - lp->m_port.Create(this, - i, - m_pkt_gen.get_payload_offset(), - m_pkt_gen.get_pkt_size(),lpo ); - } - m_cps= cfg->m_cps; - m_d_time =ptime_convert_dsec_hr((1.0/m_cps)); - m_delta_sec =(1.0/m_cps); - - - if ( get_is_rx_check_mode() ) { - assert(m_rx_check_manager.Create()); - m_rx_check_manager.m_cur_time= now_sec(); - } - - - m_pkt_gen.set_ip(cfg->m_client_ip.v4,cfg->m_server_ip.v4,cfg->m_dual_port_mask); - m_cpu_cp_u.Create(&m_cpu_dp_u); - if ( CGlobalInfo::is_learn_mode() ){ - m_nat_check_manager.Create(); - } - return (true); -} - - -void CLatencyManager::send_pkt_all_ports(){ - m_start_time = os_get_hr_tick_64(); - int i; - for (i=0; i<m_max_ports; i++) { - if ( m_port_mask & (1<<i) ){ - CLatencyManagerPerPort * lp=&m_ports[i]; - if (lp->m_port.can_send_packet() ){ - rte_mbuf_t * m=m_pkt_gen.generate_pkt(i,lp->m_port.external_nat_ip()); - lp->m_port.update_packet(m); - if ( lp->m_io->tx(m) == 0 ){ - lp->m_port.m_tx_pkt_ok++; - }else{ - lp->m_port.m_tx_pkt_err++; - } - - } - } - } -} - - -void CLatencyManager::wait_for_rx_dump(){ - rte_mbuf_t * rx_pkts[64]; - int i; - while ( true ) { - rte_pause(); - rte_pause(); - rte_pause(); - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - rte_mbuf_t * m; - uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64); - if (cnt_p) { - int j; - for (j=0; j<cnt_p; j++) { - m=rx_pkts[j] ; - lp->m_port.dump_packet( m); - rte_pktmbuf_free(m); - } - } /*cnt_p*/ - }/* for*/ - } -} - - -void CLatencyManager::handle_rx_pkt(CLatencyManagerPerPort * lp, - rte_mbuf_t * m){ - CRx_check_header *rxc; - lp->m_port.check_packet(m,rxc); - if ( unlikely(rxc!=NULL) ){ - m_rx_check_manager.handle_packet(rxc); - } - rte_pktmbuf_free(m); -} - -void CLatencyManager::handle_latecy_pkt_msg(uint8_t thread_id, - CGenNodeLatencyPktInfo * msg){ - - assert(msg->m_latency_offset==0xdead); - - uint8_t rx_port_index=(thread_id<<1)+(msg->m_dir&1); - assert( rx_port_index <m_max_ports ) ; - CLatencyManagerPerPort * lp=&m_ports[rx_port_index]; - handle_rx_pkt(lp,(rte_mbuf_t *)msg->m_pkt); -} - - -void CLatencyManager::run_rx_queue_msgs(uint8_t thread_id, - CNodeRing * r){ - - while ( true ) { - CGenNode * node; - if ( r->Dequeue(node)!=0 ){ - break; - } - assert(node); - - CGenNodeMsgBase * msg=(CGenNodeMsgBase *)node; - - uint8_t msg_type = msg->m_msg_type; - switch (msg_type ) { - case CGenNodeMsgBase::LATENCY_PKT: - handle_latecy_pkt_msg(thread_id,(CGenNodeLatencyPktInfo *) msg); - break; - default: - printf("ERROR latency-thread message type is not valid %d \n",msg_type); - assert(0); - } - - CGlobalInfo::free_node(node); - } -} - -void CLatencyManager::try_rx_queues(){ - - CMessagingManager * rx_dp = CMsgIns::Ins()->getRxDp(); - uint8_t threads=CMsgIns::Ins()->get_num_threads(); - int ti; - for (ti=0; ti<(int)threads; ti++) { - CNodeRing * r = rx_dp->getRingDpToCp(ti); - if ( !r->isEmpty() ){ - run_rx_queue_msgs((uint8_t)ti,r); - } - } -} - - -void CLatencyManager::try_rx(){ - rte_mbuf_t * rx_pkts[64]; - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - rte_mbuf_t * m; - m_cpu_dp_u.start_work(); - /* try to read 64 packets clean up the queue */ - uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64); - if (cnt_p) { - int j; - for (j=0; j<cnt_p; j++) { - m=rx_pkts[j] ; - handle_rx_pkt(lp,m); - } - /* commit only if there was work to do ! */ - m_cpu_dp_u.commit(); - }/* if work */ - }// all ports -} - - -void CLatencyManager::reset(){ - - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - lp->m_port.reset(); - } - -} - -void CLatencyManager::start(int iter){ - m_do_stop =false; - m_is_active =false; - int cnt=0; - - double n_time; - CGenNode * node = new CGenNode(); - node->m_type = CGenNode::FLOW_SYNC; /* general stuff */ - node->m_time = now_sec()+0.007; - m_p_queue.push(node); - - node = new CGenNode(); - node->m_type = CGenNode::FLOW_PKT; /* latency */ - node->m_time = now_sec(); /* 1/cps rate */ - m_p_queue.push(node); - bool do_try_rx_queue =CGlobalInfo::m_options.preview.get_vm_one_queue_enable()?true:false; - - - while ( !m_p_queue.empty() ) { - node = m_p_queue.top(); - n_time = node->m_time; - - /* wait for event */ - while ( true ) { - double dt = now_sec() - n_time ; - if (dt> (0.0)) { - break; - } - if (do_try_rx_queue){ - try_rx_queues(); - } - try_rx(); - rte_pause(); - } - - switch (node->m_type) { - case CGenNode::FLOW_SYNC: - if ( CGlobalInfo::is_learn_mode() ) { - m_nat_check_manager.handle_aging(); - } - - m_p_queue.pop(); - node->m_time += SYNC_TIME_OUT; - m_p_queue.push(node); - - break; - case CGenNode::FLOW_PKT: - m_cpu_dp_u.start_work(); - send_pkt_all_ports(); - m_p_queue.pop(); - node->m_time += m_delta_sec; - m_p_queue.push(node); - m_cpu_dp_u.commit(); - break; - } - - /* this will be called every sync which is 1msec */ - if ( m_do_stop ) { - break; - } - if ( iter>0 ){ - if ( ( cnt>iter) ){ - printf("stop due iter %d\n",iter); - break; - } - } - cnt++; - } - - /* free all nodes in the queue */ - while (!m_p_queue.empty()) { - node = m_p_queue.top(); - m_p_queue.pop(); - delete node; - } - - printf(" latency daemon has stopped\n"); - if ( get_is_rx_check_mode() ) { - m_rx_check_manager.tw_drain(); - } - -} - -void CLatencyManager::stop(){ - m_do_stop =true; -} - -bool CLatencyManager::is_active(){ - return (m_is_active); -} - - -double CLatencyManager::get_max_latency(){ - double l=0.0; - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - if ( l <lp->m_port.m_hist.get_max_latency() ){ - l=lp->m_port.m_hist.get_max_latency(); - } - } - return (l); -} - -double CLatencyManager::get_avr_latency(){ - double l=0.0; - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - if ( l <lp->m_port.m_hist.get_average_latency() ){ - l=lp->m_port.m_hist.get_average_latency(); - } - } - return (l); -} - -uint64_t CLatencyManager::get_total_pkt(){ - int i; - uint64_t t=0; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - t+=lp->m_port.m_tx_pkt_ok ; - } - return t; -} - -uint64_t CLatencyManager::get_total_bytes(){ - int i; - uint64_t t=0; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - t+=lp->m_port.m_tx_pkt_ok* (m_pkt_gen.get_pkt_size()+4); - } - return t; - -} - - -bool CLatencyManager::is_any_error(){ - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - if ( lp->m_port.is_any_err() ){ - return (true); - } - } - return (false); -} - - -void CLatencyManager::dump_json(std::string & json ){ - json="{\"name\":\"trex-latecny\",\"type\":0,\"data\":{"; - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - lp->m_port.dump_json(json); - } - - json+="\"unknown\":0}}" ; - -} - -void CLatencyManager::dump_json_v2(std::string & json ){ - json="{\"name\":\"trex-latecny-v2\",\"type\":0,\"data\":{"; - json+=add_json("cpu_util",m_cpu_cp_u.GetVal()); - - int i; - for (i=0; i<m_max_ports; i++) { - CLatencyManagerPerPort * lp=&m_ports[i]; - lp->m_port.dump_json_v2(json); - } - - json+="\"unknown\":0}}" ; - -} - -void CLatencyManager::DumpRxCheck(FILE *fd){ - if ( get_is_rx_check_mode() ) { - fprintf(fd," rx checker : \n"); - m_rx_check_manager.DumpShort(fd); - m_rx_check_manager.Dump(fd); - } -} - -void CLatencyManager::DumpShortRxCheck(FILE *fd){ - if ( get_is_rx_check_mode() ) { - m_rx_check_manager.DumpShort(fd); - } -} - -void CLatencyManager::rx_check_dump_json(std::string & json){ - if ( get_is_rx_check_mode() ) { - m_rx_check_manager.dump_json(json ); - } -} - -void CLatencyManager::update(){ - m_cpu_cp_u.Update() ; -} - -void CLatencyManager::DumpShort(FILE *fd){ - int i; - fprintf(fd," Cpu Utilization : %2.1f %% \n",m_cpu_cp_u.GetVal()); - CCPortLatency::DumpShortHeader(fd); - for (i=0; i<m_max_ports; i++) { - fprintf(fd," %d | ",i); - CLatencyManagerPerPort * lp=&m_ports[i]; - lp->m_port.DumpShort(fd); - fprintf(fd,"\n"); - } - - -} - -void CLatencyManager::Dump(FILE *fd){ - int i; - fprintf(fd," cpu : %2.1f %% \n",m_cpu_cp_u.GetVal()); - for (i=0; i<m_max_ports; i++) { - fprintf(fd," port %d \n",i); - fprintf(fd," -----------------\n"); - CLatencyManagerPerPort * lp=&m_ports[i]; - lp->m_port.DumpCounters(fd); - } -} - -void CLatencyManager::DumpRxCheckVerification(FILE *fd, - uint64_t total_tx_rx_check){ - if ( !get_is_rx_check_mode() ) { - fprintf(fd," rx_checker is disabled \n"); - return; - } - fprintf(fd," rx_check Tx : %llu \n", (unsigned long long)total_tx_rx_check); - fprintf(fd," rx_check Rx : %llu \n", (unsigned long long)m_rx_check_manager.getTotalRx() ); - fprintf(fd," rx_check verification :" ); - if (m_rx_check_manager.getTotalRx() == total_tx_rx_check) { - fprintf(fd," OK \n" ); - }else{ - fprintf(fd," FAIL \n" ); - } -} - - - void CTcpSeq::update(uint8_t *p, CFlowPktInfo *pkt_info, int16_t s_size){ TCPHeader *tcp= (TCPHeader *)(p+pkt_info->m_pkt_indication.getFastTcpOffset()); uint32_t seqnum, acknum; @@ -6876,6 +5984,7 @@ bool CSimplePacketParser::Parse(){ case EthernetHeader::Protocol::IP : // IPv4 packet ipv4=(IPHeader *)(p+14); + m_l4 = (uint8_t *)ipv4 + ipv4->getHeaderLength(); protocol = ipv4->getProtocol(); m_option_offset = 14 + IPV4_HDR_LEN; break; @@ -6891,6 +6000,7 @@ bool CSimplePacketParser::Parse(){ case EthernetHeader::Protocol::IP: // IPv4 packet ipv4=(IPHeader *)(p+18); + m_l4 = (uint8_t *)ipv4 + ipv4->getHeaderLength(); protocol = ipv4->getProtocol(); m_option_offset = 18+ IPV4_HDR_LEN; break; @@ -6940,7 +6050,3 @@ void CGenNodeBase::free_base(){ } - - - - diff --git a/src/bp_sim.h b/src/bp_sim.h index b71cb3ff..da8e8780 100755 --- a/src/bp_sim.h +++ b/src/bp_sim.h @@ -37,6 +37,7 @@ limitations under the License. #include <string> #include <common/Network/Packet/TcpHeader.h> #include <common/Network/Packet/UdpHeader.h> +#include <common/Network/Packet/IcmpHeader.h> #include <common/Network/Packet/IPHeader.h> #include <common/Network/Packet/IPv6Header.h> #include <common/Network/Packet/EthernetHeader.h> @@ -749,6 +750,7 @@ public: prefix=""; m_mac_splitter=0; m_run_mode = RUN_MODE_INVALID; + m_l_pkt_mode = 0; } @@ -771,7 +773,7 @@ public: uint16_t m_io_mode; //0,1,2 0 disable, 1- normal , 2 - short uint16_t m_run_flags; uint8_t m_mac_splitter; - uint8_t m_pad; + uint8_t m_l_pkt_mode; trex_run_mode_e m_run_mode; @@ -828,6 +830,9 @@ public: return ( (m_run_flags &RUN_FLAGS_RXCHECK_CONST_TS)?true:false ); } + inline uint8_t get_l_pkt_mode(){ + return (m_l_pkt_mode); + } void dump(FILE *fd); }; @@ -1237,7 +1242,8 @@ static inline int get_is_rx_check_mode(){ } static inline bool get_is_rx_filter_enable(){ - return ( ( get_is_rx_check_mode() || CGlobalInfo::is_learn_mode()) ?true:false ); + uint32_t latency_rate=CGlobalInfo::m_options.m_latency_rate; + return ( ( get_is_rx_check_mode() || CGlobalInfo::is_learn_mode() || latency_rate != 0) ?true:false ); } static inline uint16_t get_rx_check_hops() { return (CGlobalInfo::m_options.m_rx_check_hops); @@ -2061,11 +2067,8 @@ inline bool CFlowKey::operator ==(const CFlowKey& rhs) const{ #define IS_VALID_S 1 #define IS_VALID_E 1 -#define IS_TCP_S 2 -#define IS_TCP_E 2 - -#define IS_UDP_S 3 -#define IS_UDP_E 3 +#define PROTO_S 3 +#define PROTO_E 2 #define IS_INIT_SIDE 4 @@ -2235,19 +2238,27 @@ public: } inline void SetIsTcp(bool is_valid){ - btSetMaskBit32(m_flags,IS_TCP_S,IS_TCP_E,is_valid?1:0); + btSetMaskBit32(m_flags,PROTO_S,PROTO_E,is_valid?1:0); } inline bool IsTcp(){ - return (btGetMaskBit32(m_flags,IS_TCP_S,IS_TCP_E) ? true:false); + return ((btGetMaskBit32(m_flags,PROTO_S,PROTO_E) == 1) ? true:false); } inline void SetIsUdp(bool is_valid){ - btSetMaskBit32(m_flags,IS_UDP_S,IS_UDP_E,is_valid?1:0); + btSetMaskBit32(m_flags,PROTO_S,PROTO_E,is_valid?2:0); } inline bool IsUdp(){ - return (btGetMaskBit32(m_flags,IS_UDP_S,IS_UDP_E) ? true:false); + return ((btGetMaskBit32(m_flags,PROTO_S,PROTO_E) == 2) ? true:false); + } + + inline void SetIsIcmp(bool is_valid){ + btSetMaskBit32(m_flags,PROTO_S,PROTO_E,is_valid?3:0); + } + + inline bool IsIcmp(){ + return ((btGetMaskBit32(m_flags,PROTO_S,PROTO_E) == 3) ? true:false); } inline void SetId(uint16_t _id){ @@ -2379,6 +2390,7 @@ public: union { TCPHeader * m_tcp; UDPHeader * m_udp; + ICMPHeader * m_icmp; } l4; uint8_t * m_payload; uint16_t m_payload_len; @@ -2902,7 +2914,11 @@ inline void CFlowPktInfo::update_pkt_info(char *p, m_udp->setDestPort(src_port); } }else{ - BP_ASSERT(0); +#ifdef _DEBUG + if (!m_pkt_indication.m_desc.IsIcmp()) { + BP_ASSERT(0); + } +#endif } } } @@ -3733,312 +3749,6 @@ inline void CFlowGeneratorRecPerThread::generate_flow(CNodeGenerator * gen, node); } - - -class CLatencyPktInfo { -public: - void Create(); - void Delete(); - void set_ip(uint32_t src, - uint32_t dst, - uint32_t dual_port_mask); - rte_mbuf_t * generate_pkt(int port_id,uint32_t extern_ip=0); - - CGenNode * getNode(){ - return (&m_dummy_node); - } - - uint16_t get_payload_offset(void){ - return ( m_pkt_indication.getFastPayloadOffset()); - } - - uint16_t get_pkt_size(void){ - return ( m_packet->pkt_len ); - } - -private: - ipaddr_t m_client_ip; - ipaddr_t m_server_ip; - uint32_t m_dual_port_mask; - - CGenNode m_dummy_node; - CFlowPktInfo m_pkt_info; - CPacketIndication m_pkt_indication; - CCapPktRaw * m_packet; -}; - - -#define LATENCY_MAGIC 0x12345600 - -struct latency_header { - - uint64_t time_stamp; - uint32_t magic; - uint32_t seq; - - uint8_t get_id(){ - return( magic & 0xff); - } -}; - - -class CSimplePacketParser { -public: - - CSimplePacketParser(rte_mbuf_t * m){ - m_m=m; - } - - bool Parse(); - uint8_t getTTl(); - uint16_t getPktSize(); - - - - inline bool IsLatencyPkt(){ - return ( (m_protocol ==0x84 )?true:false ); - } - - -public: - IPHeader * m_ipv4; - IPv6Header * m_ipv6; - uint8_t m_protocol; - uint16_t m_vlan_offset; - uint16_t m_option_offset; -private: - rte_mbuf_t * m_m ; -}; - - - -class CLatencyManager ; -// per port -class CCPortLatency { -public: - bool Create(CLatencyManager * parent, - uint8_t id, - uint16_t offset, - uint16_t pkt_size, - CCPortLatency * rx_port - ); - void Delete(); - void reset(); - bool can_send_packet(){ - if ( !CGlobalInfo::is_learn_mode() ) { - return(true); - } - return ( m_nat_can_send ); - } - uint32_t external_nat_ip(){ - return (m_nat_external_ip); - } - - void update_packet(rte_mbuf_t * m); - - bool do_learn(uint32_t external_ip); - - bool check_packet(rte_mbuf_t * m, - CRx_check_header * & rx_p); - bool check_rx_check(rte_mbuf_t * m); - - - bool dump_packet(rte_mbuf_t * m); - - void DumpCounters(FILE *fd); - void dump_counters_json(std::string & json ); - - void DumpShort(FILE *fd); - void dump_json(std::string & json ); - void dump_json_v2(std::string & json ); - - uint32_t get_jitter_usec(void){ - return ((uint32_t)(m_jitter.get_jitter()*1000000.0)); - } - - - static void DumpShortHeader(FILE *fd); - - bool is_any_err(){ - if ( (m_tx_pkt_ok == m_rx_port->m_pkt_ok ) && - - ((m_unsup_prot+ - m_no_magic+ - m_no_id+ - m_seq_error+ - m_length_error+m_no_ipv4_option+m_tx_pkt_err)==0) ) { - return (false); - } - return (true); - } - -private: - std::string get_field(std::string name,float f); - - - -private: - CLatencyManager * m_parent; - CCPortLatency * m_rx_port; /* corespond rx port */ - bool m_nat_learn; - bool m_nat_can_send; - uint32_t m_nat_external_ip; - - uint32_t m_tx_seq; - uint32_t m_rx_seq; - - uint8_t m_pad; - uint8_t m_id; - uint16_t m_offset; - - uint16_t m_pkt_size; - uint16_t pad1[3]; - -public: - uint64_t m_tx_pkt_ok; - uint64_t m_tx_pkt_err; - - uint64_t m_pkt_ok; - uint64_t m_unsup_prot; - uint64_t m_no_magic; - uint64_t m_no_id; - uint64_t m_seq_error; - uint64_t m_rx_check; - uint64_t m_no_ipv4_option; - - - uint64_t m_length_error; - CTimeHistogram m_hist; /* all window */ - CJitter m_jitter; -}; - - -class CPortLatencyHWBase { -public: - virtual int tx(rte_mbuf_t * m)=0; - virtual rte_mbuf_t * rx()=0; - virtual uint16_t rx_burst(struct rte_mbuf **rx_pkts, - uint16_t nb_pkts){ - return(0); - } -}; - - -class CLatencyManagerCfg { -public: - CLatencyManagerCfg (){ - m_max_ports=0; - m_cps=0.0; - m_client_ip.v4=0x10000000; - m_server_ip.v4=0x20000000; - m_dual_port_mask=0x01000000; - } - uint32_t m_max_ports; - double m_cps;// CPS - CPortLatencyHWBase * m_ports[MAX_LATENCY_PORTS]; - ipaddr_t m_client_ip; - ipaddr_t m_server_ip; - uint32_t m_dual_port_mask; - -}; - - - -class CLatencyManagerPerPort { -public: - CCPortLatency m_port; - CPortLatencyHWBase * m_io; - uint32_t m_flag; - -}; - - -class CLatencyManager { -public: - bool Create(CLatencyManagerCfg * cfg); - void Delete(); - -public: - void reset(); - void start(int iter); - void stop(); - bool is_active(); - - void set_ip(uint32_t client_ip, - uint32_t server_ip, - uint32_t mask_dual_port){ - m_pkt_gen.set_ip(client_ip,server_ip,mask_dual_port); - } - -public: - void Dump(FILE *fd); // dump all - void DumpShort(FILE *fd); // dump short histogram of latency - - void DumpRxCheck(FILE *fd); // dump all - void DumpShortRxCheck(FILE *fd); // dump short histogram of latency - void rx_check_dump_json(std::string & json); - uint16_t get_latency_header_offset(){ - return ( m_pkt_gen.get_payload_offset() ); - } - void update(); - void dump_json(std::string & json ); // dump to json - void dump_json_v2(std::string & json ); - - - - void DumpRxCheckVerification(FILE *fd,uint64_t total_tx_rx_check); - void set_mask(uint32_t mask){ - m_port_mask=mask; - } - - double get_max_latency(void); - double get_avr_latency(void); - bool is_any_error(); - uint64_t get_total_pkt(); - uint64_t get_total_bytes(); - CNatRxManager * get_nat_manager(){ - return ( &m_nat_check_manager ); - } - -private: - void send_pkt_all_ports(); - void try_rx(); - void try_rx_queues(); - void run_rx_queue_msgs(uint8_t thread_id, - CNodeRing * r); - void wait_for_rx_dump(); - void handle_rx_pkt(CLatencyManagerPerPort * lp, - rte_mbuf_t * m); - - -private: - /* messages handlers */ - void handle_latecy_pkt_msg(uint8_t thread_id, - CGenNodeLatencyPktInfo * msg); - - - -private: - pqueue_t m_p_queue; /* priorty queue */ - bool m_is_active; - CLatencyPktInfo m_pkt_gen; - CLatencyManagerPerPort m_ports[MAX_LATENCY_PORTS]; - uint64_t m_d_time; // calc tick betwen sending - double m_cps; - double m_delta_sec; - uint64_t m_start_time; // calc tick betwen sending - uint32_t m_port_mask; - uint32_t m_max_ports; - RxCheckManager m_rx_check_manager; - CNatRxManager m_nat_check_manager; - CCpuUtlDp m_cpu_dp_u; - CCpuUtlCp m_cpu_cp_u; - - volatile bool m_do_stop __rte_cache_aligned ; - -}; - - inline bool CGenNode::is_responder_pkt(){ return ( m_pkt_info->m_pkt_indication.m_desc.IsInitSide() ?false:true ); } diff --git a/src/common/Network/Packet/IcmpHeader.h b/src/common/Network/Packet/IcmpHeader.h new file mode 100644 index 00000000..99d89329 --- /dev/null +++ b/src/common/Network/Packet/IcmpHeader.h @@ -0,0 +1,89 @@ +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +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. +*/ + +#ifndef _ICMP_HEADER_H_ +#define _ICMP_HEADER_H_ + +#include "PacketHeaderBase.h" +#include "IPHeader.h" + +class ICMPHeader +{ + +public: + ICMPHeader() + { + setCode(0); + setType(0); + setSeqNum(0xDEAD); + setId(0xBEEF); + setChecksum(0); + } + + ICMPHeader(uint8_t argType, + uint8_t argCode, + uint16_t argId, + uint16_t argSeqNum) + { + setType(argType); + setCode(argCode); + setId(argId); + setSeqNum(argSeqNum); + } + + + inline void setCode(uint8_t data); + inline uint8_t getCode(); + + inline void setType(uint8_t data); + inline uint8_t getType(); + + inline void setSeqNum(uint16_t data); + inline uint16_t getSeqNum(); + + inline void setId(uint16_t data); + inline uint16_t getId(); + + inline void setChecksum(uint16_t data); + inline uint16_t getChecksum(); + + inline void updateCheckSum(uint16_t len); + inline bool isCheckSumOk(uint16_t len); + inline uint16_t calcCheckSum(uint16_t len); + + +//////////////////////////////////////////////////////////////////////////////////////// +// Common Header Interface +//////////////////////////////////////////////////////////////////////////////////////// + +public: + inline uint8_t* getPointer (){return (uint8_t*)this;} + inline uint32_t getSize (){return 8;} + + void dump (FILE* fd); + +private: + uint8_t myType; + uint8_t myCode; + uint16_t myChecksum; + uint16_t myId; + uint16_t mySeqNum; +}; + + +#include "IcmpHeader.inl" + +#endif diff --git a/src/common/Network/Packet/IcmpHeader.inl b/src/common/Network/Packet/IcmpHeader.inl new file mode 100644 index 00000000..0e6806f8 --- /dev/null +++ b/src/common/Network/Packet/IcmpHeader.inl @@ -0,0 +1,87 @@ +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +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. +*/ + +inline void ICMPHeader::setCode(uint8_t argCode) +{ + myCode = argCode; +} + +inline uint8_t ICMPHeader::getCode() +{ + return myCode; +} + +inline void ICMPHeader::setType(uint8_t argType) +{ + myType = argType; +} + +inline uint8_t ICMPHeader::getType() +{ + return myType; +} + +inline void ICMPHeader::setSeqNum(uint16_t argSeqNum) +{ + mySeqNum = PKT_NTOHS(argSeqNum); +} + +inline uint16_t ICMPHeader::getSeqNum() +{ + return PKT_NTOHS(mySeqNum); +} + +inline void ICMPHeader::setId(uint16_t argId) +{ + myId = PKT_NTOHS(argId); +} + +inline uint16_t ICMPHeader::getId() +{ + return PKT_NTOHS(myId); +} + +inline void ICMPHeader::setChecksum(uint16_t argNewChecksum) +{ + myChecksum = PKT_NTOHS(argNewChecksum); +} + +inline uint16_t ICMPHeader::getChecksum() +{ + return PKT_NTOHS(myChecksum); +} + +inline void ICMPHeader::updateCheckSum(uint16_t len) +{ + setChecksum(0);// must be here + + myChecksum =calcCheckSum(len); +} + +inline bool ICMPHeader::isCheckSumOk(uint16_t len) +{ + uint16_t theChecksum= PKT_NTOHS(calcCheckSum(len)); + + return(theChecksum == 0); +} + +// len is in bytes. Including ICMP header + data. +inline uint16_t ICMPHeader::calcCheckSum(uint16_t len) +{ + uint16_t theChecksum = pkt_InetChecksum((uint8_t*)this, len); + + return(theChecksum); +} diff --git a/src/common/bitMan.h b/src/common/bitMan.h index ffa05598..8019b3f7 100755 --- a/src/common/bitMan.h +++ b/src/common/bitMan.h @@ -160,8 +160,8 @@ inline void btSetMaskBit32(unsigned int & a, btSetMaskBit<unsigned int>(a,startbit,stopbit,newVal); } -/* start > stop startbit = 10 , - stop = 8 +/* Notice: + startbit should be bigger (or equal) than stopbit count like big E diff --git a/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h b/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h index 642adb76..d9cdb379 100755 --- a/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h +++ b/src/dpdk_lib18/librte_ether/rte_eth_ctrl.h @@ -202,6 +202,7 @@ enum rte_eth_flow_type { struct rte_eth_ipv4_flow { uint32_t src_ip; /**< IPv4 source address to match. */ uint32_t dst_ip; /**< IPv4 destination address to match. */ + uint8_t l4_proto; /* IPv4 protocol to match */ }; /** diff --git a/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c b/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c index 9c0db84c..b0e00464 100755 --- a/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c +++ b/src/dpdk_lib18/librte_pmd_i40e/i40e_ethdev.c @@ -355,6 +355,20 @@ static inline void i40e_flex_payload_reg_init(struct i40e_hw *hw) #define I40E_PRTQF_FD_INSET(_i, _j) (0x00250000 + ((_i) * 64 + (_j) * 32)) #define I40E_GLQF_FD_MSK(_i, _j) (0x00267200 + ((_i) * 4 + (_j) * 8)) +void dump_regs(struct i40e_hw *hw) +{ + int reg_nums[] = {31, 33, 34, 35, 41, 43}; + int i; + uint32_t reg; + + for (i =0; i < sizeof (reg_nums)/sizeof(int); i++) { + reg = I40E_READ_REG(hw,I40E_PRTQF_FD_INSET(reg_nums[i], 0)); + printf("I40E_PRTQF_FD_INSET(%d, 0): 0x%08x\n", reg_nums[i], reg); + reg = I40E_READ_REG(hw,I40E_PRTQF_FD_INSET(reg_nums[i], 1)); + printf("I40E_PRTQF_FD_INSET(%d, 1): 0x%08x\n", reg_nums[i], reg); + } +} + static inline void i40e_fillter_fields_reg_init(struct i40e_hw *hw) { uint32_t reg; @@ -403,6 +417,10 @@ static inline void i40e_fillter_fields_reg_init(struct i40e_hw *hw) //printf("I40E_PRTQF_FD_INSET(34, 1) = 0x%08x\n", reg); I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(34, 1), 0x00040000); + // filter IP according to ttl and L4 protocol + I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(35, 0), 0); + I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(35, 1), 0x00040000); + reg = I40E_READ_REG(hw,I40E_PRTQF_FD_INSET(44, 0)); //printf("I40E_PRTQF_FD_INSET(44, 0) = 0x%08x\n", reg); I40E_WRITE_REG(hw, I40E_PRTQF_FD_INSET(44, 0), 0); @@ -420,8 +438,6 @@ static inline void i40e_fillter_fields_reg_init(struct i40e_hw *hw) I40E_WRITE_FLUSH(hw); } - - static int eth_i40e_dev_init(__rte_unused struct eth_driver *eth_drv, struct rte_eth_dev *dev) diff --git a/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c b/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c index 98df9357..4b209e18 100755 --- a/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c +++ b/src/dpdk_lib18/librte_pmd_i40e/i40e_fdir.c @@ -727,7 +727,10 @@ i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input, */ ip->src_addr = fdir_input->flow.ip4_flow.dst_ip; ip->dst_addr = fdir_input->flow.ip4_flow.src_ip; - ip->next_proto_id = next_proto[fdir_input->flow_type]; + if (fdir_input->flow_type == RTE_ETH_FLOW_TYPE_IPV4_OTHER) { + ip->next_proto_id = fdir_input->flow.ip4_flow.l4_proto; + } else + ip->next_proto_id = next_proto[fdir_input->flow_type]; break; case RTE_ETH_FLOW_TYPE_UDPV6: case RTE_ETH_FLOW_TYPE_TCPV6: diff --git a/src/gtest/trex_stateless_gtest.cpp b/src/gtest/trex_stateless_gtest.cpp index bc89ec54..da652599 100644 --- a/src/gtest/trex_stateless_gtest.cpp +++ b/src/gtest/trex_stateless_gtest.cpp @@ -30,6 +30,7 @@ limitations under the License. #include <trex_stateless_port.h> #include <trex_rpc_server_api.h> #include <iostream> +#include <vector> class CPcapLoader { @@ -1148,11 +1149,9 @@ TEST_F(basic_stl, basic_pause_resume0) { // stream - clean - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); + std::vector<TrexStreamsCompiledObj *> objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg_queue.add_msg(lpStartCmd); @@ -1212,14 +1211,9 @@ void CBBStartStopDelay2::call_after_init(CBasicStl * m_obj){ streams.push_back(stream1); // stream - clean - - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - - /* start with different event id */ - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(m_port_id, 1, comp_obj.clone(), 10.0 /*sec */ ); + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 1, objs[0], 10.0 /*sec */ ); m_obj->m_msg_queue.add_command(m_core,lpStopCmd, 5.0); /* command in delay of 5 sec */ @@ -1265,12 +1259,9 @@ TEST_F(basic_stl, single_pkt_bb_start_stop_delay2) { streams.push_back(stream1); // stream - clean - - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg_queue.add_msg(lpStartCmd); @@ -1346,12 +1337,9 @@ TEST_F(basic_stl, single_pkt_bb_start_stop_delay1) { streams.push_back(stream1); // stream - clean - - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg_queue.add_msg(lpStartCmd); @@ -1400,12 +1388,10 @@ TEST_F(basic_stl, single_pkt_bb_start_stop3) { streams.push_back(stream1); // stream - clean + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); TrexStatelessDpStop * lpStopCmd = new TrexStatelessDpStop(port_id); TrexStatelessDpStop * lpStopCmd1 = new TrexStatelessDpStop(port_id); @@ -1453,14 +1439,12 @@ TEST_F(basic_stl, single_pkt_bb_start_stop2) { streams.push_back(stream1); // stream - clean + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); TrexStatelessDpStop * lpStopCmd = new TrexStatelessDpStop(port_id); - TrexStatelessDpStart * lpStartCmd1 = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); + TrexStatelessDpStart * lpStartCmd1 = new TrexStatelessDpStart(port_id, 0, objs[0]->clone(), 10.0 /*sec */ ); t1.m_msg_queue.add_msg(lpStartCmd); @@ -1508,12 +1492,10 @@ TEST_F(basic_stl, single_pkt_bb_start_stop) { streams.push_back(stream1); // stream - clean + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpStartCmd = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); TrexStatelessDpStop * lpStopCmd = new TrexStatelessDpStop(port_id); @@ -1593,14 +1575,13 @@ TEST_F(basic_stl, simple_prog4) { streams.push_back(stream2); - TrexStreamsCompiledObj comp_obj(0,1.0); - - EXPECT_TRUE(compile.compile(streams, comp_obj) ); + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 0, objs[0], 20.0 /*sec */ ); - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 20.0 ); - - t1.m_msg = lpstart; + t1.m_msg = lpStartCmd; bool res=t1.init(); @@ -1663,11 +1644,10 @@ TEST_F(basic_stl, simple_prog3) { streams.push_back(stream2); - TrexStreamsCompiledObj comp_obj(0,1.0); - - EXPECT_TRUE(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 50.0 ); + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 50.0 /*sec */ ); t1.m_msg = lpstart; @@ -1724,13 +1704,10 @@ TEST_F(basic_stl, simple_prog2) { pcap.clone_packet_into_stream(stream2); streams.push_back(stream2); - - TrexStreamsCompiledObj comp_obj(0,1.0); - - EXPECT_TRUE(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10.0 ); - + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg = lpstart; @@ -1787,11 +1764,10 @@ TEST_F(basic_stl, simple_prog1) { streams.push_back(stream2); - TrexStreamsCompiledObj comp_obj(0,1.0); - - EXPECT_TRUE(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10.0 ); + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg = lpstart; @@ -1832,12 +1808,10 @@ TEST_F(basic_stl, single_pkt_burst1) { streams.push_back(stream1); - TrexStreamsCompiledObj comp_obj(0,1.0); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10.0 ); - + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg = lpstart; @@ -1883,11 +1857,9 @@ TEST_F(basic_stl, single_pkt) { // stream - clean - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(port_id, 0, comp_obj.clone(), 10.0 /*sec */ ); + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg = lpstart; @@ -1939,12 +1911,11 @@ TEST_F(basic_stl, multi_pkt1) { streams.push_back(stream2); - // stream - clean - TrexStreamsCompiledObj comp_obj(0,1.0); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10 ); + // stream - clean + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg = lpstart; @@ -2157,11 +2128,10 @@ TEST_F(basic_stl, multi_pkt2) { // stream - clean - TrexStreamsCompiledObj comp_obj(0,5.0); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 10 ); + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs, 1, 5.0)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 10.0 /*sec */ ); t1.m_msg = lpstart; @@ -2203,11 +2173,10 @@ TEST_F(basic_stl, multi_burst1) { streams.push_back(stream1); - TrexStreamsCompiledObj comp_obj(0,1.0); - - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(0, 0, comp_obj.clone(), 40 ); + uint8_t port_id = 0; + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpstart = new TrexStatelessDpStart(port_id, 0, objs[0], 40.0 /*sec */ ); t1.m_msg = lpstart; @@ -2237,10 +2206,9 @@ TEST_F(basic_stl, compile_bad_1) { streams.push_back(stream1); - TrexStreamsCompiledObj comp_obj(0,1.0); - std::string err_msg; - EXPECT_FALSE(compile.compile(streams, comp_obj, &err_msg)); + std::vector<TrexStreamsCompiledObj *>objs; + EXPECT_FALSE(compile.compile(0, streams, objs, 1, 1, &err_msg)); delete stream1; @@ -2270,10 +2238,12 @@ TEST_F(basic_stl, compile_bad_2) { streams.push_back(stream1); streams.push_back(stream2); - TrexStreamsCompiledObj comp_obj(0,1.0); + uint8_t port_id = 0; std::string err_msg; - EXPECT_FALSE(compile.compile(streams, comp_obj, &err_msg)); + std::vector<TrexStreamsCompiledObj *>objs; + EXPECT_FALSE(compile.compile(port_id, streams, objs, 1, 1, &err_msg)); + delete stream1; delete stream2; @@ -2349,10 +2319,10 @@ TEST_F(basic_stl, compile_bad_3) { streams.push_back(stream); /* compile */ - TrexStreamsCompiledObj comp_obj(0,1.0); - std::string err_msg; - EXPECT_FALSE(compile.compile(streams, comp_obj, &err_msg)); + std::vector<TrexStreamsCompiledObj *>objs; + EXPECT_FALSE(compile.compile(0, streams, objs, 1, 1, &err_msg)); + for (auto stream : streams) { delete stream; @@ -2401,11 +2371,11 @@ TEST_F(basic_stl, compile_with_warnings) { /* compile */ - TrexStreamsCompiledObj comp_obj(0,1.0); - std::string err_msg; - EXPECT_TRUE(compile.compile(streams, comp_obj, &err_msg)); - + std::vector<TrexStreamsCompiledObj *>objs; + EXPECT_TRUE(compile.compile(0, streams, objs, 1, 1, &err_msg)); + delete objs[0]; + EXPECT_TRUE(compile.get_last_compile_warnings().size() == 1); for (auto stream : streams) { @@ -2440,20 +2410,22 @@ TEST_F(basic_stl, compile_good_stream_id_compres) { streams.push_back(stream1); streams.push_back(stream2); - TrexStreamsCompiledObj comp_obj(0,1.0); - + uint8_t port_id = 0; std::string err_msg; - EXPECT_TRUE(compile.compile(streams, comp_obj, &err_msg)); + std::vector<TrexStreamsCompiledObj *>objs; + EXPECT_TRUE(compile.compile(port_id, streams, objs, 1, 1, &err_msg)); printf(" %s \n",err_msg.c_str()); - comp_obj.Dump(stdout); + objs[0]->Dump(stdout); - EXPECT_EQ_UINT32(comp_obj.get_objects()[0].m_stream->m_stream_id,0); - EXPECT_EQ_UINT32(comp_obj.get_objects()[0].m_stream->m_next_stream_id,1); + EXPECT_EQ_UINT32(objs[0]->get_objects()[0].m_stream->m_stream_id,0); + EXPECT_EQ_UINT32(objs[0]->get_objects()[0].m_stream->m_next_stream_id,1); - EXPECT_EQ_UINT32(comp_obj.get_objects()[1].m_stream->m_stream_id,1); - EXPECT_EQ_UINT32(comp_obj.get_objects()[1].m_stream->m_next_stream_id,0); + EXPECT_EQ_UINT32(objs[0]->get_objects()[1].m_stream->m_stream_id,1); + EXPECT_EQ_UINT32(objs[0]->get_objects()[1].m_stream->m_next_stream_id,0); + + delete objs[0]; delete stream1; delete stream2; @@ -2515,14 +2487,12 @@ TEST_F(basic_stl, dp_stop_event) { // stream - clean - TrexStreamsCompiledObj comp_obj(port_id, 1.0 /*mul*/); + std::vector<TrexStreamsCompiledObj *>objs; + assert(compile.compile(port_id, streams, objs)); + TrexStatelessDpStart *lpStartCmd = new TrexStatelessDpStart(port_id, 17, objs[0], 10.0 /*sec */ ); - assert(compile.compile(streams, comp_obj) ); - - TrexStatelessDpStart * lpstart = new TrexStatelessDpStart(port_id, 17, comp_obj.clone(), 10.0 /*sec */ ); - - t1.m_msg = lpstart; + t1.m_msg = lpStartCmd; /* let me handle these */ DpToCpHandlerStopEvent handler(17); diff --git a/src/latency.cpp b/src/latency.cpp new file mode 100644 index 00000000..02b54f75 --- /dev/null +++ b/src/latency.cpp @@ -0,0 +1,1019 @@ +/* + Hanoh Haim + Ido Barnea + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +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. +*/ +#include "latency.h" +#include "bp_sim.h" +#include "utl_json.h" +#include <common/basic_utils.h> + +const uint8_t sctp_pkt[]={ + + 0x00,0x04,0x96,0x08,0xe0,0x40, + 0x00,0x0e,0x2e,0x24,0x37,0x5f, + 0x08,0x00, + + 0x45,0x02,0x00,0x30, + 0x00,0x00,0x40,0x00, + 0xff,0x84,0xbd,0x04, + 0x9b,0xe6,0x18,0x9b, //sIP + 0xcb,0xff,0xfc,0xc2, //DIP + + 0x80,0x44,//SPORT + 0x00,0x50,//DPORT + + 0x00,0x00,0x00,0x00, //checksum + + 0x11,0x22,0x33,0x44, // magic + 0x00,0x00,0x00,0x00, //64 bit counter + 0x00,0x00,0x00,0x00, + 0x00,0x01,0xa0,0x00, //seq + 0x00,0x00,0x00,0x00, + +}; + +const uint8_t icmp_pkt[]={ + 0x00,0x04,0x96,0x08,0xe0,0x40, + 0x00,0x0e,0x2e,0x24,0x37,0x5f, + 0x08,0x00, + + 0x45,0x02,0x00,0x30, + 0x00,0x00,0x40,0x00, + 0xff,0x01,0xbd,0x04, + 0x9b,0xe6,0x18,0x9b, //SIP + 0xcb,0xff,0xfc,0xc2, //DIP + + 0x08, 0x00, + 0x01, 0x02, //checksum + 0xaa, 0xbb, // id + 0x00, 0x00, // Sequence number + + 0x11,0x22,0x33,0x44, // magic + 0x00,0x00,0x00,0x00, //64 bit counter + 0x00,0x00,0x00,0x00, + 0x00,0x01,0xa0,0x00, //seq + 0x00,0x00,0x00,0x00, + +}; + + +void CLatencyPktInfo::Create(class CLatencyPktMode *m_l_pkt_info){ + uint8_t pkt_size = m_l_pkt_info->getPacketLen(); + + m_packet = new CCapPktRaw( pkt_size); + m_packet->pkt_cnt=0; + m_packet->time_sec=0; + m_packet->time_nsec=0; + memcpy(m_packet->raw, m_l_pkt_info->getPacketData(), pkt_size); + m_packet->pkt_len=pkt_size; + + m_pkt_indication.m_packet =m_packet; + + m_pkt_indication.m_ether = (EthernetHeader *)m_packet->raw; + m_pkt_indication.l3.m_ipv4=(IPHeader *)(m_packet->raw+14); + m_pkt_indication.m_is_ipv6 = false; + m_pkt_indication.l4.m_icmp=(ICMPHeader *)m_packet->raw+14+20; + m_pkt_indication.m_payload=(uint8_t *)m_packet->raw+14+20+16; + m_pkt_indication.m_payload_len=0; + m_pkt_indication.m_packet_padding=4; + + + m_pkt_indication.m_ether_offset =0; + m_pkt_indication.m_ip_offset =14; + m_pkt_indication.m_udp_tcp_offset = 34; + m_pkt_indication.m_payload_offset = 34+8; + + CPacketDescriptor * lpd=&m_pkt_indication.m_desc; + lpd->Clear(); + lpd->SetInitSide(true); + lpd->SetSwapTuple(false); + lpd->SetIsValidPkt(true); + lpd->SetIsIcmp(true); + lpd->SetIsLastPkt(true); + m_pkt_info.Create(&m_pkt_indication); + + memset(&m_dummy_node,0,sizeof(m_dummy_node)); + + m_dummy_node.set_socket_id( CGlobalInfo::m_socket.port_to_socket(0) ); + + m_dummy_node.m_time =0.1; + m_dummy_node.m_pkt_info = &m_pkt_info; + m_dummy_node.m_dest_ip = 0; + m_dummy_node.m_src_ip = 0; + m_dummy_node.m_src_port = 0x11; + m_dummy_node.m_flow_id =0; + m_dummy_node.m_flags =CGenNode::NODE_FLAGS_LATENCY; + +} + +rte_mbuf_t * CLatencyPktInfo::generate_pkt(int port_id,uint32_t extern_ip){ + bool is_client_to_server=(port_id%2==0)?true:false; + + int dual_port_index=(port_id>>1); + uint32_t c=m_client_ip.v4; + uint32_t s=m_server_ip.v4; + if ( extern_ip ){ + c=extern_ip; + } + + if (!is_client_to_server) { + /*swap */ + uint32_t t=c; + c=s; + s=t; + } + uint32_t mask=dual_port_index*m_dual_port_mask; + if ( extern_ip==0 ){ + c+=mask; + } + s+=mask; + m_dummy_node.m_src_ip = c; + m_dummy_node.m_dest_ip = s; + + rte_mbuf_t * m=m_pkt_info.generate_new_mbuf(&m_dummy_node); + return (m); +} + +void CLatencyPktInfo::set_ip(uint32_t src, + uint32_t dst, + uint32_t dual_port_mask){ + m_client_ip.v4=src; + m_server_ip.v4=dst; + m_dual_port_mask=dual_port_mask; +} + +void CLatencyPktInfo::Delete(){ + m_pkt_info.Delete(); + delete m_packet; +} + +void CCPortLatency::reset(){ + m_rx_seq =m_tx_seq; + m_pad = 0; + m_tx_pkt_err=0; + m_tx_pkt_ok =0; + m_pkt_ok=0; + m_rx_check=0; + m_no_magic=0; + m_unsup_prot=0; + m_no_id=0; + m_seq_error=0; + m_length_error=0; + m_no_ipv4_option=0; + m_hist.Reset(); +} + +static uint8_t nat_is_port_can_send(uint8_t port_id){ + uint8_t client_index = (port_id %2); + return (client_index ==0 ?1:0); +} + +bool CCPortLatency::Create(CLatencyManager * parent, + uint8_t id, + uint16_t payload_offset, + uint16_t l4_offset, + uint16_t pkt_size, + CCPortLatency * rx_port){ + m_parent = parent; + m_id = id; + m_tx_seq =0x12345678; + m_icmp_tx_seq = 1; + m_icmp_rx_seq = 0; + m_l4_offset = l4_offset; + m_payload_offset = payload_offset; + m_pkt_size = pkt_size; + m_rx_port = rx_port; + m_nat_can_send = nat_is_port_can_send(m_id); + m_nat_learn = m_nat_can_send; + m_nat_external_ip=0; + + m_hist.Create(); + reset(); + return (true); +} + +void CCPortLatency::Delete(){ + m_hist.Delete(); +} + +void CCPortLatency::update_packet(rte_mbuf_t * m, int port_id){ + uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*); + bool is_client_to_server=(port_id%2==0)?true:false; + + /* update mac addr dest/src 12 bytes */ + memcpy(p,CGlobalInfo::m_options.get_dst_src_mac_addr(m_id),12); + + latency_header * h=(latency_header *)(p+m_payload_offset); + h->magic = LATENCY_MAGIC | m_id ; + h->time_stamp = os_get_hr_tick_64(); + h->seq = m_tx_seq; + m_tx_seq++; + + CLatencyPktMode *c_l_pkt_mode = m_parent->c_l_pkt_mode; + c_l_pkt_mode->update_pkt(p + m_l4_offset, is_client_to_server, m_pkt_size - m_l4_offset, &m_icmp_tx_seq); +} + + +void CCPortLatency::DumpShortHeader(FILE *fd){ + + + fprintf(fd," if| tx_ok , rx_ok , rx ,error, average , max , Jitter , max window \n"); + fprintf(fd," | , , check, , latency(usec),latency (usec) ,(usec) , \n"); + fprintf(fd," ---------------------------------------------------------------------------------------------------------------- \n"); +} + + + +std::string CCPortLatency::get_field(std::string name,float f){ + char buff[200]; + sprintf(buff,"\"%s-%d\":%.1f,",name.c_str(),m_id,f); + return (std::string(buff)); +} + + +void CCPortLatency::dump_json_v2(std::string & json ){ + char buff[200]; + sprintf(buff,"\"port-%d\": {",m_id); + json+=std::string(buff); + m_hist.dump_json("hist",json); + dump_counters_json(json); + json+="},"; +} + +void CCPortLatency::dump_json(std::string & json ){ + json += get_field("avg",m_hist.get_average_latency() ); + json += get_field("max",m_hist.get_max_latency() ); + json += get_field("c-max",m_hist.get_max_latency_last_update() ); + json += get_field("error",(float)(m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error) ); + json += get_field("jitter",(float)get_jitter_usec() ); +} + + +void CCPortLatency::DumpShort(FILE *fd){ + + m_hist.update(); + fprintf(fd,"%8lu,%8lu,%10lu,%4lu,", + m_tx_pkt_ok, + m_pkt_ok, + m_rx_check, + m_unsup_prot+m_no_magic+m_no_id+m_seq_error+m_length_error+m_no_ipv4_option+m_tx_pkt_err + ); + + fprintf(fd," %8.0f ,%8.0f,%8d ", + m_hist.get_average_latency(), + m_hist.get_max_latency(), + get_jitter_usec() + ); + fprintf(fd," | "); + m_hist.DumpWinMax(fd); + +} + +#define DPL_J(f) json+=add_json(#f,f); +#define DPL_J_LAST(f) json+=add_json(#f,f,true); + +void CCPortLatency::dump_counters_json(std::string & json ){ + + json+="\"stats\" : {"; + DPL_J(m_tx_pkt_ok); + DPL_J(m_tx_pkt_err); + DPL_J(m_pkt_ok); + DPL_J(m_unsup_prot); + DPL_J(m_no_magic); + DPL_J(m_no_id); + DPL_J(m_seq_error); + DPL_J(m_length_error); + DPL_J(m_no_ipv4_option); + json+=add_json("m_jitter",get_jitter_usec()); + /* must be last */ + DPL_J_LAST(m_rx_check); + json+="}"; + + +} + +void CCPortLatency::DumpCounters(FILE *fd){ + #define DP_A1(f) if (f) fprintf(fd," %-40s : %llu \n",#f, (unsigned long long)f) + + fprintf(fd," counter \n"); + fprintf(fd," -----------\n"); + + DP_A1(m_tx_pkt_err); + DP_A1(m_tx_pkt_ok); + DP_A1(m_pkt_ok); + DP_A1(m_unsup_prot); + DP_A1(m_no_magic); + DP_A1(m_no_id); + DP_A1(m_seq_error); + DP_A1(m_length_error); + DP_A1(m_rx_check); + DP_A1(m_no_ipv4_option); + + + fprintf(fd," -----------\n"); + m_hist.Dump(fd); + fprintf(fd," %-40s : %lu \n","jitter", (ulong)get_jitter_usec()); +} + +bool CCPortLatency::dump_packet(rte_mbuf_t * m){ + fprintf(stdout," %f.03 dump packet ..\n",now_sec()); + uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*); + uint16_t pkt_size=rte_pktmbuf_pkt_len(m); + utl_DumpBuffer(stdout,p,pkt_size,0); + return (0); + + + + if (pkt_size < ( sizeof(CRx_check_header)+14+20) ) { + assert(0); + } + CRx_check_header * lp=(CRx_check_header *)(p+pkt_size-sizeof(CRx_check_header)); + + lp->dump(stdout); + + + uint16_t vlan_offset=0; + if ( unlikely( CGlobalInfo::m_options.preview.get_vlan_mode_enable() ) ){ + vlan_offset=4; + } + + (void)vlan_offset; + +// utl_DumpBuffer(stdout,p,pkt_size,0); + return (0); + +} + +bool CCPortLatency::check_rx_check(rte_mbuf_t * m) { + m_rx_check++; + return (true); +} + +bool CCPortLatency::do_learn(uint32_t external_ip) { + m_nat_learn=true; + m_nat_can_send=true; + m_nat_external_ip=external_ip; + return (true); +} + +bool CCPortLatency::check_packet(rte_mbuf_t * m,CRx_check_header * & rx_p) { + CSimplePacketParser parser(m); + if ( !parser.Parse() ) { + m_unsup_prot++; // Unsupported protocol + return (false); + } + CLatencyPktMode *c_l_pkt_mode = m_parent->c_l_pkt_mode; + uint16_t pkt_size=rte_pktmbuf_pkt_len(m); + + /* check if CRC was extracted */ + if ( parser.getPktSize() == pkt_size-4) { + // CRC was not extracted by driver (VM E1000 driver issue) extract it + pkt_size=pkt_size-4; + } + + uint16_t vlan_offset=parser.m_vlan_offset; + uint8_t *p=rte_pktmbuf_mtod(m, uint8_t*); + + rx_p = (CRx_check_header *)0; + + bool is_lateancy_pkt = c_l_pkt_mode->IsLatencyPkt(parser.m_ipv4) & parser.IsLatencyPkt(parser.m_l4 + c_l_pkt_mode->l4_header_len()); + + if ( ! is_lateancy_pkt) { + +#ifdef NAT_TRACE_ + printf(" %.3f RX : got packet !!! \n",now_sec() ); +#endif + + /* ipv6+rx-check */ + if ( parser.m_ipv6 ) { + /* if we have ipv6 packet */ + if (parser.m_protocol == RX_CHECK_V6_OPT_TYPE) { + if ( get_is_rx_check_mode() ){ + m_rx_check++; + rx_p=(CRx_check_header *)((uint8_t*)parser.m_ipv6 +IPv6Header::DefaultSize); + return (true); + } + + } + m_seq_error++; + return (false); + } + + uint8_t opt_len = parser.m_ipv4->getOptionLen(); + uint8_t *opt_ptr = parser.m_ipv4->getOption(); + /* Process IP option header(s) */ + while ( opt_len != 0 ) { + switch (*opt_ptr) { + case RX_CHECK_V4_OPT_TYPE: + /* rx-check option header */ + if ( ( !get_is_rx_check_mode() ) || + (opt_len < RX_CHECK_LEN) ) { + m_seq_error++; + return (false); + } + m_rx_check++; + rx_p=(CRx_check_header *)opt_ptr; + opt_len -= RX_CHECK_LEN; + opt_ptr += RX_CHECK_LEN; + break; + case CNatOption::noIPV4_OPTION: + /* NAT learn option header */ + CNatOption *lp; + if ( ( !CGlobalInfo::is_learn_mode() ) || + (opt_len < CNatOption::noOPTION_LEN) ) { + m_seq_error++; + return (false); + } + lp = (CNatOption *)opt_ptr; + if ( !lp->is_valid_ipv4_magic() ) { + m_no_ipv4_option++; + return (false); + } + m_parent->get_nat_manager()->handle_packet_ipv4(lp,parser.m_ipv4); + opt_len -= CNatOption::noOPTION_LEN; + opt_ptr += CNatOption::noOPTION_LEN; + break; + default: + m_seq_error++; + return (false); + } // End of switch + } // End of while + + return (true); + } // End of check for non-latency packet + if ( CGlobalInfo::is_learn_mode() && (m_nat_learn ==false) ) { + do_learn(parser.m_ipv4->getSourceIp()); + } + + if ( (pkt_size-vlan_offset) != m_pkt_size ) { + m_length_error++; + return (false); + } + c_l_pkt_mode->update_recv(p + m_l4_offset + vlan_offset, &m_icmp_rx_seq, &m_icmp_tx_seq); +#ifdef LATENCY_DEBUG + c_l_pkt_mode->rcv_debug_print(p + m_l4_offset + vlan_offset); +#endif + latency_header * h=(latency_header *)(p+m_payload_offset + vlan_offset); + if ( h->seq != m_rx_seq ){ + m_seq_error++; + m_rx_seq =h->seq +1; + return (false); + }else{ + m_rx_seq++; + } + m_pkt_ok++; + uint64_t d = (os_get_hr_tick_64() - h->time_stamp ); + dsec_t ctime=ptime_convert_hr_dsec(d); + m_hist.Add(ctime); + m_jitter.calc(ctime); + return (true); +} + +void CLatencyManager::Delete(){ + m_pkt_gen.Delete(); + + if ( get_is_rx_check_mode() ) { + m_rx_check_manager.Delete(); + } + if ( CGlobalInfo::is_learn_mode() ){ + m_nat_check_manager.Delete(); + } + m_cpu_cp_u.Delete(); +} + +/* 0->1 + 1->0 + 2->3 + 3->2 +*/ +static uint8_t swap_port(uint8_t port_id){ + uint8_t offset= ((port_id>>1)<<1); + uint8_t client_index = (port_id %2); + return (offset + (client_index ^ 1)); +} + + + +bool CLatencyManager::Create(CLatencyManagerCfg * cfg){ + switch (CGlobalInfo::m_options.get_l_pkt_mode()) { + default: + case 0: + c_l_pkt_mode = (CLatencyPktModeSCTP *) new CLatencyPktModeSCTP(CGlobalInfo::m_options.get_l_pkt_mode()); + break; + case 1: + case 2: + case 3: + c_l_pkt_mode = (CLatencyPktModeICMP *) new CLatencyPktModeICMP(CGlobalInfo::m_options.get_l_pkt_mode()); + break; + } + + m_max_ports=cfg->m_max_ports; + assert (m_max_ports<=MAX_LATENCY_PORTS); + assert ((m_max_ports%2)==0); + m_port_mask =0xffffffff; + m_do_stop =false; + m_is_active =false; + m_pkt_gen.Create(c_l_pkt_mode); + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + CCPortLatency * lpo=&m_ports[swap_port(i)].m_port; + + lp->m_io=cfg->m_ports[i]; + lp->m_port.Create(this, + i, + m_pkt_gen.get_payload_offset(), + m_pkt_gen.get_l4_offset(), + m_pkt_gen.get_pkt_size(),lpo ); + } + m_cps= cfg->m_cps; + m_d_time =ptime_convert_dsec_hr((1.0/m_cps)); + m_delta_sec =(1.0/m_cps); + + + if ( get_is_rx_check_mode() ) { + assert(m_rx_check_manager.Create()); + m_rx_check_manager.m_cur_time= now_sec(); + } + + + m_pkt_gen.set_ip(cfg->m_client_ip.v4,cfg->m_server_ip.v4,cfg->m_dual_port_mask); + m_cpu_cp_u.Create(&m_cpu_dp_u); + if ( CGlobalInfo::is_learn_mode() ){ + m_nat_check_manager.Create(); + } + return (true); +} + + +void CLatencyManager::send_pkt_all_ports(){ + m_start_time = os_get_hr_tick_64(); + int i; + for (i=0; i<m_max_ports; i++) { + if ( m_port_mask & (1<<i) ){ + CLatencyManagerPerPort * lp=&m_ports[i]; + if (lp->m_port.can_send_packet(i%2) ){ + rte_mbuf_t * m=m_pkt_gen.generate_pkt(i,lp->m_port.external_nat_ip()); + lp->m_port.update_packet(m, i); + +#ifdef LATENCY_DEBUG + uint8_t *p = rte_pktmbuf_mtod(m, uint8_t*); + c_l_pkt_mode->send_debug_print(p + 34); +#endif + if ( lp->m_io->tx(m) == 0 ){ + lp->m_port.m_tx_pkt_ok++; + }else{ + lp->m_port.m_tx_pkt_err++; + } + + } + } + } +} + + +void CLatencyManager::wait_for_rx_dump(){ + rte_mbuf_t * rx_pkts[64]; + int i; + while ( true ) { + rte_pause(); + rte_pause(); + rte_pause(); + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + rte_mbuf_t * m; + uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64); + if (cnt_p) { + int j; + for (j=0; j<cnt_p; j++) { + m=rx_pkts[j] ; + lp->m_port.dump_packet( m); + rte_pktmbuf_free(m); + } + } /*cnt_p*/ + }/* for*/ + } +} + + +void CLatencyManager::handle_rx_pkt(CLatencyManagerPerPort * lp, + rte_mbuf_t * m){ + CRx_check_header *rxc = NULL; + + lp->m_port.check_packet(m,rxc); + if ( unlikely(rxc!=NULL) ){ + m_rx_check_manager.handle_packet(rxc); + } + + rte_pktmbuf_free(m); +} + +void CLatencyManager::handle_latency_pkt_msg(uint8_t thread_id, + CGenNodeLatencyPktInfo * msg){ + + assert(msg->m_latency_offset==0xdead); + + uint8_t rx_port_index=(thread_id<<1)+(msg->m_dir&1); + assert( rx_port_index <m_max_ports ) ; + CLatencyManagerPerPort * lp=&m_ports[rx_port_index]; + handle_rx_pkt(lp,(rte_mbuf_t *)msg->m_pkt); +} + + +void CLatencyManager::run_rx_queue_msgs(uint8_t thread_id, + CNodeRing * r){ + + while ( true ) { + CGenNode * node; + if ( r->Dequeue(node)!=0 ){ + break; + } + assert(node); + + CGenNodeMsgBase * msg=(CGenNodeMsgBase *)node; + + uint8_t msg_type = msg->m_msg_type; + switch (msg_type ) { + case CGenNodeMsgBase::LATENCY_PKT: + handle_latency_pkt_msg(thread_id,(CGenNodeLatencyPktInfo *) msg); + break; + default: + printf("ERROR latency-thread message type is not valid %d \n",msg_type); + assert(0); + } + + CGlobalInfo::free_node(node); + } +} + +void CLatencyManager::try_rx_queues(){ + + CMessagingManager * rx_dp = CMsgIns::Ins()->getRxDp(); + uint8_t threads=CMsgIns::Ins()->get_num_threads(); + int ti; + for (ti=0; ti<(int)threads; ti++) { + CNodeRing * r = rx_dp->getRingDpToCp(ti); + if ( !r->isEmpty() ){ + run_rx_queue_msgs((uint8_t)ti,r); + } + } +} + + +void CLatencyManager::try_rx(){ + rte_mbuf_t * rx_pkts[64]; + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + rte_mbuf_t * m; + m_cpu_dp_u.start_work(); + /* try to read 64 packets clean up the queue */ + uint16_t cnt_p = lp->m_io->rx_burst(rx_pkts, 64); + if (cnt_p) { + int j; + for (j=0; j<cnt_p; j++) { + m=rx_pkts[j] ; + handle_rx_pkt(lp,m); + } + /* commit only if there was work to do ! */ + m_cpu_dp_u.commit(); + }/* if work */ + }// all ports +} + + +void CLatencyManager::reset(){ + + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + lp->m_port.reset(); + } + +} + +void CLatencyManager::start(int iter){ + m_do_stop =false; + m_is_active =false; + int cnt=0; + + double n_time; + CGenNode * node = new CGenNode(); + node->m_type = CGenNode::FLOW_SYNC; /* general stuff */ + node->m_time = now_sec()+0.007; + m_p_queue.push(node); + + node = new CGenNode(); + node->m_type = CGenNode::FLOW_PKT; /* latency */ + node->m_time = now_sec(); /* 1/cps rate */ + m_p_queue.push(node); + bool do_try_rx_queue =CGlobalInfo::m_options.preview.get_vm_one_queue_enable()?true:false; + + + while ( !m_p_queue.empty() ) { + node = m_p_queue.top(); + n_time = node->m_time; + + /* wait for event */ + while ( true ) { + double dt = now_sec() - n_time ; + if (dt> (0.0)) { + break; + } + if (do_try_rx_queue){ + try_rx_queues(); + } + try_rx(); + rte_pause(); + } + + switch (node->m_type) { + case CGenNode::FLOW_SYNC: + if ( CGlobalInfo::is_learn_mode() ) { + m_nat_check_manager.handle_aging(); + } + + m_p_queue.pop(); + node->m_time += SYNC_TIME_OUT; + m_p_queue.push(node); + + break; + case CGenNode::FLOW_PKT: + m_cpu_dp_u.start_work(); + send_pkt_all_ports(); + m_p_queue.pop(); + node->m_time += m_delta_sec; + m_p_queue.push(node); + m_cpu_dp_u.commit(); + break; + } + + /* this will be called every sync which is 1msec */ + if ( m_do_stop ) { + break; + } + if ( iter>0 ){ + if ( ( cnt>iter) ){ + printf("stop due iter %d\n",iter); + break; + } + } + cnt++; + } + + /* free all nodes in the queue */ + while (!m_p_queue.empty()) { + node = m_p_queue.top(); + m_p_queue.pop(); + delete node; + } + + printf(" latency daemon has stopped\n"); + if ( get_is_rx_check_mode() ) { + m_rx_check_manager.tw_drain(); + } + +} + +void CLatencyManager::stop(){ + m_do_stop =true; +} + +bool CLatencyManager::is_active(){ + return (m_is_active); +} + + +double CLatencyManager::get_max_latency(){ + double l=0.0; + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + if ( l <lp->m_port.m_hist.get_max_latency() ){ + l=lp->m_port.m_hist.get_max_latency(); + } + } + return (l); +} + +double CLatencyManager::get_avr_latency(){ + double l=0.0; + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + if ( l <lp->m_port.m_hist.get_average_latency() ){ + l=lp->m_port.m_hist.get_average_latency(); + } + } + return (l); +} + +uint64_t CLatencyManager::get_total_pkt(){ + int i; + uint64_t t=0; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + t+=lp->m_port.m_tx_pkt_ok ; + } + return t; +} + +uint64_t CLatencyManager::get_total_bytes(){ + int i; + uint64_t t=0; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + t+=lp->m_port.m_tx_pkt_ok* (m_pkt_gen.get_pkt_size()+4); + } + return t; + +} + + +bool CLatencyManager::is_any_error(){ + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + if ( lp->m_port.is_any_err() ){ + return (true); + } + } + return (false); +} + + +void CLatencyManager::dump_json(std::string & json ){ + json="{\"name\":\"trex-latecny\",\"type\":0,\"data\":{"; + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + lp->m_port.dump_json(json); + } + + json+="\"unknown\":0}}" ; + +} + +void CLatencyManager::dump_json_v2(std::string & json ){ + json="{\"name\":\"trex-latecny-v2\",\"type\":0,\"data\":{"; + json+=add_json("cpu_util",m_cpu_cp_u.GetVal()); + + int i; + for (i=0; i<m_max_ports; i++) { + CLatencyManagerPerPort * lp=&m_ports[i]; + lp->m_port.dump_json_v2(json); + } + + json+="\"unknown\":0}}" ; + +} + +void CLatencyManager::DumpRxCheck(FILE *fd){ + if ( get_is_rx_check_mode() ) { + fprintf(fd," rx checker : \n"); + m_rx_check_manager.DumpShort(fd); + m_rx_check_manager.Dump(fd); + } +} + +void CLatencyManager::DumpShortRxCheck(FILE *fd){ + if ( get_is_rx_check_mode() ) { + m_rx_check_manager.DumpShort(fd); + } +} + +void CLatencyManager::rx_check_dump_json(std::string & json){ + if ( get_is_rx_check_mode() ) { + m_rx_check_manager.dump_json(json ); + } +} + +void CLatencyManager::update(){ + m_cpu_cp_u.Update() ; +} + +void CLatencyManager::DumpShort(FILE *fd){ + int i; + fprintf(fd," Cpu Utilization : %2.1f %% \n",m_cpu_cp_u.GetVal()); + CCPortLatency::DumpShortHeader(fd); + for (i=0; i<m_max_ports; i++) { + fprintf(fd," %d | ",i); + CLatencyManagerPerPort * lp=&m_ports[i]; + lp->m_port.DumpShort(fd); + fprintf(fd,"\n"); + } + + +} + +void CLatencyManager::Dump(FILE *fd){ + int i; + fprintf(fd," cpu : %2.1f %% \n",m_cpu_cp_u.GetVal()); + for (i=0; i<m_max_ports; i++) { + fprintf(fd," port %d \n",i); + fprintf(fd," -----------------\n"); + CLatencyManagerPerPort * lp=&m_ports[i]; + lp->m_port.DumpCounters(fd); + } +} + +void CLatencyManager::DumpRxCheckVerification(FILE *fd, + uint64_t total_tx_rx_check){ + if ( !get_is_rx_check_mode() ) { + fprintf(fd," rx_checker is disabled \n"); + return; + } + fprintf(fd," rx_check Tx : %llu \n", (unsigned long long)total_tx_rx_check); + fprintf(fd," rx_check Rx : %llu \n", (unsigned long long)m_rx_check_manager.getTotalRx() ); + fprintf(fd," rx_check verification :" ); + if (m_rx_check_manager.getTotalRx() == total_tx_rx_check) { + fprintf(fd," OK \n" ); + }else{ + fprintf(fd," FAIL \n" ); + } +} + +uint8_t CLatencyPktModeICMP::getPacketLen() {return sizeof(icmp_pkt);} +const uint8_t *CLatencyPktModeICMP::getPacketData() {return icmp_pkt;} +void CLatencyPktModeICMP::rcv_debug_print(uint8_t *pkt) { + ICMPHeader *m_icmp = (ICMPHeader *)pkt; + printf ("received latency ICMP packet code:%d seq:%x\n" + , m_icmp->getType(), m_icmp->getSeqNum()); +}; + +void CLatencyPktModeICMP::send_debug_print(uint8_t *pkt) { + ICMPHeader *m_icmp = (ICMPHeader *)pkt; + printf ("Sending latency ICMP packet code:%d seq:%d\n", m_icmp->getType(), m_icmp->getSeqNum()); +} + +void CLatencyPktModeICMP::update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq) { + ICMPHeader * m_icmp =(ICMPHeader *)(pkt); + + if (m_submode == L_PKT_SUBMODE_0_SEQ) { + m_icmp->setSeqNum(0); + } else { + m_icmp->setSeqNum(*tx_seq); + (*tx_seq)++; + } + + if ((!is_client_to_server) && (m_submode == L_PKT_SUBMODE_REPLY)) { + m_icmp->setType(0); // echo reply + } else { + m_icmp->setType(8); // echo request + } + // ICMP checksum is calculated on payload + ICMP header + m_icmp->updateCheckSum(l4_len); + +} + +bool CLatencyPktModeICMP::IsLatencyPkt(IPHeader *ip) { + if (!ip) + return false; + if (ip->getProtocol() != 0x1) + return false; + return true; +}; + +void CLatencyPktModeICMP::update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq) { + ICMPHeader *m_icmp = (ICMPHeader *)(pkt); + *r_seq = m_icmp->getSeqNum(); + // handle wrap around, so can_send_packet will allow us to send + if (*r_seq == 0) + *t_seq = 0; +} + + +uint8_t CLatencyPktModeSCTP::getPacketLen() {return sizeof(sctp_pkt);} +const uint8_t *CLatencyPktModeSCTP::getPacketData() {return sctp_pkt;} +void CLatencyPktModeSCTP::rcv_debug_print(uint8_t *pkt) {printf("Received latency SCTP packet\n");} +void CLatencyPktModeSCTP::send_debug_print(uint8_t *pkt) {printf("Sending latency SCTP packet\n"); + // utl_DumpBuffer(stdout,pkt-20,28,0); +} +void CLatencyPktModeSCTP::update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq) {} +bool CLatencyPktModeSCTP::IsLatencyPkt(IPHeader *ip) { + if (!ip) { + return false; + } + if (ip->getProtocol() != 0x84) { + return false; + } + return true; +}; +void CLatencyPktModeSCTP::update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq) {} diff --git a/src/latency.h b/src/latency.h new file mode 100644 index 00000000..59481a59 --- /dev/null +++ b/src/latency.h @@ -0,0 +1,386 @@ +#ifndef LATENCY_H +#define LATENCY_H +/* + Hanoh Haim + Ido Barnea + Cisco Systems, Inc. +*/ + +/* +Copyright (c) 2015-2015 Cisco Systems, Inc. + +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. +*/ +#include <bp_sim.h> + +#define L_PKT_SUBMODE_NO_REPLY 1 +#define L_PKT_SUBMODE_REPLY 2 +#define L_PKT_SUBMODE_0_SEQ 3 + +class CLatencyPktInfo { +public: + void Create(class CLatencyPktMode *m_l_pkt_info); + void Delete(); + void set_ip(uint32_t src, + uint32_t dst, + uint32_t dual_port_mask); + rte_mbuf_t * generate_pkt(int port_id,uint32_t extern_ip=0); + + CGenNode * getNode(){ + return (&m_dummy_node); + } + + uint16_t get_payload_offset(void){ + return ( m_pkt_indication.getFastPayloadOffset()); + } + + uint16_t get_l4_offset(void){ + return ( m_pkt_indication.getFastTcpOffset()); + } + + uint16_t get_pkt_size(void){ + return ( m_packet->pkt_len ); + } + +private: + ipaddr_t m_client_ip; + ipaddr_t m_server_ip; + uint32_t m_dual_port_mask; + + CGenNode m_dummy_node; + CFlowPktInfo m_pkt_info; + CPacketIndication m_pkt_indication; + CCapPktRaw * m_packet; +}; + + +#define LATENCY_MAGIC 0x12345600 + +struct latency_header { + + uint64_t time_stamp; + uint32_t magic; + uint32_t seq; + + uint8_t get_id(){ + return( magic & 0xff); + } +}; + +class CSimplePacketParser { +public: + + CSimplePacketParser(rte_mbuf_t * m){ + m_m=m; + } + + bool Parse(); + uint8_t getTTl(); + uint16_t getPktSize(); + + inline bool IsLatencyPkt(uint8_t *p) { + latency_header * h=(latency_header *)(p); + if ( (h->magic & 0xffffff00) != LATENCY_MAGIC ){ + return (false); + } + + return true; + } + + +public: + IPHeader * m_ipv4; + IPv6Header * m_ipv6; + uint8_t m_protocol; + uint16_t m_vlan_offset; + uint16_t m_option_offset; + uint8_t * m_l4; +private: + rte_mbuf_t * m_m ; +}; + + + +class CLatencyManager ; + +// per port +class CCPortLatency { +public: + bool Create(CLatencyManager * parent, + uint8_t id, + uint16_t offset, + uint16_t l4_offset, + uint16_t pkt_size, + CCPortLatency * rx_port + ); + void Delete(); + void reset(); + bool can_send_packet(int direction){ + // in icmp_reply mode, can send response from server, only after we got the relevant request + // if we got request, we are sure to have NAT translation in place already. + if ((CGlobalInfo::m_options.m_l_pkt_mode == L_PKT_SUBMODE_REPLY) && (direction == 1)) { + if (m_icmp_tx_seq <= m_icmp_rx_seq) + return(true); + else + return(false); + } + + if ( !CGlobalInfo::is_learn_mode() ) { + return(true); + } + return ( m_nat_can_send ); + } + uint32_t external_nat_ip(){ + return (m_nat_external_ip); + } + + void update_packet(rte_mbuf_t * m, int port_id); + + bool do_learn(uint32_t external_ip); + + bool check_packet(rte_mbuf_t * m, + CRx_check_header * & rx_p); + bool check_rx_check(rte_mbuf_t * m); + + + bool dump_packet(rte_mbuf_t * m); + + void DumpCounters(FILE *fd); + void dump_counters_json(std::string & json ); + + void DumpShort(FILE *fd); + void dump_json(std::string & json ); + void dump_json_v2(std::string & json ); + + uint32_t get_jitter_usec(void){ + return ((uint32_t)(m_jitter.get_jitter()*1000000.0)); + } + + + static void DumpShortHeader(FILE *fd); + + bool is_any_err(){ + if ( (m_tx_pkt_ok == m_rx_port->m_pkt_ok ) && + + ((m_unsup_prot+ + m_no_magic+ + m_no_id+ + m_seq_error+ + m_length_error+m_no_ipv4_option+m_tx_pkt_err)==0) ) { + return (false); + } + return (true); + } + + uint16_t get_icmp_tx_seq() {return m_icmp_tx_seq;} + uint16_t get_icmp_rx_seq() {return m_icmp_rx_seq;} + +private: + std::string get_field(std::string name,float f); + + +private: + CLatencyManager * m_parent; + CCPortLatency * m_rx_port; /* corespond rx port */ + bool m_nat_learn; + bool m_nat_can_send; + uint32_t m_nat_external_ip; + + uint32_t m_tx_seq; + uint32_t m_rx_seq; + + uint8_t m_pad; + uint8_t m_id; + uint16_t m_payload_offset; + uint16_t m_l4_offset; + + uint16_t m_pkt_size; + // following two variables are for the latency ICMP reply mode. + // if we want to pass through firewall, we want to send reply only after we got request with same seq num + // ICMP seq num of next packet we will transmit + uint16_t m_icmp_tx_seq; + // ICMP seq num of last request we got + uint16_t m_icmp_rx_seq; + uint16_t pad1[1]; + +public: + uint64_t m_tx_pkt_ok; + uint64_t m_tx_pkt_err; + + uint64_t m_pkt_ok; + uint64_t m_unsup_prot; + uint64_t m_no_magic; + uint64_t m_no_id; + uint64_t m_seq_error; + uint64_t m_rx_check; + uint64_t m_no_ipv4_option; + + + uint64_t m_length_error; + CTimeHistogram m_hist; /* all window */ + CJitter m_jitter; +}; + + +class CPortLatencyHWBase { +public: + virtual int tx(rte_mbuf_t * m)=0; + virtual rte_mbuf_t * rx()=0; + virtual uint16_t rx_burst(struct rte_mbuf **rx_pkts, + uint16_t nb_pkts){ + return(0); + } +}; + + +class CLatencyManagerCfg { +public: + CLatencyManagerCfg (){ + m_max_ports=0; + m_cps=0.0; + m_client_ip.v4=0x10000000; + m_server_ip.v4=0x20000000; + m_dual_port_mask=0x01000000; + } + uint32_t m_max_ports; + double m_cps;// CPS + CPortLatencyHWBase * m_ports[MAX_LATENCY_PORTS]; + ipaddr_t m_client_ip; + ipaddr_t m_server_ip; + uint32_t m_dual_port_mask; + +}; + + +class CLatencyManagerPerPort { +public: + CCPortLatency m_port; + CPortLatencyHWBase * m_io; + uint32_t m_flag; + +}; + + +class CLatencyPktMode { + public: + uint8_t m_submode; + CLatencyPktMode(uint8_t submode) {m_submode = submode;} + virtual uint8_t getPacketLen() = 0; + virtual const uint8_t *getPacketData() = 0; + virtual void rcv_debug_print(uint8_t *pkt) = 0; + virtual void send_debug_print(uint8_t *pkt) = 0; + virtual void update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq) = 0; + virtual bool IsLatencyPkt(IPHeader *ip) = 0; + uint8_t l4_header_len() {return 8;} + virtual void update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq) = 0; + virtual uint8_t getProtocol() = 0; + virtual ~CLatencyPktMode() {} +}; + +class CLatencyPktModeICMP: public CLatencyPktMode { + public: + CLatencyPktModeICMP(uint8_t submode) : CLatencyPktMode(submode) {} + uint8_t getPacketLen(); + const uint8_t *getPacketData(); + void rcv_debug_print(uint8_t *); + void send_debug_print(uint8_t *); + void update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq); + bool IsLatencyPkt(IPHeader *ip); + void update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq); + uint8_t getProtocol() {return 0x1;} +}; + +class CLatencyPktModeSCTP: public CLatencyPktMode { + public: + CLatencyPktModeSCTP(uint8_t submode) : CLatencyPktMode(submode) {} + uint8_t getPacketLen(); + const uint8_t *getPacketData(); + void rcv_debug_print(uint8_t *); + void send_debug_print(uint8_t *); + void update_pkt(uint8_t *pkt, bool is_client_to_server, uint16_t l4_len, uint16_t *tx_seq); + bool IsLatencyPkt(IPHeader *ip); + void update_recv(uint8_t *pkt, uint16_t *r_seq, uint16_t *t_seq); + uint8_t getProtocol() {return 0x84;} +}; + +class CLatencyManager { +public: + bool Create(CLatencyManagerCfg * cfg); + void Delete(); + void reset(); + void start(int iter); + void stop(); + bool is_active(); + void set_ip(uint32_t client_ip, + uint32_t server_ip, + uint32_t mask_dual_port){ + m_pkt_gen.set_ip(client_ip,server_ip,mask_dual_port); + } + void Dump(FILE *fd); // dump all + void DumpShort(FILE *fd); // dump short histogram of latency + + void DumpRxCheck(FILE *fd); // dump all + void DumpShortRxCheck(FILE *fd); // dump short histogram of latency + void rx_check_dump_json(std::string & json); + uint16_t get_latency_header_offset(){ + return ( m_pkt_gen.get_payload_offset() ); + } + void update(); + void dump_json(std::string & json ); // dump to json + void dump_json_v2(std::string & json ); + void DumpRxCheckVerification(FILE *fd,uint64_t total_tx_rx_check); + void set_mask(uint32_t mask){ + m_port_mask=mask; + } + double get_max_latency(void); + double get_avr_latency(void); + bool is_any_error(); + uint64_t get_total_pkt(); + uint64_t get_total_bytes(); + CNatRxManager * get_nat_manager(){ + return ( &m_nat_check_manager ); + } + CLatencyPktMode *c_l_pkt_mode; + +private: + void send_pkt_all_ports(); + void try_rx(); + void try_rx_queues(); + void run_rx_queue_msgs(uint8_t thread_id, + CNodeRing * r); + void wait_for_rx_dump(); + void handle_rx_pkt(CLatencyManagerPerPort * lp, + rte_mbuf_t * m); + /* messages handlers */ + void handle_latency_pkt_msg(uint8_t thread_id, + CGenNodeLatencyPktInfo * msg); + + pqueue_t m_p_queue; /* priorty queue */ + bool m_is_active; + CLatencyPktInfo m_pkt_gen; + CLatencyManagerPerPort m_ports[MAX_LATENCY_PORTS]; + uint64_t m_d_time; // calc tick betwen sending + double m_cps; + double m_delta_sec; + uint64_t m_start_time; // calc tick betwen sending + uint32_t m_port_mask; + uint32_t m_max_ports; + RxCheckManager m_rx_check_manager; + CNatRxManager m_nat_check_manager; + CCpuUtlDp m_cpu_dp_u; + CCpuUtlCp m_cpu_cp_u; + volatile bool m_do_stop __rte_cache_aligned ; +}; + +#endif + diff --git a/src/main_dpdk.cpp b/src/main_dpdk.cpp index f4acb344..fc9dd00e 100755 --- a/src/main_dpdk.cpp +++ b/src/main_dpdk.cpp @@ -51,6 +51,7 @@ limitations under the License. #include <rte_mbuf.h> #include <rte_random.h> #include "bp_sim.h" +#include "latency.h" #include "os_time.h" #include <common/arg/SimpleGlob.h> #include <common/arg/SimpleOpt.h> @@ -77,6 +78,7 @@ extern "C" { #include "utl_term_io.h" #include "msg_manager.h" #include "platform_cfg.h" +#include "latency.h" #include <internal_api/trex_platform_api.h> @@ -118,13 +120,10 @@ static inline int get_is_latency_thread_enable(){ return (CGlobalInfo::m_options.is_latency_enabled() ?1:0); } - - struct port_cfg_t; class CPhyEthIF; class CPhyEthIFStats ; - class CTRexExtendedDriverBase { public: @@ -436,12 +435,6 @@ static inline int get_min_sample_rate(void){ return ( get_ex_drv()->get_min_sample_rate()); } - - - - - - #define MAX_DPDK_ARGS 40 static CPlatformYamlInfo global_platform_cfg_info; static int global_dpdk_args_num ; @@ -450,9 +443,6 @@ static char global_cores_str[100]; static char global_prefix_str[100]; static char global_loglevel_str[20]; - - - // cores =0==1,1*2,2,3,4,5,6 // An enum for all the option types enum { OPT_HELP, @@ -487,6 +477,7 @@ enum { OPT_HELP, OPT_IPV6, OPT_LEARN, OPT_LEARN_VERIFY, + OPT_L_PKT_MODE, OPT_NO_FLOW_CONTROL, OPT_RX_CHECK_HOPS, OPT_MAC_FILE, @@ -499,9 +490,6 @@ enum { OPT_HELP, }; - - - /* these are the argument types: SO_NONE -- no argument needed SO_REQ_SEP -- single required argument @@ -549,6 +537,7 @@ static CSimpleOpt::SOption parser_options[] = { OPT_IPV6, "--ipv6", SO_NONE }, { OPT_LEARN, "--learn", SO_NONE }, { OPT_LEARN_VERIFY, "--learn-verify", SO_NONE }, + { OPT_L_PKT_MODE, "--l-pkt-mode", SO_REQ_SEP }, { OPT_NO_FLOW_CONTROL, "--no-flow-control", SO_NONE }, { OPT_VLAN, "--vlan", SO_NONE }, { OPT_MAC_FILE, "--mac", SO_REQ_SEP }, @@ -622,7 +611,11 @@ static int usage(){ printf(" --learn : Work in NAT environments, learn the dynamic NAT translation and ALG \n"); printf(" --learn-verify : Learn the translation, but intended for verification of the mechanism in cases that NAT does not exist \n"); printf(" \n"); - + printf(" --l-pkt-mode [0-3] : Set mode for sending latency packets.\n"); + printf(" 0 (default) send SCTP packets \n"); + printf(" 1 Send ICMP request packets \n"); + printf(" 2 Send ICMP requests from client side, and response from server side (for working with firewall) \n"); + printf(" 3 Send ICMP requests with sequence ID 0 from both sides \n"); printf(" -v [1-3] : verbose mode ( works only on the debug image ! ) \n"); printf(" 1 show only stats \n"); printf(" 2 run preview do not write to file \n"); @@ -685,7 +678,7 @@ static int usage(){ printf(" limitations under the License. \n"); printf(" \n"); printf(" Open Source Components / Libraries \n"); - printf(" DPDK (BSD) \n"); + printf(" DPDK (BSD) \n"); printf(" YAML-CPP (BSD) \n"); printf(" JSONCPP (MIT) \n"); printf(" \n"); @@ -696,6 +689,7 @@ static int usage(){ printf(" User : %s \n",VERSION_USER); printf(" Date : %s , %s \n",get_build_date(),get_build_time()); printf(" Uuid : %s \n",VERSION_UIID); + printf(" Git SHA : %s \n",VERSION_GIT_SHA); return (0); } @@ -782,6 +776,11 @@ static int parse_options(int argc, char *argv[], CParserOption* po, bool first_t po->preview.set_lean_and_verify_mode_enable(true); break; + case OPT_L_PKT_MODE : + sscanf(args.OptionArg(),"%d", &tmp_data); + po->m_l_pkt_mode=(uint8_t)tmp_data; + break; + case OPT_REAL_TIME : printf(" warning -r is deprecated, real time is not needed any more , it is the default \n"); po->preview.setRealTime(true); @@ -1448,11 +1447,11 @@ void CPhyEthIF::configure(uint16_t nb_rx_queue, /* -rx-queue 0 - default- all traffic no SCTP +rx-queue 0 - default- all traffic not goint to queue 1 will be drop as queue is disable -rx-queue 1 - SCTP traffic will go to here +rx-queue 1 - Latency measurement packets will go here pci_reg_write(IXGBE_L34T_IMIR(0),(1<<21)); @@ -1918,8 +1917,6 @@ public: virtual int send_node(CGenNode * node); }; - - bool CCoreEthIF::Create(uint8_t core_id, uint16_t tx_client_queue_id, CPhyEthIF * tx_client_port, @@ -1939,54 +1936,6 @@ bool CCoreEthIF::Create(uint8_t core_id, return (true); } -bool CCoreEthIF::process_rx_pkt(pkt_dir_t dir, - rte_mbuf_t * m){ - - CSimplePacketParser parser(m); - if ( !parser.Parse() ){ - return false; - } - bool send=false; - if ( parser.IsLatencyPkt() ){ - send=true; - - }else{ - if ( get_is_rx_filter_enable() ){ - uint8_t max_ttl = 0xff - get_rx_check_hops(); - uint8_t pkt_ttl = parser.getTTl(); - if ( (pkt_ttl==max_ttl) || (pkt_ttl==(max_ttl-1) ) ) { - send=true; - } - } - } - - - if (send) { - CGenNodeLatencyPktInfo * node=(CGenNodeLatencyPktInfo * )CGlobalInfo::create_node(); - if ( node ) { - node->m_msg_type = CGenNodeMsgBase::LATENCY_PKT; - node->m_dir = dir; - node->m_latency_offset = 0xdead; - node->m_pkt = m; - if ( m_ring_to_rx->Enqueue((CGenNode*)node)==0 ){ - }else{ - CGlobalInfo::free_node((CGenNode *)node); - send=false; - } - - #ifdef LATENCY_QUEUE_TRACE_ - printf("rx to cp --\n"); - rte_pktmbuf_dump(stdout,m, rte_pktmbuf_pkt_len(m)); - #endif - }else{ - send=false; - } - } - return (send); -} - - - void CCoreEthIF::flush_rx_queue(void){ pkt_dir_t dir ; bool is_latency=get_is_latency_thread_enable(); @@ -2020,7 +1969,6 @@ void CCoreEthIF::flush_rx_queue(void){ } } - int CCoreEthIF::flush_tx_queue(void){ /* flush both sides */ pkt_dir_t dir ; @@ -2040,7 +1988,6 @@ int CCoreEthIF::flush_tx_queue(void){ return (0); } - void CCoreEthIF::GetCoreCounters(CVirtualIFPerSideStats *stats){ stats->Clear(); pkt_dir_t dir ; @@ -2858,7 +2805,7 @@ private: int create_pkt(uint8_t *pkt,int pkt_size); int create_udp_pkt(); - int create_sctp_pkt(); + int create_icmp_pkt(); @@ -2976,7 +2923,6 @@ int CGlobalTRex::test_send(){ int i; //set_promisc_all(true); - //create_sctp_pkt(); create_udp_pkt(); CRx_check_header rx_check_header; @@ -2999,18 +2945,7 @@ int CGlobalTRex::test_send(){ //test_send_pkts(m_latency_tx_queue_id,1,2); //test_send_pkts(m_latency_tx_queue_id,1,3); test_send_pkts(0,1,0); - test_send_pkts(0,1,1); - //test_send_pkts(2,1,0); - - - //test_send_pkts(0,1,1); - //test_send_pkts(0,1,2); - //test_send_pkts(0,1,3); - - /*test_send_pkts(2,1,0); - test_send_pkts(2,1,1); - test_send_pkts(2,1,2); - test_send_pkts(2,1,3);*/ + test_send_pkts(0,2,1); /*delay(1000); fprintf(stdout," --------------------------------\n"); @@ -3095,22 +3030,21 @@ const uint8_t udp_pkt[]={ }; -const uint8_t sctp_pkt1[]={ - +const uint8_t icmp_pkt1[]={ 0x00,0x00,0x00,0x01,0x00,0x00, 0x00,0x00,0x00,0x01,0x00,0x00, 0x08,0x00, 0x45,0x02,0x00,0x30, 0x00,0x00,0x40,0x00, - 0x40,0x84,0xbd,0x04, - 0x01,0x01,0x01,0x01, //sIP - 0x02,0x02,0x02,0x02, //DIP - - 0x80,0x44,//SPORT - 0x00,0x50,//DPORT + 0xaa,0x01,0xbd,0x04, + 0x9b,0xe6,0x18,0x9b, //SIP + 0xcb,0xff,0xfc,0xc2, //DIP - 0x00,0x00,0x00,0x00, //checksum + 0x08, 0x00, + 0x01, 0x02, //checksum + 0xaa, 0xbb, // id + 0x00, 0x00, // Sequence number 0x11,0x22,0x33,0x44, // magic 0x00,0x00,0x00,0x00, //64 bit counter @@ -3118,8 +3052,7 @@ const uint8_t sctp_pkt1[]={ 0x00,0x01,0xa0,0x00, //seq 0x00,0x00,0x00,0x00, -}; - +}; @@ -3148,8 +3081,8 @@ int CGlobalTRex::create_udp_pkt(){ return (create_pkt((uint8_t*)udp_pkt,sizeof(udp_pkt))); } -int CGlobalTRex::create_sctp_pkt(){ - return (create_pkt((uint8_t*)sctp_pkt1,sizeof(sctp_pkt1))); +int CGlobalTRex::create_icmp_pkt(){ + return (create_pkt((uint8_t*)icmp_pkt1,sizeof(icmp_pkt1))); } @@ -3396,7 +3329,7 @@ int CGlobalTRex::ixgbe_start(void){ m_cores_to_dual_ports+1, &m_port_cfg.m_port_conf); - /* the latency queue for SCTP */ + /* the latency queue for latency measurement packets */ m_latency_tx_queue_id= m_cores_to_dual_ports; socket_id_t socket_id = CGlobalInfo::m_socket.port_to_socket((port_id_t)i); @@ -3413,7 +3346,7 @@ int CGlobalTRex::ixgbe_start(void){ /* set the filter queue */ _if->set_rx_queue(1); - /* sctp ring is 1 */ + /* latency measurement ring is 1 */ _if->rx_queue_setup(1, RTE_TEST_RX_LATENCY_DESC_DEFAULT, socket_id, @@ -4114,13 +4047,15 @@ int CGlobalTRex::run_in_master(){ break; } - m_mg.rx_check_dump_json(json ); - m_zmq_publisher.publish_json(json); - }/* ex checked */ } + if ( get_is_rx_check_mode() ) { + m_mg.rx_check_dump_json(json ); + m_zmq_publisher.publish_json(json); + } + /* backward compatible */ m_mg.dump_json(json ); m_zmq_publisher.publish_json(json); @@ -4355,6 +4290,54 @@ int CGlobalTRex::start_send_master(){ static CGlobalTRex g_trex; +bool CCoreEthIF::process_rx_pkt(pkt_dir_t dir, + rte_mbuf_t * m){ + + CSimplePacketParser parser(m); + if ( !parser.Parse() ){ + return false; + } + bool send=false; + CLatencyPktMode *c_l_pkt_mode = g_trex.m_mg.c_l_pkt_mode; + bool is_lateancy_pkt = c_l_pkt_mode->IsLatencyPkt(parser.m_ipv4) & parser.IsLatencyPkt(parser.m_l4 + c_l_pkt_mode->l4_header_len()); + + if (is_lateancy_pkt){ + send=true; + }else{ + if ( get_is_rx_filter_enable() ){ + uint8_t max_ttl = 0xff - get_rx_check_hops(); + uint8_t pkt_ttl = parser.getTTl(); + if ( (pkt_ttl==max_ttl) || (pkt_ttl==(max_ttl-1) ) ) { + send=true; + } + } + } + + + if (send) { + CGenNodeLatencyPktInfo * node=(CGenNodeLatencyPktInfo * )CGlobalInfo::create_node(); + if ( node ) { + node->m_msg_type = CGenNodeMsgBase::LATENCY_PKT; + node->m_dir = dir; + node->m_latency_offset = 0xdead; + node->m_pkt = m; + if ( m_ring_to_rx->Enqueue((CGenNode*)node)==0 ){ + }else{ + CGlobalInfo::free_node((CGenNode *)node); + send=false; + } + + #ifdef LATENCY_QUEUE_TRACE_ + printf("rx to cp --\n"); + rte_pktmbuf_dump(stdout,m, rte_pktmbuf_pkt_len(m)); + #endif + }else{ + send=false; + } + } + return (send); +} + TrexStateless * get_stateless_obj() { return g_trex.m_trex_stateless; @@ -4480,8 +4463,7 @@ int update_global_info_from_platform_file(){ CGlobalInfo::m_memory_cfg.set(cg->m_memory,mul); CGlobalInfo::m_memory_cfg.set_number_of_dp_cors( - CGlobalInfo::m_options.get_number_of_dp_cores_needed() ); - + CGlobalInfo::m_options.get_number_of_dp_cores_needed() ); return (0); } @@ -4740,15 +4722,19 @@ int CTRexExtendedDriverBase1G::wait_for_stable_link(){ } int CTRexExtendedDriverBase1G::configure_drop_queue(CPhyEthIF * _if){ + uint8_t protocol; + if (CGlobalInfo::m_options.m_l_pkt_mode == 0) { + protocol = IPPROTO_SCTP; + } else { + protocol = IPPROTO_ICMP; + } + _if->pci_reg_write( E1000_RXDCTL(0) , 0); /* enable filter to pass packet to rx queue 1 */ - _if->pci_reg_write( E1000_IMIR(0), 0x00020000); - _if->pci_reg_write( E1000_IMIREXT(0), 0x00081000); - - _if->pci_reg_write( E1000_TTQF(0), 0x00000084 /* protocol */ + _if->pci_reg_write( E1000_TTQF(0), protocol | 0x00008100 /* enable */ | 0xE0010000 /* RX queue is 1 */ ); @@ -4776,11 +4762,13 @@ int CTRexExtendedDriverBase1G::configure_rx_filter_rules(CPhyEthIF * _if){ */ int i; // IPv4: bytes being compared are {TTL, Protocol} - uint16_t ff_rules_v4[4]={ + uint16_t ff_rules_v4[6]={ (uint16_t)(0xFF06 - v4_hops), (uint16_t)(0xFE11 - v4_hops), (uint16_t)(0xFF11 - v4_hops), (uint16_t)(0xFE06 - v4_hops), + (uint16_t)(0xFF01 - v4_hops), + (uint16_t)(0xFE01 - v4_hops), } ; // IPv6: bytes being compared are {NextHdr, HopLimit} uint16_t ff_rules_v6[2]={ @@ -4921,24 +4909,30 @@ int CTRexExtendedDriverBase10G::configure_rx_filter_rules(CPhyEthIF * _if){ // IPv4: bytes being compared are {TTL, Protocol} - uint16_t ff_rules_v4[4]={ + uint16_t ff_rules_v4[6]={ (uint16_t)(0xFF11 - v4_hops), (uint16_t)(0xFE11 - v4_hops), (uint16_t)(0xFF06 - v4_hops), (uint16_t)(0xFE06 - v4_hops), + (uint16_t)(0xFF01 - v4_hops), + (uint16_t)(0xFE01 - v4_hops), } ; // IPv6: bytes being compared are {NextHdr, HopLimit} - uint16_t ff_rules_v6[4]={ + uint16_t ff_rules_v6[6]={ + (uint16_t)(0x3CFF - hops), + (uint16_t)(0x3CFE - hops), (uint16_t)(0x3CFF - hops), (uint16_t)(0x3CFE - hops), (uint16_t)(0x3CFF - hops), (uint16_t)(0x3CFE - hops), } ; - const rte_l4type ff_rules_type[4]={ + const rte_l4type ff_rules_type[6]={ RTE_FDIR_L4TYPE_UDP, RTE_FDIR_L4TYPE_UDP, RTE_FDIR_L4TYPE_TCP, - RTE_FDIR_L4TYPE_TCP + RTE_FDIR_L4TYPE_TCP, + RTE_FDIR_L4TYPE_NONE, + RTE_FDIR_L4TYPE_NONE } ; uint16_t *ff_rules; @@ -4978,8 +4972,7 @@ int CTRexExtendedDriverBase10G::configure_rx_filter_rules(CPhyEthIF * _if){ } int CTRexExtendedDriverBase10G::configure_drop_queue(CPhyEthIF * _if){ - - /* enable rule 0 SCTP -> queue 1 for latency */ + /* enable rule 0 SCTP -> queue 1 for latency */ /* 1<<21 means that queue 1 is for SCTP */ _if->pci_reg_write(IXGBE_L34T_IMIR(0),(1<<21)); @@ -4989,7 +4982,6 @@ int CTRexExtendedDriverBase10G::configure_drop_queue(CPhyEthIF * _if){ ((0x0f)<<IXGBE_FTQF_5TUPLE_MASK_SHIFT)|IXGBE_FTQF_QUEUE_ENABLE); /* disable queue zero - default all traffic will go to here and will be dropped */ - _if->pci_reg_write( IXGBE_RXDCTL(0) , 0); return (0); } @@ -5050,7 +5042,7 @@ void CTRexExtendedDriverBase40G::update_configuration(port_cfg_t * cfg){ } - +/* Add rule to send packets with protocol 'type', and ttl 'ttl' to rx queue 1 */ void CTRexExtendedDriverBase40G::add_rules(CPhyEthIF * _if, enum rte_eth_flow_type type, uint8_t ttl){ @@ -5075,7 +5067,11 @@ void CTRexExtendedDriverBase40G::add_rules(CPhyEthIF * _if, filter.input.flow_type = type; filter.input.ttl=ttl; - /* any SCTP move to queue number 1 */ + if (type == RTE_ETH_FLOW_TYPE_IPV4_OTHER) { + filter.input.flow.ip4_flow.l4_proto = IPPROTO_ICMP; // In this case we want filter for icmp packets + } + + /* We want to place latency packets in queue 1 */ ret=rte_eth_dev_filter_ctrl(port_id, RTE_ETH_FILTER_FDIR, RTE_ETH_FILTER_ADD, (void*)&filter); @@ -5104,7 +5100,9 @@ int CTRexExtendedDriverBase40G::configure_rx_filter_rules(CPhyEthIF * _if){ int CTRexExtendedDriverBase40G::configure_drop_queue(CPhyEthIF * _if){ - add_rules(_if,RTE_ETH_FLOW_TYPE_SCTPV4,0); + /* Configure queue for latency packets */ + add_rules(_if,RTE_ETH_FLOW_TYPE_IPV4_OTHER,255); + add_rules(_if,RTE_ETH_FLOW_TYPE_SCTPV4,255); return (0); } diff --git a/src/platform_cfg.cpp b/src/platform_cfg.cpp index 547cc3ad..ca42aa31 100755 --- a/src/platform_cfg.cpp +++ b/src/platform_cfg.cpp @@ -35,8 +35,8 @@ void CPlatformMemoryYamlInfo::reset(){ m_mbuf[MBUF_64] = m_mbuf[MBUF_64]*2; m_mbuf[MBUF_2048] = CONST_NB_MBUF_2_10G/2; - m_mbuf[TRAFFIC_MBUF_64] = m_mbuf[MBUF_64]*2; - m_mbuf[TRAFFIC_MBUF_2048] = CONST_NB_MBUF_2_10G*4; + m_mbuf[TRAFFIC_MBUF_64] = m_mbuf[MBUF_64] * 4; + m_mbuf[TRAFFIC_MBUF_2048] = CONST_NB_MBUF_2_10G * 8; m_mbuf[MBUF_DP_FLOWS] = (1024*1024/2); m_mbuf[MBUF_GLOBAL_FLOWS] =(10*1024/2); diff --git a/src/publisher/trex_publisher.h b/src/publisher/trex_publisher.h index 8d1be064..bd4392f7 100644 --- a/src/publisher/trex_publisher.h +++ b/src/publisher/trex_publisher.h @@ -39,10 +39,16 @@ public: void publish_json(const std::string &s); enum event_type_e { - EVENT_PORT_STARTED = 0, - EVENT_PORT_STOPPED = 1, - EVENT_SERVER_STOPPED = 2, - EVENT_PORT_FINISHED_TX = 3, + EVENT_PORT_STARTED = 0, + EVENT_PORT_STOPPED = 1, + EVENT_PORT_PAUSED = 2, + EVENT_PORT_RESUMED = 3, + EVENT_PORT_FINISHED_TX = 4, + EVENT_PORT_FORCE_ACQUIRED = 5, + + EVENT_SERVER_STOPPED = 100, + + }; void publish_event(event_type_e type, const Json::Value &data = Json::nullValue); diff --git a/src/rpc-server/commands/trex_rpc_cmd_general.cpp b/src/rpc-server/commands/trex_rpc_cmd_general.cpp index 9570aae7..a2d4c284 100644 --- a/src/rpc-server/commands/trex_rpc_cmd_general.cpp +++ b/src/rpc-server/commands/trex_rpc_cmd_general.cpp @@ -43,7 +43,7 @@ using namespace std; trex_rpc_cmd_rc_e TrexRpcCmdPing::_run(const Json::Value ¶ms, Json::Value &result) { - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -198,10 +198,6 @@ TrexRpcCmdGetSysInfo::_run(const Json::Value ¶ms, Json::Value &result) { } - section["ports"][i]["owner"] = port->get_owner(); - - section["ports"][i]["status"] = port->get_state_as_string(); - } return (TREX_RPC_CMD_OK); @@ -224,7 +220,7 @@ TrexRpcCmdGetOwner::_run(const Json::Value ¶ms, Json::Value &result) { uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); - section["owner"] = port->get_owner(); + section["owner"] = port->get_owner().get_name(); return (TREX_RPC_CMD_OK); } @@ -238,7 +234,7 @@ TrexRpcCmdAcquire::_run(const Json::Value ¶ms, Json::Value &result) { uint8_t port_id = parse_port(params, result); - const string &new_owner = parse_string(params, "user", result); + const string &new_owner = parse_string(params, "user", result); bool force = parse_bool(params, "force", result); /* if not free and not you and not force - fail */ @@ -250,7 +246,7 @@ TrexRpcCmdAcquire::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = port->get_owner_handler(); + result["result"] = port->get_owner().get_handler(); return (TREX_RPC_CMD_OK); } @@ -272,7 +268,7 @@ TrexRpcCmdRelease::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -288,8 +284,6 @@ TrexRpcCmdGetPortStats::_run(const Json::Value ¶ms, Json::Value &result) { TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); - result["result"]["status"] = port->get_state_as_string(); - try { port->encode_stats(result["result"]); } catch (const TrexRpcException &ex) { @@ -300,41 +294,25 @@ TrexRpcCmdGetPortStats::_run(const Json::Value ¶ms, Json::Value &result) { } /** - * request the server a sync about a specific user + * fetch the port status + * + * @author imarom (09-Dec-15) + * + * @param params + * @param result * + * @return trex_rpc_cmd_rc_e */ trex_rpc_cmd_rc_e -TrexRpcCmdSyncUser::_run(const Json::Value ¶ms, Json::Value &result) { - - const string &user = parse_string(params, "user", result); - bool sync_streams = parse_bool(params, "sync_streams", result); - - result["result"] = Json::arrayValue; - - for (auto port : get_stateless_obj()->get_port_list()) { - if (port->get_owner() == user) { - - Json::Value owned_port; +TrexRpcCmdGetPortStatus::_run(const Json::Value ¶ms, Json::Value &result) { + uint8_t port_id = parse_port(params, result); - owned_port["port_id"] = port->get_port_id(); - owned_port["handler"] = port->get_owner_handler(); - owned_port["state"] = port->get_state_as_string(); - - /* if sync streams was asked - sync all the streams */ - if (sync_streams) { - owned_port["streams"] = Json::arrayValue; + TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); - std::vector <TrexStream *> streams; - port->get_object_list(streams); + result["result"]["owner"] = (port->get_owner().is_free() ? "" : port->get_owner().get_name()); + result["result"]["state"] = port->get_state_as_string(); - for (auto stream : streams) { - owned_port["streams"].append(stream->get_stream_json()); - } - } - - result["result"].append(owned_port); - } - } return (TREX_RPC_CMD_OK); } + diff --git a/src/rpc-server/commands/trex_rpc_cmd_stream.cpp b/src/rpc-server/commands/trex_rpc_cmd_stream.cpp index dea4c171..fa3d96b2 100644 --- a/src/rpc-server/commands/trex_rpc_cmd_stream.cpp +++ b/src/rpc-server/commands/trex_rpc_cmd_stream.cpp @@ -23,6 +23,7 @@ limitations under the License. #include <trex_stream.h> #include <trex_stateless.h> #include <trex_stateless_port.h> +#include <trex_streams_compiler.h> #include <iostream> @@ -52,7 +53,8 @@ static uint64_t str2num(const string &str) { trex_rpc_cmd_rc_e TrexRpcCmdAddStream::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_int(params, "port_id", result); + uint8_t port_id = parse_port(params, result); + uint32_t stream_id = parse_int(params, "stream_id", result); const Json::Value §ion = parse_object(params, "stream", result); @@ -122,7 +124,7 @@ TrexRpcCmdAddStream::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -296,15 +298,7 @@ TrexRpcCmdAddStream::validate_stream(const TrexStream *stream, Json::Value &resu generate_execute_err(result, ss.str()); } - /* port id should be between 0 and count - 1 */ - if (stream->m_port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - delete stream; - generate_execute_err(result, ss.str()); - } - - /* add the stream to the port's stream table */ + /* add the stream to the port's stream table */ TrexStatelessPort * port = get_stateless_obj()->get_port_by_id(stream->m_port_id); /* does such a stream exists ? */ @@ -323,17 +317,11 @@ TrexRpcCmdAddStream::validate_stream(const TrexStream *stream, Json::Value &resu **************************/ trex_rpc_cmd_rc_e TrexRpcCmdRemoveStream::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - uint32_t stream_id = parse_int(params, "stream_id", result); - - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); + + uint32_t stream_id = parse_int(params, "stream_id", result); TrexStream *stream = port->get_stream_by_id(stream_id); if (!stream) { @@ -350,7 +338,7 @@ TrexRpcCmdRemoveStream::_run(const Json::Value ¶ms, Json::Value &result) { delete stream; - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -362,14 +350,8 @@ TrexRpcCmdRemoveStream::_run(const Json::Value ¶ms, Json::Value &result) { **************************/ trex_rpc_cmd_rc_e TrexRpcCmdRemoveAllStreams::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); try { @@ -379,7 +361,7 @@ TrexRpcCmdRemoveAllStreams::_run(const Json::Value ¶ms, Json::Value &result) } - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -393,27 +375,20 @@ trex_rpc_cmd_rc_e TrexRpcCmdGetStreamList::_run(const Json::Value ¶ms, Json::Value &result) { std::vector<uint32_t> stream_list; - uint8_t port_id = parse_byte(params, "port_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } - - TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); + uint8_t port_id = parse_port(params, result); + TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); - port->get_id_list(stream_list); + port->get_id_list(stream_list); - Json::Value json_list = Json::arrayValue; + Json::Value json_list = Json::arrayValue; - for (auto stream_id : stream_list) { - json_list.append(stream_id); - } + for (auto stream_id : stream_list) { + json_list.append(stream_id); + } - result["result"] = json_list; + result["result"] = json_list; - return (TREX_RPC_CMD_OK); + return (TREX_RPC_CMD_OK); } /*************************** @@ -423,18 +398,13 @@ TrexRpcCmdGetStreamList::_run(const Json::Value ¶ms, Json::Value &result) { **************************/ trex_rpc_cmd_rc_e TrexRpcCmdGetStream::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - bool get_pkt = parse_bool(params, "get_pkt", result); - uint32_t stream_id = parse_int(params, "stream_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); + bool get_pkt = parse_bool(params, "get_pkt", result); + uint32_t stream_id = parse_int(params, "stream_id", result); + TrexStream *stream = port->get_stream_by_id(stream_id); if (!stream) { @@ -462,17 +432,11 @@ TrexRpcCmdGetStream::_run(const Json::Value ¶ms, Json::Value &result) { trex_rpc_cmd_rc_e TrexRpcCmdStartTraffic::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - double duration = parse_double(params, "duration", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } - + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); + double duration = parse_double(params, "duration", result); + /* multiplier */ const Json::Value &mul_obj = parse_object(params, "mul", result); @@ -493,7 +457,7 @@ TrexRpcCmdStartTraffic::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"]["multiplier"] = port->get_multiplier(); return (TREX_RPC_CMD_OK); } @@ -504,14 +468,8 @@ TrexRpcCmdStartTraffic::_run(const Json::Value ¶ms, Json::Value &result) { **************************/ trex_rpc_cmd_rc_e TrexRpcCmdStopTraffic::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); try { @@ -520,7 +478,7 @@ TrexRpcCmdStopTraffic::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -531,17 +489,12 @@ TrexRpcCmdStopTraffic::_run(const Json::Value ¶ms, Json::Value &result) { **************************/ trex_rpc_cmd_rc_e TrexRpcCmdGetAllStreams::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - bool get_pkt = parse_bool(params, "get_pkt", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } - + + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); + bool get_pkt = parse_bool(params, "get_pkt", result); + std::vector <TrexStream *> streams; port->get_object_list(streams); @@ -573,14 +526,7 @@ TrexRpcCmdGetAllStreams::_run(const Json::Value ¶ms, Json::Value &result) { trex_rpc_cmd_rc_e TrexRpcCmdPauseTraffic::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } - + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); try { @@ -589,7 +535,7 @@ TrexRpcCmdPauseTraffic::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -601,14 +547,7 @@ TrexRpcCmdPauseTraffic::_run(const Json::Value ¶ms, Json::Value &result) { trex_rpc_cmd_rc_e TrexRpcCmdResumeTraffic::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } - + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); try { @@ -617,7 +556,7 @@ TrexRpcCmdResumeTraffic::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"] = Json::objectValue; return (TREX_RPC_CMD_OK); } @@ -629,14 +568,7 @@ TrexRpcCmdResumeTraffic::_run(const Json::Value ¶ms, Json::Value &result) { trex_rpc_cmd_rc_e TrexRpcCmdUpdateTraffic::_run(const Json::Value ¶ms, Json::Value &result) { - uint8_t port_id = parse_byte(params, "port_id", result); - - if (port_id >= get_stateless_obj()->get_port_count()) { - std::stringstream ss; - ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1; - generate_execute_err(result, ss.str()); - } - + uint8_t port_id = parse_port(params, result); TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); /* multiplier */ @@ -656,8 +588,60 @@ TrexRpcCmdUpdateTraffic::_run(const Json::Value ¶ms, Json::Value &result) { generate_execute_err(result, ex.what()); } - result["result"] = "ACK"; + result["result"]["multiplier"] = port->get_multiplier(); return (TREX_RPC_CMD_OK); } +/*************************** + * validate + * + * checks that the port + * attached streams are + * valid as a program + **************************/ +trex_rpc_cmd_rc_e +TrexRpcCmdValidate::_run(const Json::Value ¶ms, Json::Value &result) { + uint8_t port_id = parse_port(params, result); + TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); + + const TrexStreamsGraphObj *graph = NULL; + + try { + graph = port->validate(); + } + catch (const TrexException &ex) { + generate_execute_err(result, ex.what()); + } + + + result["result"]["rate"]["max_bps"] = graph->get_max_bps(); + result["result"]["rate"]["max_pps"] = graph->get_max_pps(); + result["result"]["rate"]["max_line_util"] = graph->get_max_bps() / port->get_port_speed_bps(); + + result["result"]["graph"]["expected_duration"] = graph->get_duration(); + result["result"]["graph"]["events_count"] = (int)graph->get_events().size(); + + result["result"]["graph"]["events"] = Json::arrayValue; + Json::Value &events_json = result["result"]["graph"]["events"]; + + int index = 0; + for (const auto &ev : graph->get_events()) { + Json::Value ev_json; + + ev_json["time_usec"] = ev.time; + ev_json["diff_bps"] = ev.diff_bps; + ev_json["diff_pps"] = ev.diff_pps; + ev_json["stream_id"] = ev.stream_id; + + events_json.append(ev_json); + + index++; + if (index >= 100) { + break; + } + } + + + return (TREX_RPC_CMD_OK); +} diff --git a/src/rpc-server/commands/trex_rpc_cmds.h b/src/rpc-server/commands/trex_rpc_cmds.h index b4f37e3b..c22ef390 100644 --- a/src/rpc-server/commands/trex_rpc_cmds.h +++ b/src/rpc-server/commands/trex_rpc_cmds.h @@ -77,7 +77,8 @@ TREX_RPC_CMD_DEFINE(TrexRpcCmdRelease, "release", 1, true); /** * port commands */ -TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStats, "get_port_stats", 1, true); +TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStats, "get_port_stats", 1, false); +TREX_RPC_CMD_DEFINE(TrexRpcCmdGetPortStatus, "get_port_status", 1, false); /** @@ -98,10 +99,10 @@ void parse_vm_instr_write_flow_var(const Json::Value &inst, TrexStream *stream, ); -TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStreamList, "get_stream_list", 1, true); -TREX_RPC_CMD_DEFINE(TrexRpcCmdGetAllStreams, "get_all_streams", 2, true); +TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStreamList, "get_stream_list", 1, false); +TREX_RPC_CMD_DEFINE(TrexRpcCmdGetAllStreams, "get_all_streams", 2, false); -TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStream, "get_stream", 3, true); +TREX_RPC_CMD_DEFINE(TrexRpcCmdGetStream, "get_stream", 3, false); @@ -112,7 +113,6 @@ TREX_RPC_CMD_DEFINE(TrexRpcCmdResumeTraffic, "resume_traffic", 1, true); TREX_RPC_CMD_DEFINE(TrexRpcCmdUpdateTraffic, "update_traffic", 2, true); -TREX_RPC_CMD_DEFINE(TrexRpcCmdSyncUser, "sync_user", 2, false); - +TREX_RPC_CMD_DEFINE(TrexRpcCmdValidate, "validate", 2, false); #endif /* __TREX_RPC_CMD_H__ */ diff --git a/src/rpc-server/trex_rpc_cmd.cpp b/src/rpc-server/trex_rpc_cmd.cpp index af0db3f4..d4eef1f7 100644 --- a/src/rpc-server/trex_rpc_cmd.cpp +++ b/src/rpc-server/trex_rpc_cmd.cpp @@ -63,8 +63,12 @@ TrexRpcCommand::verify_ownership(const Json::Value ¶ms, Json::Value &result) TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id); - if (!port->verify_owner_handler(handler)) { - generate_execute_err(result, "invalid handler provided. please pass the handler given when calling 'acquire' or take ownership"); + if (port->get_owner().is_free()) { + generate_execute_err(result, "please acquire the port before modifying port state"); + } + + if (!port->get_owner().verify(handler)) { + generate_execute_err(result, "port is not owned by you or your current executing session"); } } @@ -92,6 +96,8 @@ TrexRpcCommand::type_to_str(field_type_e type) { return "byte"; case FIELD_TYPE_UINT16: return "uint16"; + case FIELD_TYPE_UINT32: + return "uint32"; case FIELD_TYPE_BOOL: return "bool"; case FIELD_TYPE_INT: @@ -161,6 +167,18 @@ TrexRpcCommand::parse_uint16(const Json::Value &parent, int index, Json::Value & return parent[index].asUInt(); } +uint32_t +TrexRpcCommand::parse_uint32(const Json::Value &parent, const std::string &name, Json::Value &result) { + check_field_type(parent, name, FIELD_TYPE_UINT32, result); + return parent[name].asUInt(); +} + +uint32_t +TrexRpcCommand::parse_uint32(const Json::Value &parent, int index, Json::Value &result) { + check_field_type(parent, index, FIELD_TYPE_UINT32, result); + return parent[index].asUInt(); +} + int TrexRpcCommand::parse_int(const Json::Value &parent, const std::string &name, Json::Value &result) { check_field_type(parent, name, FIELD_TYPE_INT, result); @@ -250,6 +268,12 @@ TrexRpcCommand::check_field_type_common(const Json::Value &field, const std::str } break; + case FIELD_TYPE_UINT32: + if ( (!field.isUInt()) || (field.asUInt() > 0xFFFFFFFF)) { + rc = false; + } + break; + case FIELD_TYPE_BOOL: if (!field.isBool()) { rc = false; diff --git a/src/rpc-server/trex_rpc_cmd_api.h b/src/rpc-server/trex_rpc_cmd_api.h index e93fb775..f81981d4 100644 --- a/src/rpc-server/trex_rpc_cmd_api.h +++ b/src/rpc-server/trex_rpc_cmd_api.h @@ -99,6 +99,7 @@ protected: enum field_type_e { FIELD_TYPE_BYTE, FIELD_TYPE_UINT16, + FIELD_TYPE_UINT32, FIELD_TYPE_INT, FIELD_TYPE_DOUBLE, FIELD_TYPE_BOOL, @@ -136,6 +137,7 @@ protected: */ uint8_t parse_byte(const Json::Value &parent, const std::string &name, Json::Value &result); uint16_t parse_uint16(const Json::Value &parent, const std::string &name, Json::Value &result); + uint32_t parse_uint32(const Json::Value &parent, const std::string &name, Json::Value &result); int parse_int(const Json::Value &parent, const std::string &name, Json::Value &result); double parse_double(const Json::Value &parent, const std::string &name, Json::Value &result); bool parse_bool(const Json::Value &parent, const std::string &name, Json::Value &result); @@ -145,6 +147,7 @@ protected: uint8_t parse_byte(const Json::Value &parent, int index, Json::Value &result); uint16_t parse_uint16(const Json::Value &parent, int index, Json::Value &result); + uint32_t parse_uint32(const Json::Value &parent, int index, Json::Value &result); int parse_int(const Json::Value &parent, int index, Json::Value &result); double parse_double(const Json::Value &parent, int index, Json::Value &result); bool parse_bool(const Json::Value &parent, int index, Json::Value &result); diff --git a/src/rpc-server/trex_rpc_cmds_table.cpp b/src/rpc-server/trex_rpc_cmds_table.cpp index a65bbccf..82c723b7 100644 --- a/src/rpc-server/trex_rpc_cmds_table.cpp +++ b/src/rpc-server/trex_rpc_cmds_table.cpp @@ -41,8 +41,8 @@ TrexRpcCommandsTable::TrexRpcCommandsTable() { register_command(new TrexRpcCmdAcquire()); register_command(new TrexRpcCmdRelease()); register_command(new TrexRpcCmdGetPortStats()); - - register_command(new TrexRpcCmdSyncUser()); + register_command(new TrexRpcCmdGetPortStatus()); + /* stream commands */ register_command(new TrexRpcCmdAddStream()); @@ -57,8 +57,11 @@ TrexRpcCommandsTable::TrexRpcCommandsTable() { register_command(new TrexRpcCmdPauseTraffic()); register_command(new TrexRpcCmdResumeTraffic()); register_command(new TrexRpcCmdUpdateTraffic()); + + register_command(new TrexRpcCmdValidate()); } + TrexRpcCommandsTable::~TrexRpcCommandsTable() { for (auto cmd : m_rpc_cmd_table) { delete cmd.second; diff --git a/src/rpc-server/trex_rpc_req_resp_server.cpp b/src/rpc-server/trex_rpc_req_resp_server.cpp index 9147f75d..eb7825ac 100644 --- a/src/rpc-server/trex_rpc_req_resp_server.cpp +++ b/src/rpc-server/trex_rpc_req_resp_server.cpp @@ -26,6 +26,7 @@ limitations under the License. #include <unistd.h> #include <sstream> #include <iostream> +#include <assert.h> #include <zmq.h> #include <json/json.h> @@ -70,28 +71,14 @@ void TrexRpcServerReqRes::_rpc_thread_cb() { /* server main loop */ while (m_is_running) { - int msg_size = zmq_recv (m_socket, m_msg_buffer, sizeof(m_msg_buffer), 0); - - /* msg_size of -1 is an error - decode it */ - if (msg_size == -1) { - /* normal shutdown and zmq_term was called */ - if (errno == ETERM) { - break; - } else { - throw TrexRpcException("Unhandled error of zmq_recv"); - } - } + std::string request; - if (msg_size >= sizeof(m_msg_buffer)) { - std::stringstream ss; - ss << "RPC request of '" << msg_size << "' exceeds maximum message size which is '" << sizeof(m_msg_buffer) << "'"; - handle_server_error(ss.str()); - continue; + /* get the next request */ + bool rc = fetch_one_request(request); + if (!rc) { + break; } - /* transform it to a string */ - std::string request((const char *)m_msg_buffer, msg_size); - verbose_json("Server Received: ", TrexJsonRpcV2Parser::pretty_json_str(request)); handle_request(request); @@ -101,6 +88,35 @@ void TrexRpcServerReqRes::_rpc_thread_cb() { zmq_close(m_socket); } +bool +TrexRpcServerReqRes::fetch_one_request(std::string &msg) { + + zmq_msg_t zmq_msg; + int rc; + + rc = zmq_msg_init(&zmq_msg); + assert(rc == 0); + + rc = zmq_msg_recv (&zmq_msg, m_socket, 0); + + if (rc == -1) { + zmq_msg_close(&zmq_msg); + /* normal shutdown and zmq_term was called */ + if (errno == ETERM) { + return false; + } else { + throw TrexRpcException("Unhandled error of zmq_recv"); + } + } + + const char *data = (const char *)zmq_msg_data(&zmq_msg); + size_t len = zmq_msg_size(&zmq_msg); + msg.append(data, len); + + zmq_msg_close(&zmq_msg); + return true; +} + /** * stops the ZMQ based RPC server * diff --git a/src/rpc-server/trex_rpc_req_resp_server.h b/src/rpc-server/trex_rpc_req_resp_server.h index bc38c0ef..2876206c 100644 --- a/src/rpc-server/trex_rpc_req_resp_server.h +++ b/src/rpc-server/trex_rpc_req_resp_server.h @@ -39,14 +39,12 @@ protected: void _stop_rpc_thread(); private: - + bool fetch_one_request(std::string &msg); void handle_request(const std::string &request); void handle_server_error(const std::string &specific_err); - static const int RPC_MAX_MSG_SIZE = (200 * 1024); void *m_context; void *m_socket; - uint8_t m_msg_buffer[RPC_MAX_MSG_SIZE]; }; diff --git a/src/stateless/cp/trex_stateless_port.cpp b/src/stateless/cp/trex_stateless_port.cpp index 95bdca0b..9770c735 100644 --- a/src/stateless/cp/trex_stateless_port.cpp +++ b/src/stateless/cp/trex_stateless_port.cpp @@ -57,7 +57,6 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api m_port_id = port_id; m_port_state = PORT_STATE_IDLE; - clear_owner(); /* get the platform specific data */ api->get_interface_info(port_id, m_driver_name, m_speed); @@ -86,17 +85,35 @@ TrexStatelessPort::TrexStatelessPort(uint8_t port_id, const TrexPlatformApi *api */ void TrexStatelessPort::acquire(const std::string &user, bool force) { - if ( (!is_free_to_aquire()) && (get_owner() != user) && (!force)) { - throw TrexRpcException("port is already taken by '" + get_owner() + "'"); + + /* if port is free - just take it */ + if (get_owner().is_free()) { + get_owner().own(user); + return; + } + + if (force) { + get_owner().own(user); + + /* inform the other client of the steal... */ + Json::Value data; + data["port_id"] = m_port_id; + get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_FORCE_ACQUIRED, data); + + } else { + /* not same user or session id and not force - report error */ + if (get_owner().get_name() == user) { + throw TrexRpcException("port is already owned by another session of '" + user + "'"); + } else { + throw TrexRpcException("port is already taken by '" + get_owner().get_name() + "'"); + } } - set_owner(user); } void TrexStatelessPort::release(void) { - verify_state( ~(PORT_STATE_TX | PORT_STATE_PAUSE) ); - clear_owner(); + get_owner().release(); } /** @@ -115,7 +132,7 @@ TrexStatelessPort::start_traffic(const TrexPortMultiplier &mul, double duration) /* on start - we can only provide absolute values */ assert(mul.m_op == TrexPortMultiplier::OP_ABS); - double per_core_mul = calculate_effective_mul(mul); + double factor = calculate_effective_factor(mul); /* fetch all the streams from the table */ vector<TrexStream *> streams; @@ -123,12 +140,18 @@ TrexStatelessPort::start_traffic(const TrexPortMultiplier &mul, double duration) /* compiler it */ - TrexStreamsCompiler compiler; - TrexStreamsCompiledObj *compiled_obj = new TrexStreamsCompiledObj(m_port_id, per_core_mul); + std::vector<TrexStreamsCompiledObj *> compiled_objs; + std::string fail_msg; - bool rc = compiler.compile(streams, *compiled_obj); + TrexStreamsCompiler compiler; + bool rc = compiler.compile(m_port_id, + streams, + compiled_objs, + get_dp_core_count(), + factor, + &fail_msg); if (!rc) { - throw TrexRpcException("Failed to compile streams"); + throw TrexRpcException(fail_msg); } /* generate a message to all the relevant DP cores to start transmitting */ @@ -137,21 +160,29 @@ TrexStatelessPort::start_traffic(const TrexPortMultiplier &mul, double duration) /* mark that DP event of stoppped is possible */ m_dp_events.wait_for_event(TrexDpPortEvent::EVENT_STOP, event_id); - TrexStatelessCpToDpMsgBase *start_msg = new TrexStatelessDpStart(m_port_id, event_id, compiled_obj, duration); - - m_last_all_streams_continues = compiled_obj->get_all_streams_continues(); - m_last_duration =duration; + /* update object status */ + m_factor = factor; + m_last_all_streams_continues = compiled_objs[0]->get_all_streams_continues(); + m_last_duration = duration; change_state(PORT_STATE_TX); - send_message_to_dp(start_msg); + + /* update the DP - messages will be freed by the DP */ + int index = 0; + for (auto core_id : m_cores_id_list) { + + TrexStatelessCpToDpMsgBase *start_msg = new TrexStatelessDpStart(m_port_id, event_id, compiled_objs[index], duration); + send_message_to_dp(core_id, start_msg); + + index++; + } + /* update subscribers */ Json::Value data; data["port_id"] = m_port_id; get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_STARTED, data); - - /* save the per core multiplier for update messages */ - m_current_per_core_m = per_core_mul; + } @@ -179,7 +210,7 @@ TrexStatelessPort::stop_traffic(void) { /* generate a message to all the relevant DP cores to start transmitting */ TrexStatelessCpToDpMsgBase *stop_msg = new TrexStatelessDpStop(m_port_id); - send_message_to_dp(stop_msg); + send_message_to_all_dp(stop_msg); change_state(PORT_STATE_STREAMS); @@ -202,11 +233,15 @@ TrexStatelessPort::pause_traffic(void) { throw TrexRpcException(" pause is supported when duration is not enable is start command "); } - TrexStatelessCpToDpMsgBase *stop_msg = new TrexStatelessDpPause(m_port_id); + TrexStatelessCpToDpMsgBase *pause_msg = new TrexStatelessDpPause(m_port_id); - send_message_to_dp(stop_msg); + send_message_to_all_dp(pause_msg); change_state(PORT_STATE_PAUSE); + + Json::Value data; + data["port_id"] = m_port_id; + get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_PAUSED, data); } void @@ -215,11 +250,16 @@ TrexStatelessPort::resume_traffic(void) { verify_state(PORT_STATE_PAUSE); /* generate a message to all the relevant DP cores to start transmitting */ - TrexStatelessCpToDpMsgBase *stop_msg = new TrexStatelessDpResume(m_port_id); + TrexStatelessCpToDpMsgBase *resume_msg = new TrexStatelessDpResume(m_port_id); - send_message_to_dp(stop_msg); + send_message_to_all_dp(resume_msg); change_state(PORT_STATE_TX); + + + Json::Value data; + data["port_id"] = m_port_id; + get_stateless_obj()->get_publisher()->publish_event(TrexPublisher::EVENT_PORT_RESUMED, data); } void @@ -230,19 +270,19 @@ TrexStatelessPort::update_traffic(const TrexPortMultiplier &mul) { verify_state(PORT_STATE_TX | PORT_STATE_PAUSE); /* generate a message to all the relevant DP cores to start transmitting */ - double new_per_core_m = calculate_effective_mul(mul); + double new_factor = calculate_effective_factor(mul); switch (mul.m_op) { case TrexPortMultiplier::OP_ABS: - factor = new_per_core_m / m_current_per_core_m; + factor = new_factor / m_factor; break; case TrexPortMultiplier::OP_ADD: - factor = (m_current_per_core_m + new_per_core_m) / m_current_per_core_m; + factor = (m_factor + new_factor) / m_factor; break; case TrexPortMultiplier::OP_SUB: - factor = (m_current_per_core_m - new_per_core_m) / m_current_per_core_m; + factor = (m_factor - new_factor) / m_factor; if (factor <= 0) { throw TrexRpcException("Update request will lower traffic to less than zero"); } @@ -255,9 +295,9 @@ TrexStatelessPort::update_traffic(const TrexPortMultiplier &mul) { TrexStatelessCpToDpMsgBase *update_msg = new TrexStatelessDpUpdate(m_port_id, factor); - send_message_to_dp(update_msg); + send_message_to_all_dp(update_msg); - m_current_per_core_m *= factor; + m_factor *= factor; } @@ -310,27 +350,6 @@ TrexStatelessPort::change_state(port_state_e new_state) { m_port_state = new_state; } -/** - * generate a random connection handler - * - */ -std::string -TrexStatelessPort::generate_handler() { - std::stringstream ss; - - static const char alphanum[] = - "0123456789" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "abcdefghijklmnopqrstuvwxyz"; - - /* generate 8 bytes of random handler */ - for (int i = 0; i < 8; ++i) { - ss << alphanum[rand() % (sizeof(alphanum) - 1)]; - } - - return (ss.str()); -} - void TrexStatelessPort::encode_stats(Json::Value &port) { @@ -356,15 +375,22 @@ TrexStatelessPort::encode_stats(Json::Value &port) { } void -TrexStatelessPort::send_message_to_dp(TrexStatelessCpToDpMsgBase *msg) { +TrexStatelessPort::send_message_to_all_dp(TrexStatelessCpToDpMsgBase *msg) { for (auto core_id : m_cores_id_list) { - - /* send the message to the core */ - CNodeRing *ring = CMsgIns::Ins()->getCpDp()->getRingCpToDp(core_id); - ring->Enqueue((CGenNode *)msg->clone()); + send_message_to_dp(core_id, msg->clone()); } + /* original was not sent - delete it */ + delete msg; +} + +void +TrexStatelessPort::send_message_to_dp(uint8_t core_id, TrexStatelessCpToDpMsgBase *msg) { + + /* send the message to the core */ + CNodeRing *ring = CMsgIns::Ins()->getCpDp()->getRingCpToDp(core_id); + ring->Enqueue((CGenNode *)msg); } /** @@ -393,7 +419,7 @@ TrexStatelessPort::on_dp_event_occured(TrexDpPortEvent::event_e event_type) { } uint64_t -TrexStatelessPort::get_port_speed_bps() { +TrexStatelessPort::get_port_speed_bps() const { switch (m_speed) { case TrexPlatformApi::SPEED_1G: return (1LLU * 1000 * 1000 * 1000); @@ -410,11 +436,11 @@ TrexStatelessPort::get_port_speed_bps() { } double -TrexStatelessPort::calculate_effective_mul(const TrexPortMultiplier &mul) { +TrexStatelessPort::calculate_effective_factor(const TrexPortMultiplier &mul) { - /* for a simple factor request - calculate the multiplier per core */ + /* for a simple factor request */ if (mul.m_type == TrexPortMultiplier::MUL_FACTOR) { - return (mul.m_value / m_cores_id_list.size()); + return (mul.m_value); } /* we now need the graph - generate it if we don't have it (happens once) */ @@ -424,19 +450,19 @@ TrexStatelessPort::calculate_effective_mul(const TrexPortMultiplier &mul) { switch (mul.m_type) { case TrexPortMultiplier::MUL_BPS: - return ( (mul.m_value / m_graph_obj->get_max_bps()) / m_cores_id_list.size()); + return (mul.m_value / m_graph_obj->get_max_bps()); case TrexPortMultiplier::MUL_PPS: - return ( (mul.m_value / m_graph_obj->get_max_pps()) / m_cores_id_list.size()); + return (mul.m_value / m_graph_obj->get_max_pps()); case TrexPortMultiplier::MUL_PERCENTAGE: /* if abs percentage is from the line speed - otherwise its from the current speed */ if (mul.m_op == TrexPortMultiplier::OP_ABS) { double required = (mul.m_value / 100.0) * get_port_speed_bps(); - return ( (required / m_graph_obj->get_max_bps()) / m_cores_id_list.size()); + return (required / m_graph_obj->get_max_bps()); } else { - return (m_current_per_core_m * (mul.m_value / 100.0)); + return (m_factor * (mul.m_value / 100.0)); } default: @@ -518,3 +544,74 @@ TrexPortMultiplier(const std::string &type_str, const std::string &op_str, doubl } +const TrexStreamsGraphObj * +TrexStatelessPort::validate(void) { + + /* first compile the graph */ + + vector<TrexStream *> streams; + get_object_list(streams); + + if (streams.size() == 0) { + throw TrexException("no streams attached to port"); + } + + TrexStreamsCompiler compiler; + std::vector<TrexStreamsCompiledObj *> compiled_objs; + + std::string fail_msg; + bool rc = compiler.compile(m_port_id, + streams, + compiled_objs, + get_dp_core_count(), + 1.0, + &fail_msg); + if (!rc) { + throw TrexException(fail_msg); + } + + for (auto obj : compiled_objs) { + delete obj; + } + + /* now create a stream graph */ + if (!m_graph_obj) { + generate_streams_graph(); + } + + return m_graph_obj; +} + + +/************* Trex Port Owner **************/ + +TrexPortOwner::TrexPortOwner() { + m_is_free = true; + + /* for handlers random generation */ + srand(time(NULL)); +} + +/** + * generate a random connection handler + * + */ +std::string +TrexPortOwner::generate_handler() { + std::stringstream ss; + + static const char alphanum[] = + "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz"; + + /* generate 8 bytes of random handler */ + for (int i = 0; i < 8; ++i) { + ss << alphanum[rand() % (sizeof(alphanum) - 1)]; + } + + return (ss.str()); +} + +const std::string TrexPortOwner::g_unowned_name = "<FREE>"; +const std::string TrexPortOwner::g_unowned_handler = ""; diff --git a/src/stateless/cp/trex_stateless_port.h b/src/stateless/cp/trex_stateless_port.h index 45eb16e8..4988b46a 100644 --- a/src/stateless/cp/trex_stateless_port.h +++ b/src/stateless/cp/trex_stateless_port.h @@ -29,6 +29,77 @@ class TrexStatelessCpToDpMsgBase; class TrexStreamsGraphObj; class TrexPortMultiplier; +/** + * TRex port owner can perform + * write commands + * while port is owned - others can + * do read only commands + * + */ +class TrexPortOwner { +public: + + TrexPortOwner(); + + /** + * is port free to acquire + */ + bool is_free() { + return m_is_free; + } + + void release() { + m_is_free = true; + m_owner_name = ""; + m_handler = ""; + } + + bool is_owned_by(const std::string &user) { + return ( !m_is_free && (m_owner_name == user) ); + } + + void own(const std::string &owner_name) { + + /* save user data */ + m_owner_name = owner_name; + + /* internal data */ + m_handler = generate_handler(); + m_is_free = false; + } + + bool verify(const std::string &handler) { + return ( (!m_is_free) && (m_handler == handler) ); + } + + const std::string &get_name() { + return (!m_is_free ? m_owner_name : g_unowned_name); + } + + const std::string &get_handler() { + return (!m_is_free ? m_handler : g_unowned_handler); + } + + +private: + std::string generate_handler(); + + /* is this port owned by someone ? */ + bool m_is_free; + + /* user provided info */ + std::string m_owner_name; + + /* handler genereated internally */ + std::string m_handler; + + + /* just references defaults... */ + static const std::string g_unowned_name; + static const std::string g_unowned_handler; +}; + + /** * describes a stateless port * @@ -76,10 +147,20 @@ public: void release(void); /** + * validate the state of the port before start + * it will return a stream graph + * containing information about the streams + * configured on this port + * + * on error it throws TrexException + */ + const TrexStreamsGraphObj *validate(void); + + /** * start traffic * throws TrexException in case of an error */ - void start_traffic(const TrexPortMultiplier &mul, double duration = -1); + void start_traffic(const TrexPortMultiplier &mul, double duration); /** * stop traffic @@ -130,29 +211,6 @@ public: void get_properties(std::string &driver, TrexPlatformApi::driver_speed_e &speed); - /** - * query for ownership - * - */ - const std::string &get_owner() { - return m_owner; - } - - /** - * owner handler - * for the connection - * - */ - const std::string &get_owner_handler() { - return m_owner_handler; - } - - - bool verify_owner_handler(const std::string &handler) { - - return ( (m_owner != "none") && (m_owner_handler == handler) ); - - } /** * encode stats as JSON @@ -172,6 +230,7 @@ public: verify_state(PORT_STATE_IDLE | PORT_STATE_STREAMS); m_stream_table.add_stream(stream); + delete_streams_graph(); change_state(PORT_STATE_STREAMS); } @@ -180,6 +239,7 @@ public: verify_state(PORT_STATE_STREAMS); m_stream_table.remove_stream(stream); + delete_streams_graph(); if (m_stream_table.size() == 0) { change_state(PORT_STATE_IDLE); @@ -190,6 +250,7 @@ public: verify_state(PORT_STATE_IDLE | PORT_STATE_STREAMS); m_stream_table.remove_and_delete_all_streams(); + delete_streams_graph(); change_state(PORT_STATE_IDLE); } @@ -211,30 +272,34 @@ public: } -private: - - - /** - * take ownership of the server array - * this is static - * ownership is total - * - */ - void set_owner(const std::string &owner) { - m_owner = owner; - m_owner_handler = generate_handler(); + * returns the number of DP cores linked to this port + * + */ + uint8_t get_dp_core_count() { + return m_cores_id_list.size(); } - void clear_owner() { - m_owner = "none"; - m_owner_handler = ""; + /** + * returns the traffic multiplier currently being used by the DP + * + */ + double get_multiplier() { + return (m_factor); } - bool is_free_to_aquire() { - return (m_owner == "none"); + /** + * get port speed in bits per second + * + */ + uint64_t get_port_speed_bps() const; + + TrexPortOwner & get_owner() { + return m_owner; } +private: + const std::vector<int> get_core_id_list () { return m_cores_id_list; @@ -246,7 +311,17 @@ private: std::string generate_handler(); - void send_message_to_dp(TrexStatelessCpToDpMsgBase *msg); + /** + * send message to all cores using duplicate + * + */ + void send_message_to_all_dp(TrexStatelessCpToDpMsgBase *msg); + + /** + * send message to specific DP core + * + */ + void send_message_to_dp(uint8_t core_id, TrexStatelessCpToDpMsgBase *msg); /** * triggered when event occurs @@ -259,13 +334,9 @@ private: * calculate effective M per core * */ - double calculate_effective_mul(const TrexPortMultiplier &mul); + double calculate_effective_factor(const TrexPortMultiplier &mul); - /** - * get port speed in bits per second - * - */ - uint64_t get_port_speed_bps(); + /** * generates a graph of streams graph @@ -284,25 +355,25 @@ private: TrexStreamTable m_stream_table; uint8_t m_port_id; port_state_e m_port_state; - std::string m_owner; - std::string m_owner_handler; std::string m_driver_name; TrexPlatformApi::driver_speed_e m_speed; /* holds the DP cores associated with this port */ - std::vector<int> m_cores_id_list; + std::vector<int> m_cores_id_list; bool m_last_all_streams_continues; double m_last_duration; - double m_current_per_core_m; + double m_factor; TrexDpPortEvents m_dp_events; /* holds a graph of streams rate*/ const TrexStreamsGraphObj *m_graph_obj; -}; + /* owner information */ + TrexPortOwner m_owner; +}; /** diff --git a/src/stateless/cp/trex_stream.h b/src/stateless/cp/trex_stream.h index c42d0985..529dcbe4 100644 --- a/src/stateless/cp/trex_stream.h +++ b/src/stateless/cp/trex_stream.h @@ -129,8 +129,9 @@ public: } /* create new stream */ - TrexStream * clone_as_dp(){ - TrexStream * dp=new TrexStream(m_type,m_port_id,m_stream_id); + TrexStream * clone_as_dp() const { + + TrexStream *dp = new TrexStream(m_type,m_port_id,m_stream_id); dp->m_has_vm = m_has_vm; diff --git a/src/stateless/cp/trex_streams_compiler.cpp b/src/stateless/cp/trex_streams_compiler.cpp index c8aa1e40..478e09f8 100644 --- a/src/stateless/cp/trex_streams_compiler.cpp +++ b/src/stateless/cp/trex_streams_compiler.cpp @@ -142,8 +142,9 @@ private: /************************************** * stream compiled object *************************************/ -TrexStreamsCompiledObj::TrexStreamsCompiledObj(uint8_t port_id, double mul) : m_port_id(port_id), m_mul(mul) { - m_all_continues=false; +TrexStreamsCompiledObj::TrexStreamsCompiledObj(uint8_t port_id) { + m_port_id = port_id; + m_all_continues = false; } TrexStreamsCompiledObj::~TrexStreamsCompiledObj() { @@ -155,53 +156,40 @@ TrexStreamsCompiledObj::~TrexStreamsCompiledObj() { void -TrexStreamsCompiledObj::add_compiled_stream(TrexStream * stream){ +TrexStreamsCompiledObj::add_compiled_stream(TrexStream *stream){ obj_st obj; - obj.m_stream = stream->clone_as_dp(); + obj.m_stream = stream; m_objs.push_back(obj); } -void -TrexStreamsCompiledObj::add_compiled_stream(TrexStream * stream, - uint32_t my_dp_id, int next_dp_id) { - obj_st obj; - - obj.m_stream = stream->clone_as_dp(); - /* compress the id's*/ - obj.m_stream->fix_dp_stream_id(my_dp_id,next_dp_id); - - m_objs.push_back(obj); -} - -void TrexStreamsCompiledObj::Dump(FILE *fd){ - for (auto obj : m_objs) { - obj.m_stream->Dump(fd); - } -} - - TrexStreamsCompiledObj * TrexStreamsCompiledObj::clone() { - /* use multiplier of 1 to avoid double mult */ - TrexStreamsCompiledObj *new_compiled_obj = new TrexStreamsCompiledObj(m_port_id, 1); + TrexStreamsCompiledObj *new_compiled_obj = new TrexStreamsCompiledObj(m_port_id); /** * clone each element */ for (auto obj : m_objs) { - new_compiled_obj->add_compiled_stream(obj.m_stream); + TrexStream *new_stream = obj.m_stream->clone_as_dp(); + new_compiled_obj->add_compiled_stream(new_stream); } - new_compiled_obj->m_mul = m_mul; - return new_compiled_obj; + } +void TrexStreamsCompiledObj::Dump(FILE *fd){ + for (auto obj : m_objs) { + obj.m_stream->Dump(fd); + } +} + + void TrexStreamsCompiler::add_warning(const std::string &warning) { m_warnings.push_back("*** warning: " + warning); @@ -219,7 +207,7 @@ TrexStreamsCompiler::check_stream(const TrexStream *stream) { /* cont. stream can point only on itself */ if (stream->get_type() == TrexStream::stCONTINUOUS) { if (stream->m_next_stream_id != -1) { - ss << "continous stream '" << stream->m_stream_id << "' cannot point on another stream"; + ss << "continous stream '" << stream->m_stream_id << "' cannot point to another stream"; err(ss.str()); } } @@ -381,12 +369,14 @@ TrexStreamsCompiler::pre_compile_check(const std::vector<TrexStream *> &streams, * stream compiler *************************************/ bool -TrexStreamsCompiler::compile(const std::vector<TrexStream *> &streams, - TrexStreamsCompiledObj &obj, - std::string *fail_msg) { +TrexStreamsCompiler::compile(uint8_t port_id, + const std::vector<TrexStream *> &streams, + std::vector<TrexStreamsCompiledObj *> &objs, + uint8_t dp_core_count, + double factor, + std::string *fail_msg) { #if 0 - fprintf(stdout,"------------pre compile \n"); for (auto stream : streams) { stream->Dump(stdout); } @@ -398,7 +388,7 @@ TrexStreamsCompiler::compile(const std::vector<TrexStream *> &streams, /* compile checks */ try { - pre_compile_check(streams,nodes); + pre_compile_check(streams, nodes); } catch (const TrexException &ex) { if (fail_msg) { *fail_msg = ex.what(); @@ -408,38 +398,94 @@ TrexStreamsCompiler::compile(const std::vector<TrexStream *> &streams, return false; } + /* check if all are cont. streams */ + bool all_continues = true; + for (const auto stream : streams) { + if (stream->get_type() != TrexStream::stCONTINUOUS) { + all_continues = false; + break; + } + } - bool all_continues=true; - /* for now we do something trivial, */ + /* allocate objects for all DP cores */ + for (uint8_t i = 0; i < dp_core_count; i++) { + TrexStreamsCompiledObj *obj = new TrexStreamsCompiledObj(port_id); + obj->m_all_continues = all_continues; + objs.push_back(obj); + } + + /* compile all the streams */ for (auto stream : streams) { /* skip non-enabled streams */ if (!stream->m_enabled) { continue; } - if (stream->get_type() != TrexStream::stCONTINUOUS ) { - all_continues=false; - } - - int new_id= nodes.get(stream->m_stream_id)->m_compressed_stream_id; - assert(new_id>=0); - uint32_t my_stream_id = (uint32_t)new_id; - int my_next_stream_id=-1; - if (stream->m_next_stream_id>=0) { - my_next_stream_id=nodes.get(stream->m_next_stream_id)->m_compressed_stream_id; - } - - /* add it */ - obj.add_compiled_stream(stream, - my_stream_id, - my_next_stream_id - ); + + /* compile a single stream to all cores */ + compile_stream(stream, factor, dp_core_count, objs, nodes); } - obj.m_all_continues =all_continues; + return true; } +/** + * compiles a single stream to DP objects + * + * @author imarom (03-Dec-15) + * + */ +void +TrexStreamsCompiler::compile_stream(const TrexStream *stream, + double factor, + uint8_t dp_core_count, + std::vector<TrexStreamsCompiledObj *> &objs, + GraphNodeMap &nodes) { + + + /* fix the stream ids */ + int new_id = nodes.get(stream->m_stream_id)->m_compressed_stream_id; + assert(new_id >= 0); + + int new_next_id = -1; + if (stream->m_next_stream_id >= 0) { + new_next_id = nodes.get(stream->m_next_stream_id)->m_compressed_stream_id; + } + + /* calculate rate */ + double per_core_rate = (stream->m_pps * (factor / dp_core_count)); + int per_core_burst_total_pkts = (stream->m_burst_total_pkts / dp_core_count); + + std::vector<TrexStream *> per_core_streams(dp_core_count); + + /* for each core - creates its own version of the stream */ + for (uint8_t i = 0; i < dp_core_count; i++) { + TrexStream *dp_stream = stream->clone_as_dp(); + + /* fix stream ID */ + dp_stream->fix_dp_stream_id(new_id, new_next_id); + + + /* adjust rate and packets count */ + dp_stream->m_pps = per_core_rate; + dp_stream->m_burst_total_pkts = per_core_burst_total_pkts; + + per_core_streams[i] = dp_stream; + } + + /* take care of remainder from a burst */ + int burst_remainder = stream->m_burst_total_pkts - (per_core_burst_total_pkts * dp_core_count); + per_core_streams[0]->m_burst_total_pkts += burst_remainder; + + /* attach the compiled stream of every core to its object */ + for (uint8_t i = 0; i < dp_core_count; i++) { + objs[i]->add_compiled_stream(per_core_streams[i]); + } + + +} + /************************************** * streams graph *************************************/ @@ -490,6 +536,9 @@ TrexStreamsGraph::add_rate_events_for_stream_cont(double &offset_usec, const Tre /* no more events after this stream */ offset_usec = -1; + + /* also mark we have an inifite time */ + m_graph_obj->m_expected_duration = -1; } /** @@ -602,6 +651,7 @@ TrexStreamsGraph::generate_graph_for_one_root(uint32_t root_stream_id) { /* loop detection */ auto search = loop_hash.find(stream->m_next_stream_id); if (search != loop_hash.end()) { + m_graph_obj->on_loop_detection(); break; } @@ -674,6 +724,11 @@ TrexStreamsGraphObj::find_max_rate() { max_rate_bps = std::max(max_rate_bps, current_rate_bps); } + /* if not mark as inifite - get the last event time */ + if (m_expected_duration != -1) { + m_expected_duration = m_rate_events.back().time; + } + m_max_pps = max_rate_pps; m_max_bps = max_rate_bps; } diff --git a/src/stateless/cp/trex_streams_compiler.h b/src/stateless/cp/trex_streams_compiler.h index a4c12f8d..7fe2dbf2 100644 --- a/src/stateless/cp/trex_streams_compiler.h +++ b/src/stateless/cp/trex_streams_compiler.h @@ -38,9 +38,10 @@ class GraphNodeMap; */ class TrexStreamsCompiledObj { friend class TrexStreamsCompiler; + public: - TrexStreamsCompiledObj(uint8_t port_id, double m_mul); + TrexStreamsCompiledObj(uint8_t port_id); ~TrexStreamsCompiledObj(); struct obj_st { @@ -56,32 +57,22 @@ public: return (m_port_id); } - /** - * clone the compiled object - * - */ - TrexStreamsCompiledObj * clone(); - - double get_multiplier(){ - return (m_mul); - } - bool get_all_streams_continues(){ return (m_all_continues); } void Dump(FILE *fd); + TrexStreamsCompiledObj* clone(); + private: - void add_compiled_stream(TrexStream * stream, - uint32_t my_dp_id, int next_dp_id); - void add_compiled_stream(TrexStream * stream); + void add_compiled_stream(TrexStream *stream); + std::vector<obj_st> m_objs; bool m_all_continues; uint8_t m_port_id; - double m_mul; }; class TrexStreamsCompiler { @@ -93,7 +84,13 @@ public: * @author imarom (28-Oct-15) * */ - bool compile(const std::vector<TrexStream *> &streams, TrexStreamsCompiledObj &obj, std::string *fail_msg = NULL); + bool compile(uint8_t port_id, + const std::vector<TrexStream *> &streams, + std::vector<TrexStreamsCompiledObj *> &objs, + uint8_t dp_core_count = 1, + double factor = 1.0, + std::string *fail_msg = NULL); + /** * @@ -115,8 +112,13 @@ private: void add_warning(const std::string &warning); void err(const std::string &err); + void compile_stream(const TrexStream *stream, + double factor, + uint8_t dp_core_count, + std::vector<TrexStreamsCompiledObj *> &objs, + GraphNodeMap &nodes); + std::vector<std::string> m_warnings; - }; class TrexStreamsGraph; @@ -131,6 +133,12 @@ class TrexStreamsGraphObj { public: + TrexStreamsGraphObj() { + m_max_pps = 0; + m_max_bps = 0; + m_expected_duration = 0; + } + /** * rate event is defined by those: * time - the time of the event on the timeline @@ -153,12 +161,21 @@ public: return m_max_bps; } + int get_duration() const { + return m_expected_duration; + } + const std::list<rate_event_st> & get_events() const { return m_rate_events; } + private: + void on_loop_detection() { + m_expected_duration = -1; + } + void add_rate_event(const rate_event_st &ev) { m_rate_events.push_back(ev); } @@ -166,8 +183,9 @@ private: void generate(); void find_max_rate(); - double m_max_pps; - double m_max_bps; + double m_max_pps; + double m_max_bps; + int m_expected_duration; /* list of rate events */ std::list<rate_event_st> m_rate_events; diff --git a/src/stateless/dp/trex_stateless_dp_core.cpp b/src/stateless/dp/trex_stateless_dp_core.cpp index 8c0f03c8..142b38bf 100644 --- a/src/stateless/dp/trex_stateless_dp_core.cpp +++ b/src/stateless/dp/trex_stateless_dp_core.cpp @@ -490,7 +490,7 @@ TrexStatelessDpCore::add_stream(TrexStatelessDpPerPort * lp_port, node->m_pause =0; node->m_stream_type = stream->m_type; - node->m_next_time_offset = 1.0 / (stream->get_pps() * comp->get_multiplier()); + node->m_next_time_offset = 1.0 / stream->get_pps(); /* stateless specific fields */ switch ( stream->m_type ) { |