class TestPmd(TestCase):
def plot_results(self, number_ports):
cores_configs = []
percent_values = []
# Append the percentage results for the all the cores configs
for test_cycle in self.test_cycles:
cores_configs.append(test_cycle['cores'])
config_results = []
for frame_size in self.frame_sizes:
config_results.append(test_cycle['pct'][frame_size])
percent_values.append(config_results)
image_path = self.plotting.create_bars_plot(
'test_perf_pmd_%sports' % number_ports,
'PMD, %d ports' % number_ports,
self.frame_sizes,
percent_values,
ylabel='% linerate',
legend=cores_configs)
dts.results_plot_print(image_path)
def set_up_all(self):
"""
Run at the start of each test suite.
PMD prerequisites.
"""
self.frame_sizes = [64, 65, 128, 256, 512, 1024, 1280, 1518]
self.rxfreet_values = [0, 8, 16, 32, 64, 128]
self.test_cycles = [{
'cores': '1S/1C/1T',
'Mpps': {},
'pct': {}
}, {
'cores': '1S/1C/2T',
'Mpps': {},
'pct': {}
}, {
'cores': '1S/2C/1T',
'Mpps': {},
'pct': {}
}, {
'cores': '1S/2C/2T',
'Mpps': {},
'pct': {}
}, {
'cores': '1S/4C/2T',
'Mpps': {},
'pct': {}
}]
self.table_header = ['Frame Size']
for test_cycle in self.test_cycles:
self.table_header.append("%s Mpps" % test_cycle['cores'])
self.table_header.append("% linerate")
self.blacklist = ""
# Based on h/w type, choose how many ports to use
self.dut_ports = self.dut.get_ports()
self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE[
'ip'] + HEADER_SIZE['udp']
self.ports_socket = self.dut.get_numa_id(self.dut_ports[0])
self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic)
self.pmdout = PmdOutput(self.dut)
def set_up(self):
"""
Run before each test case.
"""
pass
def test_perf_pmd_performance_4ports(self):
"""
PMD Performance Benchmarking with 4 ports.
"""
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
# prepare traffic generator input
self.verify(
len(self.dut_ports) >= 4,
"Insufficient ports for 4 ports performance")
tgen_input = []
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[0]),
self.tester.get_local_port(self.dut_ports[1]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[2]),
self.tester.get_local_port(self.dut_ports[3]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[1]),
self.tester.get_local_port(self.dut_ports[0]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[3]),
self.tester.get_local_port(self.dut_ports[2]), "test.pcap"))
# run testpmd for each core config
for test_cycle in self.test_cycles:
core_config = test_cycle['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
if len(core_list) > 4:
queues = len(core_list) / 4
else:
queues = 1
core_mask = dts.create_mask(core_list)
port_mask = dts.create_mask(self.dut.get_ports())
self.pmdout.start_testpmd(
"all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" %
(core_mask, queues, queues, port_mask))
info = "Executing PMD (mac fwd) using %s\n" % test_cycle['cores']
dts.report(info, annex=True)
self.logger.info(info)
dts.report(commandLine + "\n\n", frame=True, annex=True)
# self.dut.send_expect("set fwd mac", "testpmd> ", 100)
self.dut.send_expect("start", "testpmd> ")
for frame_size in self.frame_sizes:
wirespeed = self.wirespeed(self.nic, frame_size, 4)
# create pcap file
self.logger.info("Running with frame size %d " % frame_size)
payload_size = frame_size - self.headers_size
self.tester.scapy_append(
'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP()/UDP()/("X"*%d)])'
% payload_size)
self.tester.scapy_execute()
# run traffic generator
_, pps = self.tester.traffic_generator_throughput(tgen_input)
pps /= 1000000.0
test_cycle['Mpps'][frame_size] = pps
test_cycle['pct'][frame_size] = pps * 100 / wirespeed
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
for n in range(len(self.test_cycles)):
for frame_size in self.frame_sizes:
self.verify(self.test_cycles[n]['Mpps'][frame_size] is not 0,
"No traffic detected")
# Print results
dts.results_table_add_header(self.table_header)
for frame_size in self.frame_sizes:
table_row = [frame_size]
for test_cycle in self.test_cycles:
table_row.append(test_cycle['Mpps'][frame_size])
table_row.append(test_cycle['pct'][frame_size])
dts.results_table_add_row(table_row)
self.plot_results(number_ports=4)
dts.results_table_print()
def test_perf_pmd_performance_2ports(self):
"""
PMD Performance Benchmarking with 2 ports.
"""
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
# prepare traffic generator input
tgen_input = []
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[0]),
self.tester.get_local_port(self.dut_ports[1]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[1]),
self.tester.get_local_port(self.dut_ports[0]), "test.pcap"))
# run testpmd for each core config
for test_cycle in self.test_cycles:
core_config = test_cycle['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
if len(core_list) > 2:
queues = len(core_list) / 2
else:
queues = 1
core_mask = dts.create_mask(core_list)
port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]])
self.pmdout.start_testpmd(
"all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" %
(core_mask, queues, queues, port_mask))
command_line = self.pmdout.get_pmd_cmd()
info = "Executing PMD using %s\n" % test_cycle['cores']
self.logger.info(info)
dts.report(info, annex=True)
dts.report(command_line + "\n\n", frame=True, annex=True)
self.dut.send_expect("start", "testpmd> ")
for frame_size in self.frame_sizes:
wirespeed = self.wirespeed(self.nic, frame_size, 2)
# create pcap file
self.logger.info("Running with frame size %d " % frame_size)
payload_size = frame_size - self.headers_size
self.tester.scapy_append(
'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP()/UDP()/("X"*%d)])'
% payload_size)
self.tester.scapy_execute()
# run traffic generator
_, pps = self.tester.traffic_generator_throughput(tgen_input)
pps /= 1000000.0
test_cycle['Mpps'][frame_size] = pps
test_cycle['pct'][frame_size] = pps * 100 / wirespeed
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
for n in range(len(self.test_cycles)):
for frame_size in self.frame_sizes:
self.verify(self.test_cycles[n]['Mpps'][frame_size] > 0,
"No traffic detected")
# Print results
dts.results_table_add_header(self.table_header)
for frame_size in self.frame_sizes:
table_row = [frame_size]
for test_cycle in self.test_cycles:
table_row.append(test_cycle['Mpps'][frame_size])
table_row.append(test_cycle['pct'][frame_size])
dts.results_table_add_row(table_row)
self.plot_results(number_ports=2)
dts.results_table_print()
def test_checksum_checking(self):
"""
Packet forwarding checking test
"""
self.dut.kill_all()
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
core_mask = dts.create_mask(
self.dut.get_core_list('1S/1C/1T', socket=self.ports_socket))
port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]])
for rxfreet_value in self.rxfreet_values:
self.pmdout.start_testpmd(
"all",
"--coremask=%s --portmask=%s --nb-cores=2 --enable-rx-cksum --disable-hw-vlan --disable-rss --crc-strip --rxd=1024 --txd=1024 --rxfreet=%d"
% (core_mask, port_mask, rxfreet_value))
self.dut.send_expect("set fwd csum", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
self.send_packet(self.frame_sizes[0], checksum_test=True)
l4csum_error = self.stop_and_get_l4csum_errors()
# Check the l4 checksum errors reported for Rx port
self.verify(
1 == int(l4csum_error[1]),
"Wrong l4 checksum error count using rxfreet=%d (expected 1, reported %s)"
% (rxfreet_value, l4csum_error[1]))
self.dut.send_expect("quit", "# ", 30)
sleep(5)
def test_packet_checking(self):
"""
Packet forwarding checking test
"""
self.dut.kill_all()
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
core_mask = dts.create_mask(
self.dut.get_core_list('1S/1C/1T', socket=self.ports_socket))
port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]])
self.pmdout.start_testpmd(
"all", "--coremask=%s --portmask=%s" % (core_mask, port_mask))
self.dut.send_expect("start", "testpmd> ")
for size in self.frame_sizes:
self.send_packet(size)
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
def stop_and_get_l4csum_errors(self):
"""
Stop forwarding and get Bad-l4csum number from stop statistic
"""
out = self.dut.send_expect("stop", "testpmd> ")
result_scanner = r"Bad-l4csum: ([0-9]+) \s*"
scanner = re.compile(result_scanner, re.DOTALL)
m = scanner.findall(out)
return m
def get_stats(self, portid):
"""
Get packets number from port statistic
"""
stats = self.pmdout.get_pmd_stats(portid)
return stats
def send_packet(self, frame_size, checksum_test=False):
"""
Send 1 packet to portid
"""
port0_stats = self.get_stats(self.dut_ports[0])
gp0tx_pkts, gp0tx_bytes = [
port0_stats['TX-packets'], port0_stats['TX-bytes']
]
port1_stats = self.get_stats(self.dut_ports[1])
gp1rx_pkts, gp1rx_err, gp1rx_bytes = [
port1_stats['RX-packets'], port1_stats['RX-errors'],
port1_stats['RX-bytes']
]
interface = self.tester.get_interface(
self.tester.get_local_port(self.dut_ports[1]))
mac = self.dut.get_mac_address(self.dut_ports[1])
load_size = frame_size - HEADER_SIZE['eth']
padding = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] - \
HEADER_SIZE['udp']
checksum = ''
if checksum_test:
checksum = 'chksum=0x0'
self.tester.scapy_foreground()
self.tester.scapy_append('nutmac="%s"' % mac)
self.tester.scapy_append(
'sendp([Ether(dst=nutmac, src="52:00:00:00:00:00")/IP(len=%s)/UDP(%s)/Raw(load="\x50"*%s)], iface="%s")'
% (load_size, checksum, padding, interface))
out = self.tester.scapy_execute()
time.sleep(.5)
port0_stats = self.get_stats(self.dut_ports[0])
p0tx_pkts, p0tx_bytes = [
port0_stats['TX-packets'], port0_stats['TX-bytes']
]
port1_stats = self.get_stats(self.dut_ports[1])
p1rx_pkts, p1rx_err, p1rx_bytes = [
port1_stats['RX-packets'], port1_stats['RX-errors'],
port1_stats['RX-bytes']
]
p0tx_pkts -= gp0tx_pkts
p0tx_bytes -= gp0tx_bytes
p1rx_pkts -= gp1rx_pkts
p1rx_bytes -= gp1rx_bytes
p1rx_err -= gp1rx_err
time.sleep(5)
self.verify(
p0tx_pkts == p1rx_pkts,
"packet pass assert error, %d RX packets, %d TX packets" %
(p1rx_pkts, p0tx_pkts))
if checksum_test:
self.verify(
p1rx_bytes == frame_size - 4,
"packet pass assert error, expected %d RX bytes, actual %d" %
(frame_size - 4, p1rx_bytes))
else:
self.verify(
p1rx_bytes == frame_size,
"packet pass assert error, expected %d RX bytes, actual %d" %
(frame_size, p1rx_bytes))
self.verify(
p0tx_bytes == frame_size,
"packet pass assert error, expected %d TX bytes, actual %d" %
(frame_size, p0tx_bytes))
return out
def tear_down(self):
"""
Run after each test case.
"""
pass
def tear_down_all(self):
"""
Run after each test suite.
"""
self.dut.kill_all()
class TestPmd(TestCase, IxiaPacketGenerator):
def set_up_all(self):
"""
Run at the start of each test suite.
PMD prerequisites.
"""
self.tester.extend_external_packet_generator(TestPmd, self)
self.frame_sizes = [64, 72, 128, 256, 512, 1024, 1280, 1518]
self.rxfreet_values = [0, 8, 16, 32, 64, 128]
self.test_cycles = [{'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {}}]
self.table_header = ['Frame Size']
for test_cycle in self.test_cycles:
self.table_header.append("%s Mpps" % test_cycle['cores'])
self.table_header.append("% linerate")
self.perf_results = {'header': [], 'data': []}
self.blacklist = ""
# Update config file and rebuild to get best perf on FVL
self.dut.send_expect(
"sed -i -e 's/CONFIG_RTE_LIBRTE_I40E_16BYTE_RX_DESC=n/CONFIG_RTE_LIBRTE_I40E_16BYTE_RX_DESC=y/' ./config/common_base",
"#", 20)
self.dut.build_install_dpdk(self.target)
# Based on h/w type, choose how many ports to use
self.dut_ports = self.dut.get_ports()
if self.dut.get_os_type() == 'linux':
# Get dut system information
port_num = self.dut_ports[0]
pci_device_id = self.dut.ports_info[port_num]['pci']
ori_driver = self.dut.ports_info[port_num]['port'].get_nic_driver()
self.dut.ports_info[port_num]['port'].bind_driver()
sut = SystemInfo(self.dut, pci_device_id)
self.system_info = sut.get_system_info()
self.nic_info = sut.get_nic_info()
self.dut.ports_info[port_num]['port'].bind_driver(ori_driver)
######
self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE[
'ip'] + HEADER_SIZE['tcp']
self.ports_socket = self.dut.get_numa_id(self.dut_ports[0])
self.pmdout = PmdOutput(self.dut)
def set_up(self):
"""
Run before each test case.
"""
pass
def test_perf_single_core_performance(self):
"""
Run single core performance
"""
self.perf_results['header'] = []
self.perf_results['data'] = []
if len(self.dut_ports) >= 4:
self.pmd_performance_4ports()
else:
self.verify(
len(self.dut_ports) >= 2,
"Insufficient ports for 2 ports performance test")
self.pmd_performance_2ports()
#To replace False to True for if condition to send the result by email.
if False:
#it need place dpdk source git repo under dep directory.
repo_dir = FOLDERS["Depends"] + r'/dpdk'
git_info = perf_report.get_dpdk_git_info(repo_dir)
self.verify(git_info is not None, "get dpdk git repo error")
tpl_path = FOLDERS["NicDriver"] + r'/perf_report.jinja'
file_tpl = os.path.abspath(tpl_path)
html_msg = perf_report.generate_html_report(file_tpl, \
perf_data = self.perf_results['data'], \
git_info = git_info, \
nic_info = self.nic_info, \
system_info = self.system_info)
self.verify(html_msg is not None, "generate html report error")
subject = "Single core performance test with %d ports %s -- %s" % \
(len(self.dut_ports), self.nic, datetime.now().strftime('%Y-%m-%d %H:%M'))
sender = '*****@*****.**'
mailto = ['*****@*****.**']
smtp_server = 'smtp.intel.com'
perf_report.send_html_report(sender, mailto, subject, html_msg,
smtp_server)
def pmd_performance_4ports(self):
"""
PMD Performance Benchmarking with 4 ports.
"""
all_cores_mask = utils.create_mask(self.dut.get_core_list("all"))
# prepare traffic generator input
tgen_input = []
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[0]),
self.tester.get_local_port(self.dut_ports[1]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[2]),
self.tester.get_local_port(self.dut_ports[3]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[1]),
self.tester.get_local_port(self.dut_ports[0]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[3]),
self.tester.get_local_port(self.dut_ports[2]), "test.pcap"))
# run testpmd for each core config
for test_cycle in self.test_cycles:
core_config = test_cycle['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
if len(core_list) > 4:
queues = len(core_list) / 4
else:
queues = 1
core_mask = utils.create_mask(core_list)
port_mask = utils.create_mask(self.dut.get_ports())
self.pmdout.start_testpmd(
core_config,
" --rxq=%d --txq=%d --portmask=%s --rss-ip --txrst=32 --txfreet=32 --txd=128 --tx-offloads=0"
% (queues, queues, port_mask),
socket=self.ports_socket)
command_line = self.pmdout.get_pmd_cmd()
info = "Executing PMD using %s\n" % test_cycle['cores']
self.rst_report(info, annex=True)
self.logger.info(info)
self.rst_report(command_line + "\n\n", frame=True, annex=True)
# self.dut.send_expect("set fwd mac", "testpmd> ", 100)
self.dut.send_expect("start", "testpmd> ", 100)
for frame_size in self.frame_sizes:
wirespeed = self.wirespeed(self.nic, frame_size, 4)
# create pcap file
self.logger.info("Running with frame size %d " % frame_size)
payload_size = frame_size - self.headers_size
self.tester.scapy_append(
'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP(src="1.2.3.4",dst="1.1.1.1")/TCP()/("X"*%d)])'
% payload_size)
self.tester.scapy_execute()
# run traffic generator
_, pps = self.tester.traffic_generator_throughput(
tgen_input, rate_percent=100, delay=60)
pps /= 1000000.0
pct = pps * 100 / wirespeed
test_cycle['Mpps'][frame_size] = float('%.3f' % pps)
test_cycle['pct'][frame_size] = float('%.3f' % pct)
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
for n in range(len(self.test_cycles)):
for frame_size in self.frame_sizes:
self.verify(self.test_cycles[n]['Mpps'][frame_size] is not 0,
"No traffic detected")
# Print results
self.result_table_create(self.table_header)
self.perf_results['header'] = self.table_header
for frame_size in self.frame_sizes:
table_row = [frame_size]
for test_cycle in self.test_cycles:
table_row.append(test_cycle['Mpps'][frame_size])
table_row.append(test_cycle['pct'][frame_size])
self.result_table_add(table_row)
self.perf_results['data'].append(table_row)
self.result_table_print()
def pmd_performance_2ports(self):
"""
PMD Performance Benchmarking with 2 ports.
"""
all_cores_mask = utils.create_mask(self.dut.get_core_list("all"))
# prepare traffic generator input
tgen_input = []
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[0]),
self.tester.get_local_port(self.dut_ports[1]), "test.pcap"))
tgen_input.append(
(self.tester.get_local_port(self.dut_ports[1]),
self.tester.get_local_port(self.dut_ports[0]), "test.pcap"))
# run testpmd for each core config
for test_cycle in self.test_cycles:
core_config = test_cycle['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
if len(core_list) > 2:
queues = len(core_list) / 2
else:
queues = 1
core_mask = utils.create_mask(core_list)
port_mask = utils.create_mask(
[self.dut_ports[0], self.dut_ports[1]])
#self.pmdout.start_testpmd("all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" % (core_mask, queues, queues, port_mask))
self.pmdout.start_testpmd(
core_config,
" --rxq=%d --txq=%d --portmask=%s --rss-ip --txrst=32 --txfreet=32 --txd=128"
% (queues, queues, port_mask),
socket=self.ports_socket)
command_line = self.pmdout.get_pmd_cmd()
info = "Executing PMD using %s\n" % test_cycle['cores']
self.logger.info(info)
self.rst_report(info, annex=True)
self.rst_report(command_line + "\n\n", frame=True, annex=True)
self.dut.send_expect("start", "testpmd> ", 100)
for frame_size in self.frame_sizes:
wirespeed = self.wirespeed(self.nic, frame_size, 2)
# create pcap file
self.logger.info("Running with frame size %d " % frame_size)
payload_size = frame_size - self.headers_size
self.tester.scapy_append(
'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP(src="1.2.3.4",dst="1.1.1.1")/TCP()/("X"*%d)])'
% payload_size)
self.tester.scapy_execute()
# run traffic generator
_, pps = self.tester.traffic_generator_throughput(
tgen_input, rate_percent=100, delay=60)
pps /= 1000000.0
pct = pps * 100 / wirespeed
test_cycle['Mpps'][frame_size] = float('%.3f' % pps)
test_cycle['pct'][frame_size] = float('%.3f' % pct)
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
for n in range(len(self.test_cycles)):
for frame_size in self.frame_sizes:
self.verify(self.test_cycles[n]['Mpps'][frame_size] > 0,
"No traffic detected")
# Print results
self.result_table_create(self.table_header)
self.perf_results['header'] = self.table_header
for frame_size in self.frame_sizes:
table_row = [frame_size]
for test_cycle in self.test_cycles:
table_row.append(test_cycle['Mpps'][frame_size])
table_row.append(test_cycle['pct'][frame_size])
self.result_table_add(table_row)
self.perf_results['data'].append(table_row)
self.result_table_print()
def test_checksum_checking(self):
"""
Packet forwarding checking test
"""
self.dut.kill_all()
port_mask = utils.create_mask([self.dut_ports[0], self.dut_ports[1]])
for rxfreet_value in self.rxfreet_values:
self.pmdout.start_testpmd(
"1S/2C/1T",
"--portmask=%s --enable-rx-cksum --disable-rss --rxd=1024 --txd=1024 --rxfreet=%d"
% (port_mask, rxfreet_value),
socket=self.ports_socket)
self.dut.send_expect("set fwd csum", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
self.send_packet(self.frame_sizes[0], checksum_test=True)
l4csum_error = self.stop_and_get_l4csum_errors()
# Check the l4 checksum errors reported for Rx port
self.verify(
1 == int(l4csum_error[1]),
"Wrong l4 checksum error count using rxfreet=%d (expected 1, reported %s)"
% (rxfreet_value, l4csum_error[1]))
self.dut.send_expect("quit", "# ", 30)
sleep(5)
def test_packet_checking(self):
"""
Packet forwarding checking test
"""
self.dut.kill_all()
port_mask = utils.create_mask([self.dut_ports[0], self.dut_ports[1]])
self.pmdout.start_testpmd("1S/2C/1T",
"--portmask=%s" % port_mask,
socket=self.ports_socket)
self.dut.send_expect("start", "testpmd> ")
for size in self.frame_sizes:
self.send_packet(size)
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
def stop_and_get_l4csum_errors(self):
"""
Stop forwarding and get Bad-l4csum number from stop statistic
"""
out = self.dut.send_expect("stop", "testpmd> ")
result_scanner = r"Bad-l4csum: ([0-9]+) \s*"
scanner = re.compile(result_scanner, re.DOTALL)
m = scanner.findall(out)
return m
def get_stats(self, portid):
"""
Get packets number from port statistic
"""
stats = self.pmdout.get_pmd_stats(portid)
return stats
def send_packet(self, frame_size, checksum_test=False):
"""
Send 1 packet to portid
"""
port0_stats = self.get_stats(self.dut_ports[0])
gp0tx_pkts, gp0tx_bytes = [
port0_stats['TX-packets'], port0_stats['TX-bytes']
]
port1_stats = self.get_stats(self.dut_ports[1])
gp1rx_pkts, gp1rx_err, gp1rx_bytes = [
port1_stats['RX-packets'], port1_stats['RX-errors'],
port1_stats['RX-bytes']
]
interface = self.tester.get_interface(
self.tester.get_local_port(self.dut_ports[1]))
mac = self.dut.get_mac_address(self.dut_ports[1])
load_size = frame_size - HEADER_SIZE['eth']
padding = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] - \
HEADER_SIZE['udp']
checksum = ''
if checksum_test:
checksum = 'chksum=0x1'
self.tester.scapy_foreground()
self.tester.scapy_append('nutmac="%s"' % mac)
self.tester.scapy_append(
'sendp([Ether(dst=nutmac, src="52:00:00:00:00:00")/IP(len=%s)/UDP(%s)/Raw(load="\x50"*%s)], iface="%s")'
% (load_size, checksum, padding, interface))
out = self.tester.scapy_execute()
time.sleep(.5)
port0_stats = self.get_stats(self.dut_ports[0])
p0tx_pkts, p0tx_bytes = [
port0_stats['TX-packets'], port0_stats['TX-bytes']
]
port1_stats = self.get_stats(self.dut_ports[1])
p1rx_pkts, p1rx_err, p1rx_bytes = [
port1_stats['RX-packets'], port1_stats['RX-errors'],
port1_stats['RX-bytes']
]
p0tx_pkts -= gp0tx_pkts
p0tx_bytes -= gp0tx_bytes
p1rx_pkts -= gp1rx_pkts
p1rx_bytes -= gp1rx_bytes
p1rx_err -= gp1rx_err
time.sleep(5)
self.verify(
self.pmdout.check_tx_bytes(p0tx_pkts, p1rx_pkts),
"packet pass assert error, %d RX packets, %d TX packets" %
(p1rx_pkts, p0tx_pkts))
self.verify(
p1rx_bytes == frame_size - 4,
"packet pass assert error, expected %d RX bytes, actual %d" %
(frame_size - 4, p1rx_bytes))
self.verify(
self.pmdout.check_tx_bytes(p0tx_bytes, frame_size - 4),
"packet pass assert error, expected %d TX bytes, actual %d" %
(frame_size - 4, p0tx_bytes))
return out
def ip(self, port, frag, src, proto, tos, dst, chksum, len, options,
version, flags, ihl, ttl, id):
self.add_tcl_cmd("protocol config -name ip")
self.add_tcl_cmd('ip config -sourceIpAddr "%s"' % src)
self.add_tcl_cmd("ip config -sourceIpAddrMode ipRandom")
self.add_tcl_cmd('ip config -destIpAddr "%s"' % dst)
self.add_tcl_cmd("ip config -destIpAddrMode ipIdle")
self.add_tcl_cmd("ip config -ttl %d" % ttl)
self.add_tcl_cmd("ip config -totalLength %d" % len)
self.add_tcl_cmd("ip config -fragment %d" % frag)
self.add_tcl_cmd("ip config -ipProtocol ipV4ProtocolReserved255")
self.add_tcl_cmd("ip config -identifier %d" % id)
self.add_tcl_cmd("stream config -framesize %d" % (len + 18))
self.add_tcl_cmd("ip set %d %d %d" %
(self.chasId, port['card'], port['port']))
def tear_down(self):
"""
Run after each test case.
"""
pass
def tear_down_all(self):
"""
Run after each test suite.
"""
self.dut.kill_all()
class TestPmd(TestCase):
def plot_results(self, number_ports):
cores_configs = []
percent_values = []
# Append the percentage results for the all the cores configs
for test_cycle in self.test_cycles:
cores_configs.append(test_cycle['cores'])
config_results = []
for frame_size in self.frame_sizes:
config_results.append(test_cycle['pct'][frame_size])
percent_values.append(config_results)
image_path = self.plotting.create_bars_plot(
'test_perf_pmd_%sports' % number_ports,
'PMD, %d ports' % number_ports,
self.frame_sizes,
percent_values,
ylabel='% linerate',
legend=cores_configs)
dts.results_plot_print(image_path)
def set_up_all(self):
"""
Run at the start of each test suite.
PMD prerequisites.
"""
self.frame_sizes = [64, 65, 128, 256, 512, 1024, 1280, 1518]
self.rxfreet_values = [0, 8, 16, 32, 64, 128]
self.test_cycles = [{'cores': '1S/1C/1T', 'Mpps': {}, 'pct': {}},
{'cores': '1S/1C/2T', 'Mpps': {}, 'pct': {}},
{'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {}},
{'cores': '1S/2C/2T', 'Mpps': {}, 'pct': {}},
{'cores': '1S/4C/2T', 'Mpps': {}, 'pct': {}}
]
self.table_header = ['Frame Size']
for test_cycle in self.test_cycles:
self.table_header.append("%s Mpps" % test_cycle['cores'])
self.table_header.append("% linerate")
self.blacklist = ""
# Based on h/w type, choose how many ports to use
self.dut_ports = self.dut.get_ports()
self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE[
'ip'] + HEADER_SIZE['udp']
self.ports_socket = self.dut.get_numa_id(self.dut_ports[0])
self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic)
self.pmdout = PmdOutput(self.dut)
def set_up(self):
"""
Run before each test case.
"""
pass
def test_perf_pmd_performance_4ports(self):
"""
PMD Performance Benchmarking with 4 ports.
"""
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
# prepare traffic generator input
self.verify(len(self.dut_ports) >= 4,
"Insufficient ports for 4 ports performance")
tgen_input = []
tgen_input.append((self.tester.get_local_port(self.dut_ports[0]),
self.tester.get_local_port(self.dut_ports[1]),
"test.pcap"))
tgen_input.append((self.tester.get_local_port(self.dut_ports[2]),
self.tester.get_local_port(self.dut_ports[3]),
"test.pcap"))
tgen_input.append((self.tester.get_local_port(self.dut_ports[1]),
self.tester.get_local_port(self.dut_ports[0]),
"test.pcap"))
tgen_input.append((self.tester.get_local_port(self.dut_ports[3]),
self.tester.get_local_port(self.dut_ports[2]),
"test.pcap"))
# run testpmd for each core config
for test_cycle in self.test_cycles:
core_config = test_cycle['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
if len(core_list) > 4:
queues = len(core_list) / 4
else:
queues = 1
core_mask = dts.create_mask(core_list)
port_mask = dts.create_mask(self.dut.get_ports())
self.pmdout.start_testpmd("all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" % (core_mask, queues, queues, port_mask))
info = "Executing PMD (mac fwd) using %s\n" % test_cycle['cores']
dts.report(info, annex=True)
self.logger.info(info)
dts.report(commandLine + "\n\n", frame=True, annex=True)
# self.dut.send_expect("set fwd mac", "testpmd> ", 100)
self.dut.send_expect("start", "testpmd> ")
for frame_size in self.frame_sizes:
wirespeed = self.wirespeed(self.nic, frame_size, 4)
# create pcap file
self.logger.info("Running with frame size %d " % frame_size)
payload_size = frame_size - self.headers_size
self.tester.scapy_append(
'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP()/UDP()/("X"*%d)])' % payload_size)
self.tester.scapy_execute()
# run traffic generator
_, pps = self.tester.traffic_generator_throughput(tgen_input)
pps /= 1000000.0
test_cycle['Mpps'][frame_size] = pps
test_cycle['pct'][frame_size] = pps * 100 / wirespeed
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
for n in range(len(self.test_cycles)):
for frame_size in self.frame_sizes:
self.verify(self.test_cycles[n]['Mpps'][
frame_size] is not 0, "No traffic detected")
# Print results
dts.results_table_add_header(self.table_header)
for frame_size in self.frame_sizes:
table_row = [frame_size]
for test_cycle in self.test_cycles:
table_row.append(test_cycle['Mpps'][frame_size])
table_row.append(test_cycle['pct'][frame_size])
dts.results_table_add_row(table_row)
self.plot_results(number_ports=4)
dts.results_table_print()
def test_perf_pmd_performance_2ports(self):
"""
PMD Performance Benchmarking with 2 ports.
"""
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
# prepare traffic generator input
tgen_input = []
tgen_input.append((self.tester.get_local_port(self.dut_ports[0]),
self.tester.get_local_port(self.dut_ports[1]),
"test.pcap"))
tgen_input.append((self.tester.get_local_port(self.dut_ports[1]),
self.tester.get_local_port(self.dut_ports[0]),
"test.pcap"))
# run testpmd for each core config
for test_cycle in self.test_cycles:
core_config = test_cycle['cores']
core_list = self.dut.get_core_list(core_config,
socket=self.ports_socket)
if len(core_list) > 2:
queues = len(core_list) / 2
else:
queues = 1
core_mask = dts.create_mask(core_list)
port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]])
self.pmdout.start_testpmd("all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" % (core_mask, queues, queues, port_mask))
command_line = self.pmdout.get_pmd_cmd()
info = "Executing PMD using %s\n" % test_cycle['cores']
self.logger.info(info)
dts.report(info, annex=True)
dts.report(command_line + "\n\n", frame=True, annex=True)
self.dut.send_expect("start", "testpmd> ")
for frame_size in self.frame_sizes:
wirespeed = self.wirespeed(self.nic, frame_size, 2)
# create pcap file
self.logger.info("Running with frame size %d " % frame_size)
payload_size = frame_size - self.headers_size
self.tester.scapy_append(
'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP()/UDP()/("X"*%d)])' % payload_size)
self.tester.scapy_execute()
# run traffic generator
_, pps = self.tester.traffic_generator_throughput(tgen_input)
pps /= 1000000.0
test_cycle['Mpps'][frame_size] = pps
test_cycle['pct'][frame_size] = pps * 100 / wirespeed
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
for n in range(len(self.test_cycles)):
for frame_size in self.frame_sizes:
self.verify(self.test_cycles[n]['Mpps'][
frame_size] > 0, "No traffic detected")
# Print results
dts.results_table_add_header(self.table_header)
for frame_size in self.frame_sizes:
table_row = [frame_size]
for test_cycle in self.test_cycles:
table_row.append(test_cycle['Mpps'][frame_size])
table_row.append(test_cycle['pct'][frame_size])
dts.results_table_add_row(table_row)
self.plot_results(number_ports=2)
dts.results_table_print()
def test_checksum_checking(self):
"""
Packet forwarding checking test
"""
self.dut.kill_all()
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
core_mask = dts.create_mask(self.dut.get_core_list('1S/1C/1T',
socket=self.ports_socket))
port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]])
for rxfreet_value in self.rxfreet_values:
self.pmdout.start_testpmd("all", "--coremask=%s --portmask=%s --nb-cores=2 --enable-rx-cksum --disable-hw-vlan --disable-rss --crc-strip --rxd=1024 --txd=1024 --rxfreet=%d" % (core_mask, port_mask, rxfreet_value))
self.dut.send_expect("set fwd csum", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
self.send_packet(self.frame_sizes[0], checksum_test=True)
l4csum_error = self.stop_and_get_l4csum_errors()
# Check the l4 checksum errors reported for Rx port
self.verify(1 == int(l4csum_error[1]),
"Wrong l4 checksum error count using rxfreet=%d (expected 1, reported %s)" %
(rxfreet_value, l4csum_error[1]))
self.dut.send_expect("quit", "# ", 30)
sleep(5)
def test_packet_checking(self):
"""
Packet forwarding checking test
"""
self.dut.kill_all()
all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
core_mask = dts.create_mask(self.dut.get_core_list('1S/1C/1T',
socket=self.ports_socket))
port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]])
self.pmdout.start_testpmd("all", "--coremask=%s --portmask=%s" % (core_mask, port_mask))
self.dut.send_expect("start", "testpmd> ")
for size in self.frame_sizes:
self.send_packet(size)
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
sleep(5)
def stop_and_get_l4csum_errors(self):
"""
Stop forwarding and get Bad-l4csum number from stop statistic
"""
out = self.dut.send_expect("stop", "testpmd> ")
result_scanner = r"Bad-l4csum: ([0-9]+) \s*"
scanner = re.compile(result_scanner, re.DOTALL)
m = scanner.findall(out)
return m
def get_stats(self, portid):
"""
Get packets number from port statistic
"""
stats = self.pmdout.get_pmd_stats(portid)
return stats
def send_packet(self, frame_size, checksum_test=False):
"""
Send 1 packet to portid
"""
port0_stats = self.get_stats(self.dut_ports[0])
gp0tx_pkts, gp0tx_bytes = [port0_stats['TX-packets'], port0_stats['TX-bytes']]
port1_stats = self.get_stats(self.dut_ports[1])
gp1rx_pkts, gp1rx_err, gp1rx_bytes = [port1_stats['RX-packets'], port1_stats['RX-errors'], port1_stats['RX-bytes']]
interface = self.tester.get_interface(
self.tester.get_local_port(self.dut_ports[1]))
mac = self.dut.get_mac_address(self.dut_ports[1])
load_size = frame_size - HEADER_SIZE['eth']
padding = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] - \
HEADER_SIZE['udp']
checksum = ''
if checksum_test:
checksum = 'chksum=0x0'
self.tester.scapy_foreground()
self.tester.scapy_append('nutmac="%s"' % mac)
self.tester.scapy_append('sendp([Ether(dst=nutmac, src="52:00:00:00:00:00")/IP(len=%s)/UDP(%s)/Raw(load="\x50"*%s)], iface="%s")' % (
load_size, checksum, padding, interface))
out = self.tester.scapy_execute()
time.sleep(.5)
port0_stats = self.get_stats(self.dut_ports[0])
p0tx_pkts, p0tx_bytes = [port0_stats['TX-packets'], port0_stats['TX-bytes']]
port1_stats = self.get_stats(self.dut_ports[1])
p1rx_pkts, p1rx_err, p1rx_bytes = [port1_stats['RX-packets'], port1_stats['RX-errors'], port1_stats['RX-bytes']]
p0tx_pkts -= gp0tx_pkts
p0tx_bytes -= gp0tx_bytes
p1rx_pkts -= gp1rx_pkts
p1rx_bytes -= gp1rx_bytes
p1rx_err -= gp1rx_err
time.sleep(5)
self.verify(p0tx_pkts == p1rx_pkts,
"packet pass assert error, %d RX packets, %d TX packets" % (p1rx_pkts, p0tx_pkts))
if checksum_test:
self.verify(p1rx_bytes == frame_size - 4,
"packet pass assert error, expected %d RX bytes, actual %d" % (frame_size - 4, p1rx_bytes))
else:
self.verify(p1rx_bytes == frame_size,
"packet pass assert error, expected %d RX bytes, actual %d" % (frame_size, p1rx_bytes))
self.verify(p0tx_bytes == frame_size,
"packet pass assert error, expected %d TX bytes, actual %d" % (frame_size, p0tx_bytes))
return out
def tear_down(self):
"""
Run after each test case.
"""
pass
def tear_down_all(self):
"""
Run after each test suite.
"""
self.dut.kill_all()
