def main():
"""Check server info and quit."""
client = STLClient()
try:
# connect to server
client.connect()
# get server info
print(client.get_server_system_info())
except STLError as ex_error:
print(ex_error, file=sys.stderr)
sys.exit(1)
finally:
client.disconnect()
class TrexTest(BaseTest):
"""
Base test for setting up and tearing down TRex client instance for
linerate tests.
"""
def setUp(self):
super(TrexTest, self).setUp()
trex_server_addr = testutils.test_param_get("trex_server_addr")
self.trex_client = STLClient(server=trex_server_addr)
self.trex_client.connect()
self.trex_client.acquire()
self.trex_client.reset() # Resets configs from all ports
self.trex_client.clear_stats() # Clear status from all ports
# Put all ports to promiscuous mode, otherwise they will drop all
# incoming packets if the destination mac is not the port mac address.
self.trex_client.set_port_attr(self.trex_client.get_all_ports(),
promiscuous=True)
def tearDown(self):
print("Tearing down STLClient...")
self.trex_client.stop()
self.trex_client.release()
self.trex_client.disconnect()
super(TrexTest, self).tearDown()
def main():
parser = argparse.ArgumentParser(
description=
"STL traffic used for test the scalability of the network functions.")
parser.add_argument(
"--ip_src",
type=str,
default="192.168.17.1",
help="Source IP address for all packets in the stream.",
)
parser.add_argument(
"--ip_dst",
type=str,
default="192.168.17.2",
help="Destination IP address for all packets in the stream.",
)
parser.add_argument("--pps",
type=int,
default=1e3,
help="Packet per second.")
parser.add_argument("--duration",
type=int,
default=3,
help="Test duration.")
# Potential lens: 64, 128, 256, 512, 1024
parser.add_argument("--ip_tot_len",
type=int,
default=64,
help="IP total length")
parser.add_argument("--num",
type=int,
default=1,
help="Number of rounds tested")
parser.add_argument(
"--estimate_pps",
action="store_true",
help="Estimate the maximal pps without dropping packets.",
)
args = parser.parse_args()
print(
"Test information:\n PPS: {}, Duration: {}s, IP_TOT_LEN: {}B, Number of rounds: {}"
.format(args.pps, args.duration, args.ip_tot_len, args.num))
test_data = {
"pps": args.pps,
"duration": args.duration,
"ip_tot_len": args.ip_tot_len,
"ip_src": args.ip_src,
"ip_dst": args.ip_dst,
"num": args.num,
}
try:
client = STLClient()
client.connect()
tx_port, rx_port = init_ports(client)
if args.estimate_pps:
run_estimate_pps(test_data, client, rx_port, tx_port)
else:
run_test(test_data, client, rx_port, tx_port, save_data=True)
print("All tests finished! Results are in *.data files")
except STLError as error:
print(error)
finally:
client.disconnect()
class TRex(TrafficGeneratorChassis):
def __init__(self, **kwargs):
super(TRex, self).__init__(**kwargs)
self.hostname = kwargs.pop("hostname", "localhost")
self.__trex_client = STLClient(server=self.hostname)
def _verify_port_action(self, port_name):
if self.is_connected() and self._verify_port_string(port_name) and \
port_name in self.port_data:
return (True)
return (False)
def _verify_port_string(self, port_name):
try:
if int(port_name) < 0:
return False
except ValueError:
return False
return True
def connect(self):
if not self.is_connected():
self.__trex_client.connect()
return self.is_connected()
def disconnect(self):
if self.is_connected:
for port in list(self.port_data.keys()):
self.port_data[port] = self.release_port(port)
self.__trex_client.disconnect()
return True
def is_connected(self):
return self.__trex_client.is_connected()
def reserve_port(self, port_name):
if not self._verify_port_string(port_name):
return False
try:
self.__trex_client.acquire(ports=[int(port_name)], force=True)
except STLError:
return False
try:
self.__trex_client.reset(ports=[int(port_name)])
except STLError:
self.__trex_client.release(ports=[int(port_name)])
return False
tport = _TRexPort(port_name, self.__trex_client)
if tport is None:
return False
return super(TRex, self).reserve_port(port_name, tport)
def release_port(self, port_name):
if not self._verify_port_string(port_name) or \
port_name not in self.port_data:
return False
try:
self.__trex_client.release(ports=[port_name])
except STLError:
pass
return super(TRex, self).release_port(port_name)
#
# FIXME: All the port specific functions should be re factored to use the
# base class so the shared code in _xena and _trex can be removed.
#
def clear_statistics(self, port_name):
if self._verify_port_action(port_name):
self.port_data[port_name].clear_statistics()
def take_tx_statistics_snapshot(self, port_name):
if self._verify_port_action(port_name):
self.port_data[port_name].take_tx_statistics_snapshot()
def take_rx_statistics_snapshot(self, port_name):
if self._verify_port_action(port_name):
self.port_data[port_name].take_rx_statistics_snapshot()
def get_tx_statistics_snapshots(self, port_name):
if self._verify_port_action(port_name):
return self.port_data[port_name].get_tx_statistics_snapshots()
return None
def get_rx_statistics_snapshots(self, port_name):
if self._verify_port_action(port_name):
return self.port_data[port_name].get_rx_statistics_snapshots()
return None
def start_traffic(self, port_name):
if self._verify_port_action(port_name):
return self.port_data[port_name].start_traffic()
return False
def stop_traffic(self, port_name):
if self._verify_port_action(port_name):
return self.port_data[port_name].stop_traffic()
return False
def configure_traffic_stream(self, port_name, traffic_flows, nr_of_flows,
packet_size, **kwargs):
if self._verify_port_action(port_name):
return self.port_data[port_name].configure_traffic_stream(
traffic_flows, nr_of_flows, packet_size, **kwargs)
return False
def next_traffic_stream(self, port_name):
if self._verify_port_action(port_name):
return self.port_data[port_name].next_traffic_stream()
return False
def get_port_limits(self, port_name):
if self._verify_port_action(port_name):
return self.port_data[port_name].get_port_limits()
return dict()
def main() -> int:
# Initialize the argument parser and subparsers
# First we initialize general arguments.
parser = argparse.ArgumentParser(description="Linerate test control plane")
parser.add_argument(
"--server-addr",
type=str,
help="The server address",
default="127.0.0.1",
required=False,
)
parser.add_argument(
"--trex-config",
type=str,
help="The Trex config to be placed on the server.",
required=True,
)
parser.add_argument(
"--keep-running",
action="store_true",
default=False,
help="Keep Trex running after the test.",
)
parser.add_argument(
"--force-restart",
action="store_true",
default=False,
help="Force restart the Trex process " + "if there is one running.",
)
# Second, we initialize subparsers from all test scripts
subparsers = parser.add_subparsers(
dest="test",
help="The test profile, which is the " +
"filename(without .py) in the test directory",
required=True,
)
test_py_list = glob.glob(join(dirname(__file__), "tests", "*.py"))
test_list = [
basename(f)[:-3] for f in test_py_list
if isfile(f) and not f.endswith("__init__.py")
]
for test in test_list:
test_class = get_test_class(test)
if not test_class:
continue
test_parser = subparsers.add_parser(test)
test_class.setup_subparser(test_parser)
# Finally, we get the arguments
args = parser.parse_args()
# Set up the Trex server
if not os.path.exists(args.trex_config):
logging.error("Can not find Trex config file: %s", args.trex_config)
return
if not os.path.isfile(args.trex_config):
logging.error("%s is not a file", args.trex_config)
return 1
trex_config_file_on_server = TREX_FILES_DIR + os.path.basename(
args.trex_config)
trex_daemon_client = CTRexClient(args.server_addr)
trex_started = False
try:
logging.info("Pushing Trex config %s to the server", args.trex_config)
if not trex_daemon_client.push_files(args.trex_config):
logging.error("Unable to push %s to Trex server", args.trex_config)
return 1
if args.force_restart:
logging.info("Killing all Trexes... with meteorite... Boom!")
trex_daemon_client.kill_all_trexes()
# Wait until Trex enter the Idle state
start_time = time.time()
success = False
while time.time() - start_time < DEFAULT_KILL_TIMEOUT:
if trex_daemon_client.is_idle():
success = True
break
time.sleep(1)
if not success:
logging.error("Unable to kill Trex process, please login " +
"to the server and kill it manually.")
return 1
if not trex_daemon_client.is_idle():
logging.info("The Trex server process is running")
logging.warning("A Trex server process is still running, " +
"use --force-restart to kill it if necessary.")
return 1
test_class = get_test_class(args.test)
if not test_class:
logging.error("Unable to get test class for test %s", args.test)
return 1
test_type = test_class.test_type()
logging.info("Starting Trex with %s mode", test_class.test_type())
try:
start_trex_function = getattr(trex_daemon_client,
"start_{}".format(test_type))
except AttributeError:
logging.error("Unkonwon test type %s", test_type)
return 1
# Not checking the return value from this
# call since it always return True
start_trex_function(cfg=trex_config_file_on_server)
trex_started = True
# Start the test
if test_type == "stateless":
trex_client = STLClient(server=args.server_addr)
elif test_type == "astf":
trex_client = ASTFClient(server=args.server_addr)
else:
logging.error("Unknown test type %s", test_type)
return 1
test = test_class(trex_client)
try:
logging.info("Connecting to Trex server...")
trex_client.connect()
logging.info("Acquaring ports...")
trex_client.acquire()
logging.info("Resetting and clearing port...")
trex_client.reset() # Resets configs from all ports
trex_client.clear_stats() # Clear status from all ports
logging.info("Running the test: %s...", test)
test.start(args)
except STLError as e:
logging.error("Got error from Trex server: %s", e)
return 1
finally:
logging.info("Cleaning up Trex client")
trex_client.stop()
trex_client.release()
trex_client.disconnect()
except ConnectionRefusedError:
logging.error(
"Unable to connect to server %s.\n" +
"Did you start the Trex daemon?",
args.server_addr,
)
return 1
except ProtocolError as pe:
logging.error("%s", pe)
return 1
except TRexError as te:
logging.error("TRex error: %s", te.msg)
return 1
except TRexInUseError as tiue:
logging.error("TRex is already taken: %s", tiue.msg)
return 1
except TRexRequestDenied as trd:
logging.error("Request denied: %s", trd.msg)
return 1
finally:
if trex_started and not args.keep_running:
logging.info("Stopping Trex server")
trex_daemon_client.stop_trex()
passed = True
try:
udp_payload = "A" * 50
pkt = STLPktBuilder(
pkt=Ether() / IP(src="192.168.17.1", dst="192.168.17.2") /
UDP(dport=8888, sport=9999, chksum=0) / udp_payload)
st = STLStream(
name="udp_single_burst",
packet=pkt,
# Packet group id
flow_stats=STLFlowLatencyStats(pg_id=PG_ID),
mode=STLTXSingleBurst(total_pkts=TOTAL_PKTS, pps=PPS),
)
clt.connect()
all_ports = clt.get_all_ports()
print("All ports: {}".format(",".join(map(str, all_ports))))
tx_port, rx_port = all_ports
print(f"TX port: {tx_port}, RX port: {rx_port}")
tx_port_attr = clt.get_port_attr(tx_port)
rx_port_attr = clt.get_port_attr(rx_port)
assert tx_port_attr["src_ipv4"] == "192.168.17.1"
assert rx_port_attr["src_ipv4"] == "192.168.18.1"
clt.reset(ports=all_ports)
clt.add_streams([st], ports=[tx_port])
print(f"Inject {TOTAL_PKTS} packets on port {all_ports[0]}")
ret = rx_interation(clt, tx_port, rx_port, TOTAL_PKTS,
pkt.get_pkt_len())
if not ret:
def main():
"""Stop traffic if any is running. Report xstats."""
parser = argparse.ArgumentParser()
parser.add_argument(u"--xstat0",
type=str,
default=u"",
help=u"Reference xstat object if any.")
parser.add_argument(u"--xstat1",
type=str,
default=u"",
help=u"Reference xstat object if any.")
args = parser.parse_args()
client = STLClient()
try:
# connect to server
client.connect()
client.acquire(force=True)
# TODO: Support unidirection.
client.stop(ports=[0, 1])
# Read the stats after the test,
# we need to update values before the last trial started.
if args.xstat0:
snapshot = eval(args.xstat0)
client.ports[0].get_xstats().reference_stats = snapshot
if args.xstat1:
snapshot = eval(args.xstat1)
client.ports[1].get_xstats().reference_stats = snapshot
# Now we can call the official method to get differences.
xstats0 = client.get_xstats(0)
xstats1 = client.get_xstats(1)
# If STLError happens, let the script fail with stack trace.
finally:
client.disconnect()
print(u"##### statistics port 0 #####")
print(json.dumps(xstats0, indent=4, separators=(u",", u": ")))
print(u"##### statistics port 1 #####")
print(json.dumps(xstats1, indent=4, separators=(u",", u": ")))
tx_0, rx_0 = xstats0[u"tx_good_packets"], xstats0[u"rx_good_packets"]
tx_1, rx_1 = xstats1[u"tx_good_packets"], xstats1[u"rx_good_packets"]
lost_a, lost_b = tx_0 - rx_1, tx_1 - rx_0
print(f"\npackets lost from 0 --> 1: {lost_a} pkts")
print(f"packets lost from 1 --> 0: {lost_b} pkts")
total_rcvd, total_sent = rx_0 + rx_1, tx_0 + tx_1
total_lost = total_sent - total_rcvd
print(f"rate='unknown'; "
f"total_received={total_rcvd}; "
f"total_sent={total_sent}; "
f"frame_loss={total_lost}; "
f"target_duration='manual'; "
f"approximated_duration='manual'; "
f"approximated_rate='unknown'; "
f"latency_stream_0(usec)=-1/-1/-1; "
f"latency_stream_1(usec)=-1/-1/-1; ")
def main():
parser = argparse.ArgumentParser(description="")
parser.add_argument(
"--ip_src",
type=str,
default="192.168.17.1",
help="Source IP address for all packets in the stream.",
)
parser.add_argument(
"--ip_dst",
type=str,
default="192.168.17.2",
help="Destination IP address for all packets in the stream.",
)
# Due to different packet sizes, it is easier to keep the PPS fixed.
# 0.25 Mpps -> about 3Gbps bit rate.
parser.add_argument(
"--pps", type=float, default=0.25, help="Transmit L1 rate in Mpps."
)
# This is "configured" to give some space for power management ;)
parser.add_argument(
"--tot_pkts_burst",
type=int,
default=50 * 10 ** 3,
help="Total number of packets in each single burst.",
)
parser.add_argument(
"--model",
type=str,
default="poisson",
choices=["poisson", "pareto"],
help="To be used traffic model.",
)
# MARK: Currently NOT implemented.
parser.add_argument(
"--src_num", type=int, default=1, help="Number of flow sources."
)
parser.add_argument(
"--burst_num",
type=int,
default=100,
help="The number of bursts in one test round.",
)
parser.add_argument("--test", action="store_true", help="Just used for debug.")
parser.add_argument(
"--out", type=str, default="", help="Stores file with given name"
)
args = parser.parse_args()
print(f"* The fastest reaction time of X-MEN: {X_MEN_REACTION_TIME} seconds.")
print(f"* Traffic model: {args.model}")
l3_data = {"ip_src": args.ip_src, "ip_dst": args.ip_dst}
streams, flow_duration = get_streams(
args.pps,
args.burst_num,
args.model,
args.src_num,
args.tot_pkts_burst,
l3_data,
args.test,
)
if args.test:
pprint.pp([s.to_json() for s in streams[:3]])
sys.exit(0)
print(f"* Flow duration: {flow_duration} seconds.")
try:
client = STLClient()
client.connect()
tx_port, rx_port = init_ports(client)
client.add_streams(streams, ports=[tx_port])
start_ts = time.time()
client.clear_stats()
client.start(ports=[tx_port], force=True)
rx_delay_sec = flow_duration + 5
print(f"The estimated RX delay: {rx_delay_sec} seconds.")
client.wait_on_traffic(rx_delay_ms=3000) # rx_delay_sec * 10 ** 3)
end_ts = time.time()
test_dur = end_ts - start_ts
print(f"Total test duration: {test_dur} seconds")
err_cntrs_results, latency_results = get_rx_stats(
client, tx_port, rx_port, args.burst_num
)
print("--- The latency results of all streams:")
for m_burst in range(args.burst_num):
# Include ISG duratio, packet size and time stamps into .json dump
err_cntrs_results[m_burst]["isg"] = ISGS_SAVE[m_burst]
err_cntrs_results[m_burst]["len"] = IP_TOT_LENS_SAVE[m_burst]
err_cntrs_results[m_burst]["start_ts"] = start_ts
err_cntrs_results[m_burst]["end_ts"] = end_ts
print("Burst ", m_burst)
print("ISG: ", ISGS_SAVE[m_burst])
print("Dropped: ", err_cntrs_results[m_burst]["dropped"])
print("Latency: ", latency_results[m_burst]["average"])
# print(err_cntrs_results[m_burst])
# print(latency_results[m_burst])
if args.out:
savedir_latency = "/home/malte/malte/latency/"
savedir_error = "/home/malte/malte/error/"
if not os.path.exists(savedir_latency):
os.mkdir(savedir_latency)
if not os.path.exists(savedir_error):
os.mkdir(savedir_error)
savedir_latency += args.out + "_latency.json"
savedir_error += args.out + "_error.json"
print("\nResults: ", savedir_latency, ", ", savedir_error)
save_rx_stats(err_cntrs_results, savedir_error, args.burst_num)
save_rx_stats(latency_results, savedir_latency, args.burst_num)
except STLError as error:
print(error)
finally:
client.disconnect()
def simple_burst(
profile_file,
duration,
framesize,
rate,
port_0,
port_1,
latency,
async_start=False,
traffic_directions=2,
force=False,
delay=0.0,
):
"""Send traffic and measure packet loss and latency.
Procedure:
- reads the given traffic profile with streams,
- connects to the T-rex client,
- resets the ports,
- removes all existing streams,
- adds streams from the traffic profile to the ports,
- if the warm-up time is more than 0, sends the warm-up traffic, reads the
statistics,
- clears the statistics from the client,
- starts the traffic,
- waits for the defined time (or runs forever if async mode is defined),
- stops the traffic,
- reads and displays the statistics and
- disconnects from the client.
:param profile_file: A python module with T-rex traffic profile.
:param framesize: Frame size.
:param duration: Duration of traffic run in seconds (-1=infinite).
:param rate: Traffic rate [percentage, pps, bps].
:param port_0: Port 0 on the traffic generator.
:param port_1: Port 1 on the traffic generator.
:param latency: With latency stats.
:param async_start: Start the traffic and exit.
:param traffic_directions: Bidirectional (2) or unidirectional (1) traffic.
:param force: Force start regardless of ports state.
:param delay: Sleep overhead [s].
:type profile_file: str
:type framesize: int or str
:type duration: float
:type rate: str
:type port_0: int
:type port_1: int
:type latency: bool
:type async_start: bool
:type traffic_directions: int
:type force: bool
:type delay: float
"""
client = None
total_rcvd = 0
total_sent = 0
approximated_duration = 0.0
lost_a = 0
lost_b = 0
lat_a = u"-1/-1/-1/"
lat_b = u"-1/-1/-1/"
# Read the profile:
try:
print(f"### Profile file:\n{profile_file}")
profile = STLProfile.load(profile_file,
direction=0,
port_id=0,
framesize=framesize,
rate=rate)
streams = profile.get_streams()
except STLError:
print(f"Error while loading profile '{profile_file}'!")
raise
try:
# Create the client:
client = STLClient()
# Connect to server:
client.connect()
# Prepare our ports (the machine has 0 <--> 1 with static route):
client.reset(ports=[port_0, port_1])
client.remove_all_streams(ports=[port_0, port_1])
if u"macsrc" in profile_file:
client.set_port_attr(ports=[port_0, port_1], promiscuous=True)
if isinstance(framesize, int):
last_stream_a = int((len(streams) - 2) / 2)
last_stream_b = (last_stream_a * 2)
client.add_streams(streams[0:last_stream_a], ports=[port_0])
if traffic_directions > 1:
client.add_streams(streams[last_stream_a:last_stream_b],
ports=[port_1])
elif isinstance(framesize, str):
client.add_streams(streams[0:3], ports=[port_0])
if traffic_directions > 1:
client.add_streams(streams[3:6], ports=[port_1])
if latency:
try:
if isinstance(framesize, int):
client.add_streams(streams[last_stream_b], ports=[port_0])
if traffic_directions > 1:
client.add_streams(streams[last_stream_b + 1],
ports=[port_1])
elif isinstance(framesize, str):
latency = False
except STLError:
# Disable latency if NIC does not support requested stream type
print(u"##### FAILED to add latency streams #####")
latency = False
ports = [port_0]
if traffic_directions > 1:
ports.append(port_1)
# Clear the stats before injecting:
client.clear_stats()
lost_a = 0
lost_b = 0
# Choose rate and start traffic:
client.start(
ports=ports,
mult=rate,
duration=duration,
force=force,
core_mask=STLClient.CORE_MASK_PIN,
)
if async_start:
# For async stop, we need to export the current snapshot.
xsnap0 = client.ports[0].get_xstats().reference_stats
print(f"Xstats snapshot 0: {xsnap0!r}")
if traffic_directions > 1:
xsnap1 = client.ports[1].get_xstats().reference_stats
print(f"Xstats snapshot 1: {xsnap1!r}")
else:
time_start = time.monotonic()
# wait_on_traffic fails if duration stretches by 30 seconds or more.
# TRex has some overhead, wait some more.
time.sleep(duration + delay)
client.stop()
time_stop = time.monotonic()
approximated_duration = time_stop - time_start - delay
# Read the stats after the traffic stopped (or time up).
stats = client.get_stats()
if client.get_warnings():
for warning in client.get_warnings():
print(warning)
# Now finish the complete reset.
client.reset()
print(u"##### Statistics #####")
print(json.dumps(stats, indent=4, separators=(u",", u": ")))
lost_a = stats[port_0][u"opackets"] - stats[port_1][u"ipackets"]
if traffic_directions > 1:
lost_b = stats[port_1][u"opackets"] - stats[port_0][u"ipackets"]
# Stats index is not a port number, but "pgid".
if latency:
lat_obj = stats[u"latency"][0][u"latency"]
lat_a = fmt_latency(str(lat_obj[u"total_min"]),
str(lat_obj[u"average"]),
str(lat_obj[u"total_max"]),
str(lat_obj[u"hdrh"]))
if traffic_directions > 1:
lat_obj = stats[u"latency"][1][u"latency"]
lat_b = fmt_latency(str(lat_obj[u"total_min"]),
str(lat_obj[u"average"]),
str(lat_obj[u"total_max"]),
str(lat_obj[u"hdrh"]))
if traffic_directions > 1:
total_sent = stats[0][u"opackets"] + stats[1][u"opackets"]
total_rcvd = stats[0][u"ipackets"] + stats[1][u"ipackets"]
else:
total_sent = stats[port_0][u"opackets"]
total_rcvd = stats[port_1][u"ipackets"]
print(f"\npackets lost from {port_0} --> {port_1}: {lost_a} pkts")
if traffic_directions > 1:
print(
f"packets lost from {port_1} --> {port_0}: {lost_b} pkts")
except STLError:
print(u"T-Rex STL runtime error!", file=sys.stderr)
raise
finally:
if async_start:
if client:
client.disconnect(stop_traffic=False, release_ports=True)
else:
if client:
client.disconnect()
print(f"rate={rate!r}; "
f"total_received={total_rcvd}; "
f"total_sent={total_sent}; "
f"frame_loss={lost_a + lost_b}; "
f"target_duration={duration!r}; "
f"approximated_duration={approximated_duration!r}; "
f"latency_stream_0(usec)={lat_a}; "
f"latency_stream_1(usec)={lat_b}; ")
def main():
global IP_TOT_LEN
parser = argparse.ArgumentParser(
description=
"On/Off traffic of a deterministic and stateless stream profile.")
parser.add_argument(
"--ip_src",
type=str,
default="192.168.17.1",
help="Source IP address for all packets in the stream.",
)
parser.add_argument(
"--ip_dst",
type=str,
default="192.168.17.2",
help="Destination IP address for all packets in the stream.",
)
parser.add_argument(
"--max_bit_rate",
type=float,
default=1,
help="Maximal bit rate (with the unit Gbps) of the underlying network.",
)
parser.add_argument("--on_time",
type=int,
default=2,
help="ON time in seconds.")
parser.add_argument(
"--init_off_on_ratio",
type=float,
default=0.5,
help="Initial ratio between OFF and ON time.",
)
parser.add_argument(
"--iteration",
type=int,
default=1,
help="Number of iterations for the ON state of each PPS.",
)
parser.add_argument(
"--numa_node",
type=int,
default=0,
help="The NUMA node of cores used for TX and RX.",
)
parser.add_argument("--test",
action="store_true",
help="Just used for debug.")
parser.add_argument(
"--out",
type=str,
default="",
help=
"The name of the output file, stored in /home/malte/malte/latency if given",
)
parser.add_argument(
"--ip_tot_len",
type=int,
default=IP_TOT_LEN,
help="The IP total length of packets to be transmitted.",
)
parser.add_argument(
"--enable_second_flow",
action="store_true",
help="Enable the second flow, used to test two-vnf setup.",
)
parser.add_argument(
"--soft",
action="store_true",
help="Different overlap for sencond flow, it's easier to scale ;)",
)
args = parser.parse_args()
IP_TOT_LEN = args.ip_tot_len
stream_params = create_stream_params(
args.max_bit_rate,
args.on_time,
args.init_off_on_ratio,
args.iteration,
args.test,
)
print("\n--- Initial stream parameters:")
pprint.pp(stream_params)
print()
if args.enable_second_flow:
print(
"INFO: The second flow is enabled. Two flows share the physical link."
)
# Simply reverse the link utilizations
second_stream_params = copy.deepcopy(list(reversed(stream_params)))
# Change ISG's of 2nd flow to 2s
for s in second_stream_params:
s["on_time"] = args.on_time - (args.on_time * 0.2)
s["isg"] = s["isg"] + (args.on_time * 0.2) * 10**6
# Reset ISG of first stream of the 2nd flow back to 1
# -> they always start together then
if args.soft:
second_stream_params[0]["isg"] = 1 * 10**6
print("\n--- Updated stream parameters with the second flow:")
pprint.pp(second_stream_params)
# Does not work on the blackbox
# core_mask = get_core_mask(args.numa_node)
# print(f"The core mask for RX and TX: {hex(core_mask)}")
if args.enable_second_flow:
streams = create_streams_with_second_flow(stream_params,
second_stream_params,
args.ip_src, args.ip_dst)
else:
streams = create_streams(stream_params, args.ip_src, args.ip_dst)
second_stream_params = None
if args.test:
pprint.pp([s.to_json() for s in streams])
import sys
sys.exit(0)
if args.enable_second_flow:
RX_DELAY_S = (sum([s["on_time"] for s in stream_params])) / 2.0 + 3
else:
RX_DELAY_S = sum([s["on_time"] for s in stream_params]) + 3
RX_DELAY_MS = 3 * 1000 # Time after last Tx to wait for the last packet at Rx side
try:
client = STLClient()
client.connect()
tx_port, rx_port = init_ports(client)
client.add_streams(streams, ports=[tx_port])
# Start TX
start_ts = time.time()
client.clear_stats()
# All cores in the core_mask is used by the tx_port and its adjacent
# port, so it is the rx_port normally.
# client.start(ports=[tx_port], core_mask=[core_mask], force=True)
client.start(ports=[tx_port], force=True)
print(f"The estimated RX delay: {RX_DELAY_MS / 1000} seconds.")
client.wait_on_traffic(rx_delay_ms=RX_DELAY_MS)
end_ts = time.time()
test_dur = end_ts - start_ts
print(f"Total test duration: {test_dur} seconds")
# Check RX stats.
# MARK: All latency results are in usec.
err_cntrs_results, latency_results = get_rx_stats(
client,
tx_port,
rx_port,
stream_params,
second_stream_params=second_stream_params,
)
print("--- The latency results of all streams:")
print(f"- Number of streams first flow: {len(latency_results[0])}")
for index, _ in enumerate(stream_params):
print(f"- Stream: {index}")
# Add timestamps to .json dump to parse turbostat results later
err_cntrs_results[0][index]["start_ts"] = start_ts
err_cntrs_results[0][index]["end_ts"] = end_ts
print(err_cntrs_results[0][index])
print(latency_results[0][index])
# Save stats as .json dump
if args.out:
savedir_latency = "/home/malte/malte/latency/flow1/"
savedir_error = "/home/malte/malte/error/flow1/"
if not os.path.exists(savedir_latency):
os.mkdir(savedir_latency)
if not os.path.exists(savedir_error):
os.mkdir(savedir_error)
savedir_latency += args.out + "_latency.json"
savedir_error += args.out + "_error.json"
print("\nResults: ", savedir_latency, ", ", savedir_error)
save_rx_stats(err_cntrs_results[0], savedir_error, stream_params)
save_rx_stats(latency_results[0], savedir_latency, stream_params)
if second_stream_params is not None:
print(
f"\n\n- Number of streams second flow: {len(latency_results[1])}"
)
for index, _ in enumerate(stream_params):
print(f"- Stream: {index}")
err_cntrs_results[1][index]["start_ts"] = start_ts
err_cntrs_results[1][index]["end_ts"] = end_ts
print(err_cntrs_results[1][index])
print(latency_results[1][index])
if args.out:
savedir_latency = "/home/malte/malte/latency/flow2/"
savedir_error = "/home/malte/malte/error/flow2/"
if not os.path.exists(savedir_latency):
os.mkdir(savedir_latency)
if not os.path.exists(savedir_error):
os.mkdir(savedir_error)
savedir_latency += args.out + "_latency.json"
savedir_error += args.out + "_error.json"
print("\nResults: ", savedir_latency, ", ", savedir_error)
save_rx_stats(err_cntrs_results[1], savedir_error,
stream_params)
save_rx_stats(latency_results[1], savedir_latency,
stream_params)
except STLError as error:
print(error)
finally:
client.disconnect()
def main():
global PAYLOAD_SIZE
parser = argparse.ArgumentParser(
description=
"On/Off traffic of a deterministic and stateless stream profile.")
parser.add_argument(
"--ip_src",
type=str,
default="192.168.17.1",
help="Source IP address for all packets in the stream.",
)
parser.add_argument(
"--ip_dst",
type=str,
default="192.168.17.2",
help="Destination IP address for all packets in the stream.",
)
parser.add_argument(
"--max_bit_rate",
type=float,
default=1,
help="Maximal bit rate (with the unit Gbps) of the underlying network.",
)
parser.add_argument("--on_time",
type=int,
default=2,
help="ON time in seconds.")
parser.add_argument(
"--init_off_on_ratio",
type=float,
default=0.5,
help="Initial ratio between OFF and ON time.",
)
parser.add_argument(
"--iteration",
type=int,
default=1,
help="Number of iterations for the ON state of each PPS.",
)
parser.add_argument(
"--numa_node",
type=int,
default=0,
help="The NUMA node of cores used for TX and RX.",
)
parser.add_argument("--test",
action="store_true",
help="Just used for debug.")
parser.add_argument(
"--out",
type=str,
default="",
help=
"The name of the output file, stored in /home/malte/malte/latency if given",
)
parser.add_argument(
"--payload_size",
type=int,
default=PAYLOAD_SIZE,
help="Payload size of the packets",
)
args = parser.parse_args()
PAYLOAD_SIZE = args.payload_size
stream_params = create_stream_params(
args.max_bit_rate,
args.on_time,
args.init_off_on_ratio,
args.iteration,
args.test,
)
print("\n--- To be used stream parameters:")
pprint.pp(stream_params)
print()
# Does not work on the blackbox
# core_mask = get_core_mask(args.numa_node)
# print(f"The core mask for RX and TX: {hex(core_mask)}")
streams = create_streams(stream_params, args.ip_src, args.ip_dst)
if args.test:
pprint.pp(streams)
pprint.pp([s.to_json() for s in streams])
RX_DELAY_S = sum([s["on_time"] for s in stream_params]) + 3
RX_DELAY_MS = 3 * 1000 # Time after last Tx to wait for the last packet at Rx side
try:
client = STLClient()
client.connect()
tx_port, rx_port = init_ports(client)
client.add_streams(streams, ports=[tx_port])
# Start TX
start_ts = time.time()
client.clear_stats()
# All cores in the core_mask is used by the tx_port and its adjacent
# port, so it is the rx_port normally.
# client.start(ports=[tx_port], core_mask=[core_mask], force=True)
client.start(ports=[tx_port], force=True)
print(f"The estimated RX delay: {RX_DELAY_MS / 1000} seconds.")
client.wait_on_traffic(rx_delay_ms=RX_DELAY_MS)
end_ts = time.time()
test_dur = end_ts - start_ts
print(f"Total test duration: {test_dur} seconds")
# Check RX stats.
# MARK: All latency results are in usec.
# err_cntrs_results, latency_results = get_rx_stats(
# client, tx_port, rx_port, stream_params
# )
err_cntrs_results, latency_results, flow_results = get_rx_stats(
client, tx_port, rx_port, stream_params)
print("--- The latency results of all streams:")
print(f"- Number of streams: {len(latency_results)}")
for index, _ in enumerate(stream_params):
print(f"- Stream: {index}")
err_cntrs_results[index]["start_ts"] = start_ts
err_cntrs_results[index]["end_ts"] = end_ts
print(err_cntrs_results[index])
print(latency_results[index])
print(flow_results[index])
if args.out:
savedir_latency = "/home/malte/malte/latency/" + args.out + "_latency.json"
savedir_error = "/home/malte/malte/error/" + args.out + "_error.json"
print("Results: ", savedir_latency, ", ", savedir_error)
save_rx_stats(err_cntrs_results, savedir_error, stream_params)
save_rx_stats(latency_results, savedir_latency, stream_params)
except STLError as error:
print(error)
finally:
client.disconnect()
