def set_up_all(self):
"""
Run at the start of each test suite.
"""
self.dut_ports = self.dut.get_ports(self.nic)
self.verify(len(self.dut_ports) >= 2, "Insufficient ports")
cores = self.dut.get_core_list("1S/4C/1T")
self.coremask = utils.create_mask(cores)
self.portmask = utils.create_mask(self.dut_ports)
self.path = "./examples/link_status_interrupt/build/link_status_interrupt"
# build sample app
out = self.dut.build_dpdk_apps("./examples/link_status_interrupt")
self.verify("Error" not in out, "compilation error 1")
self.verify("No such file" not in out, "compilation error 2")
# from kernel 4.8+, kernel will not support legacy intr mode.
# detaile info:https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/commit/drivers/pci/quirks.c?id=8bcf4525c5d43306c5fd07e132bc8650e3491aec
if self.nic in [
"fortville_eagle", "fortville_spirit",
"fortville_spirt_single", "fortville_25g"
]:
self.basic_intr_mode = ["msix"]
else:
self.basic_intr_mode = ["msix", "legacy"]
if self.drivername == "vfio-pci":
self.basic_intr_mode.append("msi")
def set_up_all(self):
"""
Prerequisite steps for each test suit.
"""
self.dut_ports = self.dut.get_ports()
self.verify(len(self.dut_ports) >= 1, "Insufficient ports")
self.rx_port = self.dut_ports[0]
self.tx_port = self.dut_ports[0]
cores = self.dut.get_core_list("1S/2C/1T")
self.coremask = utils.create_mask(cores)
self.port_mask = utils.create_mask([self.rx_port, self.tx_port])
if self.kdriver == "fm10k":
netobj = self.dut.ports_info[self.tx_port]['port']
netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU)
netobj = self.dut.ports_info[self.rx_port]['port']
netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU)
self.tester.send_expect(
"ifconfig %s mtu %s" %
(self.tester.get_interface(self.tester.get_local_port(
self.rx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ")
# self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.tx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ")
self.pmdout = PmdOutput(self.dut)
def test_reset_queues(self):
"""
Reset RX/TX Queues.
"""
testcorelist = self.dut.get_core_list("1S/8C/1T",
socket=self.ports_socket)
self.pmdout.start_testpmd(testcorelist,
"--portmask=%s --port-topology=loop" %
utils.create_mask([self.ports[0]]),
socket=self.ports_socket)
fwdcoremask = utils.create_mask(testcorelist[-3:])
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("port config all rxq 2", "testpmd> ")
self.dut.send_expect("port config all txq 2", "testpmd> ")
self.dut.send_expect("set coremask %s" % fwdcoremask, "testpmd> ")
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("port start all", "testpmd> ", 100)
out = self.dut.send_expect("show config rxtx", "testpmd> ")
self.verify("RX queue number: 2" in out,
"RX queues not reconfigured properly")
self.verify("Tx queue number: 2" in out,
"TX queues not reconfigured properly")
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
self.dut.send_expect("quit", "# ", 30)
def set_up_all(self):
"""
Run at the start of each test suite.
Vlan Prerequistites
"""
global dutRxPortId
global dutTxPortId
# Based on h/w type, choose how many ports to use
ports = self.dut.get_ports(self.nic)
self.verify(len(ports) >= 2, "Insufficient ports")
self.ports_socket = self.dut.get_numa_id(ports[0])
cores = self.dut.get_core_list('1S/2C/2T')
coreMask = utils.create_mask(cores)
ports = self.dut.get_ports(self.nic)
valports = [_ for _ in ports if self.tester.get_local_port(_) != -1]
portMask = utils.create_mask(valports[:2])
dutRxPortId = valports[0]
dutTxPortId = valports[1]
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("Default", "--portmask=%s" % portMask, socket=self.ports_socket)
if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortville_25g", "fortpark_TLV"]:
self.dut.send_expect("vlan set filter on all", "testpmd> ")
self.dut.send_expect("set promisc all off", "testpmd> ")
out = self.dut.send_expect("set fwd mac", "testpmd> ")
self.verify('Set mac packet forwarding mode' in out, "set fwd mac error")
out = self.dut.send_expect("start", "testpmd> ", 120)
def set_up_all(self):
"""
Run at the start of each test suite.
"""
self.tester.extend_external_packet_generator(TestPVPVirtioMultiQueues,
self)
self.frame_sizes = [64, 128, 256, 512, 1024, 1518]
self.core_config = "1S/6C/1T"
self.queue_number = 2
self.port_number = 2
self.dut_ports = self.dut.get_ports()
self.verify(len(self.dut_ports) >= 1, "Insufficient ports for testing")
self.ports_socket = self.dut.get_numa_id(self.dut_ports[0])
self.cores_num = len([
n for n in self.dut.cores if int(n['socket']) == self.ports_socket
])
self.verify(self.cores_num >= 6,
"There has not enought cores to test this case")
self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE['ip'] + \
HEADER_SIZE['udp']
self.core_list = self.dut.get_core_list(self.core_config,
socket=self.ports_socket)
self.core_list_user = self.core_list[0:3]
self.core_list_host = self.core_list[3:6]
self.core_mask_user = utils.create_mask(self.core_list_user)
self.core_mask_host = utils.create_mask(self.core_list_host)
self.dst_mac = self.dut.get_mac_address(self.dut_ports[0])
self.logger.info("you can config packet_size in file %s.cfg," % self.suite_name + \
"in region 'suite' like packet_sizes=[64, 128, 256]")
# get the frame_sizes from cfg file
if 'packet_sizes' in self.get_suite_cfg():
self.frame_sizes = self.get_suite_cfg()['packet_sizes']
def set_up_all(self):
"""
Run at the start of each test suite.
"""
# only one port is enought for this case
self.dut_ports = self.dut.get_ports()
self.verify(
len(self.dut_ports) >= 1, "Not enough ports for " + self.nic)
self.core_mask = utils.create_mask(self.dut.get_core_list("1S/4C/1T"))
self.port_mask = utils.create_mask([self.dut_ports[0]])
self.path = "./examples/l2fwd/build/app/l2fwd"
# strip mempool size
self.main_path = "./examples/l2fwd/main.c"
out = self.dut.send_expect(
"cat %s | grep \"#define NB_MBUF\"" % self.main_path, "# ")
mp_str = utils.regexp(out, r"#define NB_MBUF (\d+)")
if mp_str is None:
mp_size = 8192
else:
mp_size = int(mp_str)
# make sure packets more than 2*mempool size
self.pkts = mp_size * 2 + 1000
def set_up_all(self):
"""
Run at the start of each test suite.
"""
self.works = 4
self.packet_num = 96
self.core_config = "1S/7C/1T"
self.build_eventdev_app()
self.dut_ports = self.dut.get_ports()
self.verify(len(self.dut_ports) >= 1, "Insufficient ports for testing")
self.ports_socket = self.dut.get_numa_id(self.dut_ports[0])
self.core_list = self.dut.get_core_list(self.core_config,
socket=self.ports_socket)
self.core_list_rx = self.core_list[0:1]
self.core_list_tx = self.core_list[1:2]
self.core_list_sd = self.core_list[2:3]
self.core_list_wk = self.core_list[3:7]
self.core_mask_rx = utils.create_mask(self.core_list_rx)
self.core_mask_tx = utils.create_mask(self.core_list_tx)
self.core_mask_sd = utils.create_mask(self.core_list_sd)
self.core_mask_wk = utils.create_mask(self.core_list_wk)
self.core_list = ",".join(self.core_list)
pre = int(self.core_list[0]) - 1
self.core_list = str(pre) + "," + self.core_list
self.rx_port = self.tester.get_local_port(self.dut_ports[0])
self.tx_port = self.rx_port
self.rx_interface = self.tester.get_interface(self.rx_port)
self.tx_interface = self.tester.get_interface(self.tx_port)
self.d_mac = self.dut.get_mac_address(self.dut_ports[0])
def test_l2fwd_integrity(self):
print("***l2fwd integrity")
"""
Check port forwarding.
"""
# the cases use the first two ports
port_mask = utils.create_mask([self.dut_ports[0], self.dut_ports[1]])
print("***port mask", port_mask)
core_mask = utils.create_mask(
self.dut.get_core_list(self.core_config, socket=self.ports_socket))
print("***core mask", core_mask)
for queues in self.test_queues:
command_line = "./examples/l2fwd/build/app/l2fwd -n %d -c %s -- -q %s -p %s &" % \
(self.dut.get_memory_channels(), core_mask,
str(queues['queues']), port_mask)
self.dut.send_expect(command_line, "L2FWD: entering main loop", 60)
tgen_input = []
tx_port = self.tester.get_local_port(self.dut_ports[0])
rx_port = self.tester.get_local_port(self.dut_ports[1])
tgen_input.append((tx_port, rx_port))
result = self.tester.check_random_pkts(tgen_input,
allow_miss=False)
self.verify(result != False, "Packet integrity check failed")
self.quit_l2fwd()
def get_core_mask(self):
"""
get the coremask about vhost and virito depend on the queue number
"""
self.core_list_user = self.core_list[0:self.nb_cores + 1]
self.core_list_host = self.core_list[self.nb_cores +
1:2 * self.nb_cores + 2]
self.core_mask_user = utils.create_mask(self.core_list_user)
self.core_mask_host = utils.create_mask(self.core_list_host)
def cross_correlate(self,
image,
region1=None,
region2=None,
upsample_factor=100,
extended_output=False,
mask_cc=False):
"""
Cross-correlates current instance of ``Image`` with another instance
using phase correlation.
:param image:
Instance of image class.
:param region1: (optional)
Region to EXCLUDE in current instance of ``Image``.
Or (blc[0], blc[1], trc[0], trc[1],) or (center[0], center[1], r,
None,) or (center[0], center[1], bmaj, e, bpa). Default ``None``.
:param region2: (optional)
Region to EXCLUDE in other instance of ``Image``. Or (blc[0],
blc[1], trc[0], trc[1],) or (center[0], center[1], r, None,) or
(center[0], center[1], bmaj, e, bpa). Default ``None``.
:param upsample_factor: (optional)
Upsampling factor. Images will be registered to within
``1 / upsample_factor`` of a pixel. For example
``upsample_factor == 20`` means the images will be registered
within 1/20th of a pixel. If ``1`` then no upsampling.
(default: ``100``)
:param extended_output: (optioinal)
Output all information from ``register_translation``? (default:
``False``)
:param mask_cc: (optional)
If some of images is instance of ``CleanImage`` class - should we
mask clean components instead of image array? (default: ``False``)
:return:
Array of shifts (subpixeled) in each direction or full information
from ``register_translation`` depending on ``extended_output``.
"""
image1 = self.image.copy()
if region1 is not None:
mask1 = create_mask(self.image.shape, region1)
if mask_cc and isinstance(self, CleanImage):
raise NotImplementedError()
image1[mask1] = 0.
image2 = image.image.copy()
if region2 is not None:
mask2 = create_mask(image.image.shape, region2)
if mask_cc and isinstance(image, CleanImage):
raise NotImplementedError()
image2[mask2] = 0.
# Cross-correlate images
shift, error, diffphase = register_translation(image1, image2,
upsample_factor)
result = shift
if extended_output:
result = (shift, error, diffphase)
return result
def test_create_mask(self):
inputs = tf.constant([[1, 2], [2, 1], [3, 2]])
masking_prob = {1: 1., 2: 0., 3: 0.8}
self.assertAllEqual(
tf.constant([[1, 0], [0, 1], [0, 0]]),
utils.create_mask(inputs, masking_prob, seed=1))
self.assertAllEqual(
tf.constant([[1, 0], [0, 1], [1, 0]]),
utils.create_mask(inputs, masking_prob, seed=2))
def benchmark(self, index, lcore, num_pthreads, size_list):
"""
Just Test IPv4 Throughput for selected parameters.
"""
Bps = dict()
Pps = dict()
Pct = dict()
if int(lcore[0]) == 1:
core_mask = utils.create_mask(self.dut.get_core_list(lcore, socket=self.ports_socket))
else:
core_mask = utils.create_mask(self.dut.get_core_list(lcore))
portmask = utils.create_mask([P0, P1])
self.dut.send_expect("examples/ip_fragmentation/build/ip_fragmentation -c %s -n %d -- -p %s -q %s" % (
core_mask, self.dut.get_memory_channels(), portmask, num_pthreads), "IP_FRAG:", 120)
result = [2, lcore, num_pthreads]
for size in size_list:
dmac = self.dut.get_mac_address(P0)
flows = ['Ether(dst="%s")/IP(src="1.2.3.4", dst="100.10.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.20.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
'Ether(dst="%s")/IPv6(dst="101:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58),
'Ether(dst="%s")/IPv6(dst="201:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58)]
self.tester.scapy_append('wrpcap("test1.pcap", [%s])' % string.join(flows, ','))
# reserved for rx/tx bidirection test
dmac = self.dut.get_mac_address(P1)
flows = ['Ether(dst="%s")/IP(src="1.2.3.4", dst="100.30.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.40.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
'Ether(dst="%s")/IPv6(dst="301:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58),
'Ether(dst="%s")/IPv6(dst="401:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58)]
self.tester.scapy_append('wrpcap("test2.pcap", [%s])' % string.join(flows, ','))
self.tester.scapy_execute()
tgenInput = []
tgenInput.append((self.tester.get_local_port(P0), self.tester.get_local_port(P1), "test1.pcap"))
tgenInput.append((self.tester.get_local_port(P1), self.tester.get_local_port(P0), "test2.pcap"))
factor = (size + 1517) / 1518
# wireSpd = 2 * 10000.0 / ((20 + size) * 8)
Bps[str(size)], Pps[str(size)] = self.tester.traffic_generator_throughput(tgenInput)
self.verify(Pps[str(size)] > 0, "No traffic detected")
Pps[str(size)] *= 1.0 / factor / 1000000
Pct[str(size)] = (1.0 * Bps[str(size)] * 100) / (2 * 10000000000)
result.append(Pps[str(size)])
result.append(Pct[str(size)])
self.result_table_add(result)
self.dut.send_expect("^C", "#")
def _efd_perf_evaluate(self, node_num, flow_num):
# extended flow number into etgen module
self.tester.ixia_packet_gen.flow_num = flow_num
# output port is calculated from overall ports number
server_cmd_fmt = "%s -c %s -n %d -w %s -w %s -- -p 0x3 -n %d -f %s"
node_cmd_fmt = "%s -c %s -n %d --proc-type=secondary -- -n %d"
socket = self.dut.get_numa_id(self.dut_ports[0])
self.tester.scapy_append(
'wrpcap("efd.pcap", [Ether()/IP(src="0.0.0.0", dst="0.0.0.0")/("X"*26)])'
)
self.tester.scapy_execute()
tgen_input = []
rx_port = self.tester.get_local_port(self.dut_ports[0])
tx_port = self.tester.get_local_port(self.dut_ports[1])
tgen_input.append((tx_port, rx_port, "efd.pcap"))
tgen_input.append((rx_port, tx_port, "efd.pcap"))
cores = self.dut.get_core_list("1S/%dC/1T" % (node_num + 2), socket)
self.verify(len(cores), "Can't find enough cores")
server_cmd = server_cmd_fmt % (
self.server_app, utils.create_mask(
cores[0:2]), self.dut.get_memory_channels(),
self.dut.get_port_pci(self.dut_ports[0]),
self.dut.get_port_pci(self.dut_ports[1]), node_num, hex(flow_num))
# create table may need few minutes
self.dut.send_expect(server_cmd, "Finished Process Init", timeout=240)
node_sessions = []
for node in range(node_num):
node_cmd = node_cmd_fmt % (self.node_app,
utils.create_mask([cores[2 + node]]),
self.dut.get_memory_channels(), node)
node_session = self.dut.new_session(suite="node%d" % node)
node_sessions.append(node_session)
node_session.send_expect(node_cmd,
"Finished Process Init",
timeout=30)
_, pps = self.tester.traffic_generator_throughput(tgen_input, delay=10)
for node_session in node_sessions:
node_session.send_expect("^C", "#")
self.dut.close_session(node_session)
self.dut.send_expect("^C", "#")
pps /= 1000000.0
return pps
def test_multiprocess_simple_mpapplicationstartup(self):
"""
Test use of Auto for Application Startup.
"""
# Send message from secondary to primary (auto process type)
cores = self.dut.get_core_list('1S/2C/1T')
coremask = utils.create_mask(cores)
out = self.dut.send_expect(
"./examples/multi_process/simple_mp/%s/simple_mp -n 1 -c %s --proc-type=auto "
% (self.target, coremask), "Finished Process Init", 100)
self.verify("EAL: Auto-detected process type: PRIMARY" in out,
"The type of process (PRIMARY) was not detected properly")
time.sleep(20)
coremask = hex(int(coremask, 16) * 0x100).rstrip("L")
out = self.session_secondary.send_expect(
"./examples/multi_process/simple_mp/%s/simple_mp -n 1 -c %s --proc-type=auto"
% (self.target, coremask), "Finished Process Init", 100)
self.verify(
"EAL: Auto-detected process type: SECONDARY" in out,
"The type of process (SECONDARY) was not detected properly")
self.session_secondary.send_expect("send hello_primary", ">")
out = self.dut.get_session_output()
self.session_secondary.send_expect("quit", "# ")
self.dut.send_expect("quit", "# ")
self.verify("Received 'hello_primary'" in out,
"Message not received on primary process")
# Send message from primary to secondary (auto process type)
cores = self.dut.get_core_list('1S/2C/1T')
coremask = utils.create_mask(cores)
out = self.session_secondary.send_expect(
"./examples/multi_process/simple_mp/%s/simple_mp -n 1 -c %s --proc-type=auto"
% (self.target, coremask), "Finished Process Init", 100)
self.verify("EAL: Auto-detected process type: PRIMARY" in out,
"The type of process (PRIMARY) was not detected properly")
time.sleep(20)
coremask = hex(int(coremask, 16) * 0x100).rstrip("L")
out = self.dut.send_expect(
"./examples/multi_process/simple_mp/%s/simple_mp -n 1 -c %s --proc-type=auto"
% (self.target, coremask), "Finished Process Init", 100)
self.verify(
"EAL: Auto-detected process type: SECONDARY" in out,
"The type of process (SECONDARY) was not detected properly")
self.session_secondary.send_expect("send hello_secondary", ">", 100)
out = self.dut.get_session_output()
self.session_secondary.send_expect("quit", "# ")
self.dut.send_expect("quit", "# ")
self.verify("Received 'hello_secondary'" in out,
"Message not received on primary process")
def set_up_all(self):
"""
Run at the start of each test suite.
"""
self.frame_sizes = [64, 128, 256, 512, 1024, 1518]
self.core_config = "1S/5C/1T"
self.dut_ports = self.dut.get_ports()
self.ports_socket = self.dut.get_numa_id(self.dut_ports[0])
self.core_list = self.dut.get_core_list(self.core_config,
socket=self.ports_socket)
self.core_list_user = self.core_list[0:2]
self.core_list_host = self.core_list[2:5]
self.core_mask_user = utils.create_mask(self.core_list_user)
self.core_mask_host = utils.create_mask(self.core_list_host)
def test_link_stats(self):
"""
port link stats test
"""
if self.kdriver == "fm10k":
print utils.RED("RRC not support\n")
return
self.pmdout.start_testpmd("Default",
"--portmask=%s --port-topology=loop" %
utils.create_mask(self.ports),
socket=self.ports_socket)
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("start", "testpmd>")
ports_num = len(self.ports)
# link down test
for i in range(ports_num):
self.dut.send_expect("set link-down port %d" % i, "testpmd>")
# leep few seconds for NIC link status update
time.sleep(5)
self.check_ports(status=False)
# link up test
for j in range(ports_num):
self.dut.send_expect("set link-up port %d" % j, "testpmd>")
time.sleep(5)
self.check_ports(status=True)
self.check_forwarding()
def test_change_numberrxdtxdaftercycle(self):
"""
Change the Number of rxd/txd.
"""
self.pmdout.start_testpmd("Default",
"--portmask=%s --port-topology=loop" %
utils.create_mask(self.ports),
socket=self.ports_socket)
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("port config all rxd 1024", "testpmd> ")
self.dut.send_expect("port config all txd 1024", "testpmd> ")
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("port start all", "testpmd> ", 100)
out = self.dut.send_expect("show config rxtx", "testpmd> ")
self.verify("RX desc=1024" in out,
"RX descriptor not reconfigured properly")
self.verify("TX desc=1024" in out,
"TX descriptor not reconfigured properly")
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("port start all", "testpmd> ", 100)
out = self.dut.send_expect("show config rxtx", "testpmd> ")
self.verify("RX desc=1024" in out,
"RX descriptor not reconfigured properly")
self.verify("TX desc=1024" in out,
"TX descriptor not reconfigured properly")
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
def test_stress_test(self):
"""
Start/stop stress test.
"""
stress_iterations = 10
self.pmdout.start_testpmd("Default",
"--portmask=%s --port-topology=loop" %
utils.create_mask(self.ports),
socket=self.ports_socket)
tgenInput = []
for port in self.ports:
dmac = self.dut.get_mac_address(port)
self.tester.scapy_append(
'wrpcap("test%d.pcap",[Ether(src="02:00:00:00:00:0%d",dst=%s)/IP()/UDP()/()])'
% (port, port, dmac))
tgenInput.append(
(self.tester.get_local_port(port),
self.tester.get_local_port(port), "test%d.pcap" % port))
for _ in range(stress_iterations):
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("port start all", "testpmd> ", 100)
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ")
def test_multiple_ports(self):
"""
Check distributor app work fine with multiple ports
"""
self.verify(len(self.dut_ports) >= 2, "Not enough ports")
cmd_fmt = "%s -c %s -n %d -w %s -w %s -- -p 0x3"
socket = self.dut.get_numa_id(self.dut_ports[0])
cores = self.dut.get_core_list("1S/%dC/1T" % (2 + 4), socket)
cmd = cmd_fmt % (self.app, utils.create_mask(cores),
self.dut.get_memory_channels(),
self.dut.get_port_pci(self.dut_ports[0]),
self.dut.get_port_pci(self.dut_ports[1]))
self.dut.send_expect(cmd, "doing packet RX", timeout=30)
tx_port = self.tester.get_local_port(self.dut_ports[0])
rx_port = self.tester.get_local_port(self.dut_ports[1])
tgen_input = [(tx_port, rx_port)]
self.tester.check_random_pkts(tgen_input, pktnum=256, seq_check=True)
tgen_input = [(rx_port, tx_port)]
self.tester.check_random_pkts(tgen_input, pktnum=256, seq_check=True)
self.dut.send_expect("^C", "#")
def loss(self, input_sequences, input_lengths, output_sequences, output_lengths, weight_decay):
# Shift the presented output sequences by 1 position by prepending the last input token and removing the last output token
last_inputs = input_sequences[input_lengths - 1, T.arange(input_sequences[0].shape[0])].reshape((1, input_sequences[0].shape[0]))
presented_sequences = T.concatenate([last_inputs, output_sequences[:-1]])
# Predict output sequence
predicted_sequences = self.forward(input_sequences, input_lengths, presented_sequences)
predicted_sequences_hard = T.argmax(predicted_sequences, -1)
timesteps = predicted_sequences.shape[0]
batch_size = predicted_sequences.shape[1]
dimensionality = predicted_sequences.shape[2]
# Create to masks to reshape the predictions and output sequences taking into account sentence lengths
mask = utils.create_mask(output_lengths, timesteps, columns=False).T
# reshape into vecor using mask
reshaped_predictions = predicted_sequences[mask.nonzero()]
reshaped_targets = output_sequences[mask.nonzero()]
loss = self.loss_function(reshaped_predictions, reshaped_targets) + self.l2(weight_decay)
accuracy = T.mean(T.eq(predicted_sequences_hard, output_sequences))
return loss, accuracy
def test_send_packets_with_one_device(self):
in_pcap = 'in_pmdpcap.pcap'
out_pcap = '/tmp/out_pmdpcap.pcap'
two_cores = self.dut.get_core_list("1S/2C/1T")
core_mask = utils.create_mask(two_cores)
self.create_pcap_file(in_pcap, TestPmdPcap.pcap_file_sizes[0])
self.dut.session.copy_file_to(in_pcap)
command = ("./{}/app/testpmd -c {} -n {} " +
"--vdev=eth_pcap0,rx_pcap={},tx_pcap={} " +
"-- -i --port-topology=chained --no-flush-rx")
self.dut.send_expect(
command.format(self.target, core_mask, self.memory_channel,
TestPmdPcap.dut_pcap_files_path + in_pcap,
out_pcap), 'testpmd> ', 15)
self.dut.send_expect('start', 'testpmd> ')
sleep(2)
self.dut.send_expect('stop', 'testpmd> ')
self.dut.send_expect('quit', '# ')
self.check_pcap_files(TestPmdPcap.dut_pcap_files_path + in_pcap,
out_pcap, TestPmdPcap.pcap_file_sizes[0])
def set_up_all(self):
"""
Run at the start of each test suite.
Whitelist Prerequisites:
Two Ports
testpmd can normally started
"""
self.frames_to_send = 1
# Based on h/w type, choose how many ports to use
self.dutPorts = self.dut.get_ports()
# Verify that enough ports are available
self.verify(len(self.dutPorts) >= 1, "Insufficient ports")
portMask = utils.create_mask(self.dutPorts[:1])
self.pmdout = PmdOutput(self.dut)
self.pmdout.start_testpmd("Default", "--portmask=%s" % portMask)
self.dut.send_expect("set verbose 1", "testpmd> ")
self.dut.send_expect("set fwd rxonly", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
# get dest address from self.target port
out = self.dut.send_expect("show port info %d" % self.dutPorts[0], "testpmd> ")
self.dest = self.dut.get_mac_address(self.dutPorts[0])
mac_scanner = r"MAC address: (([\dA-F]{2}:){5}[\dA-F]{2})"
ret = utils.regexp(out, mac_scanner)
self.verify(ret is not None, "MAC address not found")
self.verify(cmp(ret.lower(), self.dest) == 0, "MAC address wrong")
self.max_mac_addr = utils.regexp(out, "Maximum number of MAC addresses: ([0-9]+)")
def set_up_all(self):
"""
Run at the start of each test suite.
PMD prerequisites.
"""
# Check for port availability
self.needed_ports = {"niantic": 2,
"I217V": 1,
"I217LM": 1,
"I218V": 1,
"I218LM": 1}
self.dut_ports = self.dut.get_ports()
self.verify(len(self.dut_ports) >= self.needed_ports[self.nic],
"Insufficient ports for speed testing")
out = self.dut.build_dpdk_apps("./examples/ip_pipeline")
self.verify("Error" not in out, "Compilation error")
self.ports_mask = utils.create_mask(
[self.dut_ports[0], self.dut_ports[1]])
self.coremask = "0x3e" # IP Pipeline app requires FIVE cores
self.dut.setup_memory(4096)
def test_multiprocess_simple_mploadtest(self):
"""
Load test of Simple MP application.
"""
cores = self.dut.get_core_list('1S/2C/1T')
coremask = utils.create_mask(cores)
self.session_secondary.send_expect(
"./examples/multi_process/simple_mp/%s/simple_mp -n 1 -c %s --proc-type=primary"
% (self.target, coremask), "Finished Process Init", 100)
time.sleep(20)
coremask = hex(int(coremask, 16) * 0x100).rstrip("L")
self.dut.send_expect(
"./examples/multi_process/simple_mp/%s/simple_mp -n 1 -c %s --proc-type=secondary"
% (self.target, coremask), "Finished Process Init", 100)
stringsSent = 0
for line in open('/usr/share/dict/words', 'r').readlines():
line = line.split('\n')[0]
self.dut.send_expect("send %s" % line, ">")
stringsSent += 1
if stringsSent == 3:
break
time.sleep(5)
self.dut.send_expect("quit", "# ")
self.session_secondary.send_expect("quit", "# ")
def set_up_all(self):
"""
Run at the start of each test suite.
Nothing to do here.
"""
cores = self.dut.get_core_list("all")
self.coremask = utils.create_mask(cores)
def launch_vhost_sample(self):
#
# Launch the vhost sample with different parameters
#
self.coremask = utils.create_mask(self.cores)
self.vhostapp_testcmd = self.vhost_test % (
self.coremask, self.memory_channel, self.jumbo, self.zero_copy,
self.vm2vm)
# Clean and prepare the vhost cuse modules
self.dut.send_expect("rm -rf /dev/vhost-net", "#", 20)
self.dut.send_expect("modprobe fuse", "#", 20)
self.dut.send_expect("modprobe cuse", "#", 20)
self.dut.send_expect("rmmod eventfd_link", "#", 20)
self.dut.send_expect(
"insmod lib/librte_vhost/eventfd_link/eventfd_link.ko", "#", 20)
self.dut.send_expect(self.vhostapp_testcmd, "# ", 40)
time.sleep(30)
try:
print "Launch vhost sample:"
self.dut.session.copy_file_from("/root/dpdk/vhost.out")
fp = open('./vhost.out', 'r')
out = fp.read()
fp.close()
if "Error" in out:
raise Exception("Launch vhost sample failed")
else:
print "Launch vhost sample finished"
except Exception as e:
print utils.RED("Failed to launch vhost sample: %s" % str(e))
def set_up_all(self):
self.dut_ports = self.dut.get_ports(self.nic)
self.verify(len(self.dut_ports) >= 1, "Insufficient ports")
self.vm0 = None
self.env_done = False
self.port = self.dut_ports[0]
self.vm_port = 0
cores = self.dut.get_core_list("1S/1C/1T")
self.port_mask = utils.create_mask([self.port])
# set vf assign method and vf driver
self.dut.send_expect('modprobe vfio-pci', '#')
self.vf_driver = self.get_suite_cfg()['vf_driver']
if self.vf_driver is None:
self.vf_driver = 'pci-stub'
self.verify(self.vf_driver in self.supported_vf_driver,
"Unspported vf driver")
if self.vf_driver == 'pci-stub':
self.vf_assign_method = 'pci-assign'
else:
self.vf_assign_method = 'vfio-pci'
self.dut.send_expect('modprobe vfio-pci', '#')
# enable tester mtu
tester_port = self.tester.get_local_port(self.port)
self.netobj = self.tester.ports_info[tester_port]['port']
self.netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU + 100)
def set_up_all(self):
"""
Run at the start of each test suite.
"""
self.dut_ports = self.dut.get_ports(self.nic)
self.verify(len(self.dut_ports) >= 2, "Insufficient ports")
cores = self.dut.get_core_list("1S/4C/1T")
self.coremask = utils.create_mask(cores)
self.portmask = utils.create_mask(self.dut_ports)
self.path = "./examples/link_status_interrupt/build/link_status_interrupt"
# build sample app
out = self.dut.build_dpdk_apps("./examples/link_status_interrupt")
self.verify("Error" not in out, "compilation error 1")
self.verify("No such file" not in out, "compilation error 2")
def test_all_cores_coremask(self):
"""
Check coremask parsing for all the cores at once.
"""
available_max_lcore = self.get_available_max_lcore()
core_mask = utils.create_mask(self.all_cores[:available_max_lcore - 1])
first_core = self.all_cores[0]
command = command_line % (self.target, core_mask, self.mem_channel)
out = self.dut.send_expect(command, "RTE>>", 10)
self.verify("EAL: Master lcore %s is ready" % first_core in out,
"Core %s not ready" % first_core)
self.verify("EAL: Detected lcore %s as core" % first_core in out,
"Core %s not detected" % first_core)
for core in self.all_cores[1:available_max_lcore - 1]:
self.verify("EAL: lcore %s is ready" % core in out,
"Core %s not ready" % core)
self.verify("EAL: Detected lcore %s as core" % core in out,
"Core %s not detected" % core)
self.dut.send_expect("quit", "# ", 10)
def test_timer_callbacks_verify(self):
"""
Timer callbacks running on targeted cores
"""
# get the mask for the first core
cores = self.dut.get_core_list('1S/1C/1T')
coreMask = utils.create_mask(cores)
# run timer on the background
cmdline = "./examples/timer/build/app/timer -n 1 -c " + coreMask + " &"
self.dut.send_expect(cmdline, "# ", 1)
time.sleep(15)
out = self.dut.get_session_output()
self.dut.send_expect("killall timer", "# ", 5)
# verify timer0
utils.regexp(out, r'timer0_cb\(\) on lcore (\d+)')
pat = re.compile(r'timer0_cb\(\) on lcore (\d+)')
match = pat.findall(out)
self.verify(match or match[0] == 0, "timer0 error")
# verify timer1
pat = re.compile(r'timer1_cb\(\) on lcore (\d+)')
matchlist = sorted(pat.findall(out))
self.verify(cmp(list(set(matchlist)), cores) == 0, "timer1 error")
def notest_port_testing(self):
"""
Check port forwarding.
"""
# the cases use the first two ports
print("***set port_mask")
port_mask = utils.create_mask([self.dut_ports[0], self.dut_ports[1]])
print("***port_mask", port_mask)
self.dut.send_expect(
"./examples/l2fwd/build/app/l2fwd -n 1 -c f -- -q 8 -p %s &" %
port_mask, "L2FWD: entering main loop", 60)
for i in [0, 1]:
tx_port = self.tester.get_local_port(self.dut_ports[i])
rx_port = self.tester.get_local_port(self.dut_ports[1 - i])
tx_interface = self.tester.get_interface(tx_port)
rx_interface = self.tester.get_interface(rx_port)
self.tester.scapy_background()
self.tester.scapy_append('p = sniff(iface="%s", count=1)' %
rx_interface)
self.tester.scapy_append('number_packets=len(p)')
self.tester.scapy_append('RESULT = str(number_packets)')
self.tester.scapy_foreground()
self.tester.scapy_append(
'sendp([Ether()/IP()/UDP()/("X"*46)], iface="%s")' %
tx_interface)
self.tester.scapy_execute()
number_packets = self.tester.scapy_get_result()
self.verify(number_packets == "1", "Failed to switch L2 frame")
self.quit_l2fwd()
