class TestShutdownApi(TestCase):
#
#
#
# Test cases.
#
def set_up_all(self):
"""
Run at the start of each test suite.
"""
ports = self.dut.get_ports()
self.verify(len(ports) >= 1, "Insufficient number of ports.")
self.ports = ports[:1]
self.ports_socket = self.dut.get_numa_id(self.ports[0])
for port in self.ports:
self.tester.send_expect(
"ifconfig %s mtu %s" % (self.tester.get_interface(
self.tester.get_local_port(port)), 5000), "# ")
self.pmdout = PmdOutput(self.dut)
def get_stats(self, portid):
"""
Get packets number from port statistic.
@param: stop -- stop forward before get stats
"""
output = PmdOutput(self.dut)
stats = output.get_pmd_stats(portid)
return stats
def check_forwarding(self,
ports=None,
pktSize=68,
received=True,
vlan=False,
promisc=False,
vlan_strip=False):
if ports is None:
ports = self.ports
if len(ports) == 1:
self.send_packet(ports[0], ports[0], pktSize, received, vlan,
promisc, vlan_strip)
return
def send_packet(self,
txPort,
rxPort,
pktSize=68,
received=True,
vlan=False,
promisc=False,
vlan_strip=False):
"""
Send packages according to parameters.
"""
port0_stats = self.get_stats(txPort)
gp0tx_pkts, gp0tx_bytes = [
port0_stats['TX-packets'], port0_stats['TX-bytes']
]
port1_stats = self.get_stats(rxPort)
gp1rx_pkts, gp1rx_err, gp1rx_bytes = [
port1_stats['RX-packets'], port1_stats['RX-errors'],
port1_stats['RX-bytes']
]
time.sleep(5)
itf = self.tester.get_interface(self.tester.get_local_port(rxPort))
smac = self.tester.get_mac(self.tester.get_local_port(rxPort))
dmac = self.dut.get_mac_address(rxPort)
# when promisc is true, destination mac should be fake
if promisc:
dmac = "00:00:00:00:00:01"
if vlan:
padding = pktSize - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] - 4
pkg = 'Ether(src="%s", dst="%s")/Dot1Q(vlan=1)/IP()/Raw(load="P" * %d)' % (
smac, dmac, padding)
else:
padding = pktSize - HEADER_SIZE['eth'] - HEADER_SIZE['ip']
pkg = 'Ether(src="%s", dst="%s")/IP()/Raw(load="P" * %d)' % (
smac, dmac, padding)
self.tester.scapy_foreground()
self.tester.scapy_append('sendp(%s, iface="%s")' % (pkg, itf))
self.tester.scapy_execute()
time.sleep(3)
port0_stats = self.get_stats(txPort)
p0tx_pkts, p0tx_bytes = [
port0_stats['TX-packets'], port0_stats['TX-bytes']
]
port1_stats = self.get_stats(rxPort)
p1rx_pkts, p1rx_err, p1rx_bytes = [
port1_stats['RX-packets'], port1_stats['RX-errors'],
port1_stats['RX-bytes']
]
time.sleep(5)
p0tx_pkts -= gp0tx_pkts
p0tx_bytes -= gp0tx_bytes
p1rx_pkts -= gp1rx_pkts
p1rx_bytes -= gp1rx_bytes
rx_bytes_exp = pktSize
tx_bytes_exp = pktSize
if self.kdriver == "fm10k":
# RRC will always strip rx/tx crc
rx_bytes_exp -= 4
tx_bytes_exp -= 4
if vlan_strip is True:
# RRC will always strip rx/tx vlan
rx_bytes_exp -= 4
tx_bytes_exp -= 4
else:
# some NIC will always include tx crc
rx_bytes_exp -= 4
tx_bytes_exp -= 4
if vlan_strip is True:
# vlan strip default is off
tx_bytes_exp -= 4
# fortville nic enable send lldp packet function when port setup
# now the tx-packets size is lldp_size(110) * n + forward packe size
# so use (tx-packets - forward packet size) % lldp_size, if it is 0, it means forward packet size right
if received:
self.verify(
self.pmdout.check_tx_bytes(p0tx_pkts, p1rx_pkts),
"Wrong TX pkts p0_tx=%d, p1_rx=%d" % (p0tx_pkts, p1rx_pkts))
self.verify(
p1rx_bytes == rx_bytes_exp,
"Wrong Rx bytes p1_rx=%d, expect=%d" %
(p1rx_bytes, rx_bytes_exp))
self.verify(
self.pmdout.check_tx_bytes(p0tx_bytes, tx_bytes_exp),
"Wrong Tx bytes p0_tx=%d, expect=%d" %
(p0tx_bytes, tx_bytes_exp))
else:
self.verify(self.pmdout.check_tx_bytes(p0tx_pkts),
"Packet not dropped p0tx_pkts=%d" % p0tx_pkts)
def check_ports(self, status=True):
"""
Check link status of the ports.
"""
# RRC not support link speed change
if self.kdriver == "fm10k":
return
for port in self.ports:
out = self.tester.send_expect(
"ethtool %s" %
self.tester.get_interface(self.tester.get_local_port(port)),
"# ")
if status:
self.verify("Link detected: yes" in out, "Wrong link status")
else:
self.verify("Link detected: no" in out, "Wrong link status")
def set_up(self):
"""
Run before each test case.
"""
pass
def test_stop_restart(self):
"""
Stop and Restar.
"""
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> ")
self.check_forwarding()
self.dut.send_expect("stop", "testpmd> ")
self.check_forwarding(received=False)
self.dut.send_expect("port stop all", "testpmd> ", 100)
time.sleep(5)
self.check_ports(status=False)
self.dut.send_expect("port start all", "testpmd> ", 100)
time.sleep(5)
self.check_ports(status=True)
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
def test_set_promiscuousmode(self):
"""
Promiscuous mode.
"""
ports = [self.ports[0]]
portmask = utils.create_mask(ports)
self.pmdout.start_testpmd("Default",
"--portmask=%s --port-topology=loop" %
portmask,
socket=self.ports_socket)
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("set promisc all off", "testpmd> ")
self.dut.send_expect("port start all", "testpmd> ", 100)
self.dut.send_expect("show config rxtx", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
try:
self.check_forwarding(ports)
except VerifyFailure as e:
print 'promiscuous mode is working correctly'
except Exception as e:
print " !!! DEBUG IT: " + e.message
self.verify(False, e.message)
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("set promisc all on", "testpmd> ")
self.dut.send_expect("port start all", "testpmd> ", 100)
self.dut.send_expect("show config rxtx", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding(ports, promisc=True)
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("set promisc all off", "testpmd> ")
self.dut.send_expect("start", "testpmd> ")
self.dut.send_expect("quit", "# ", 30)
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 test_reconfigure_ports(self):
"""
Reconfigure All Ports With The Same Configurations (CRC)
"""
RX_OFFLOAD_KEEP_CRC = 0x10000
self.pmdout.start_testpmd(
"Default",
"--portmask=%s --port-topology=loop --disable-crc-strip" %
utils.create_mask(self.ports),
socket=self.ports_socket)
out = self.dut.send_expect("show config rxtx", "testpmd> ")
Rx_offloads = re.compile('Rx offloads=(.*?)\s+?').findall(out, re.S)
crc_keep_temp = []
for i in range(len(self.dut.get_ports())):
crc_keep_temp.append(int(Rx_offloads[i], 16) & RX_OFFLOAD_KEEP_CRC)
crc_keep = crc_keep_temp[0]
crc_keep = crc_keep and crc_keep_temp[i]
self.verify(crc_keep == RX_OFFLOAD_KEEP_CRC,
"CRC keeping not enabled properly")
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("port config all crc-strip on", "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> ")
Rx_offloads = re.compile('Rx offloads=(.*?)\s+?').findall(out, re.S)
crc_strip_temp = []
for i in range(len(self.dut.get_ports())):
crc_strip_temp.append(
int(Rx_offloads[i], 16) | ~RX_OFFLOAD_KEEP_CRC)
crc_strip = crc_strip_temp[0]
crc_strip = crc_strip and crc_strip_temp[i]
self.verify(crc_strip == ~RX_OFFLOAD_KEEP_CRC,
"CRC stripping not enabled properly")
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
def test_change_linkspeed(self):
"""
Change Link Speed.
"""
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)
out = self.tester.send_expect(
"ethtool %s" % self.tester.get_interface(
self.tester.get_local_port(self.ports[0])), "# ")
if 'fortville_spirit' == self.nic:
result_scanner = r"([0-9]+)baseSR4/([A-Za-z]+)"
else:
result_scanner = r"([0-9]+)baseT/([A-Za-z]+)"
scanner = re.compile(result_scanner, re.DOTALL)
m = scanner.findall(out)
configs = m[:-(len(m) / 2)]
for config in configs:
print config
if self.nic in ["ironpond"]:
if config[0] != '1000' or '10000':
continue
elif self.nic in ["fortville_eagle"]:
if config[0] != '10000':
continue
elif self.nic in ["sagepond"]:
if config[0] != '1000' and '10000':
continue
self.dut.send_expect("port stop all", "testpmd> ", 100)
for port in self.ports:
self.dut.send_expect(
"port config %d speed %s duplex %s" %
(port, config[0], config[1].lower()), "testpmd> ")
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("port start all", "testpmd> ", 100)
time.sleep(5) # sleep few seconds for link stable
for port in self.ports:
out = self.tester.send_expect(
"ethtool %s" % self.tester.get_interface(
self.tester.get_local_port(port)), "# ")
self.verify("Speed: %s" % config[0] in out,
"Wrong speed reported by the self.tester.")
self.verify("Duplex: %s" % config[1] in out,
"Wrong link type reported by the self.tester.")
self.dut.send_expect("start", "testpmd> ")
self.check_forwarding()
self.dut.send_expect("stop", "testpmd> ")
def test_enable_disablejumbo(self):
"""
Enable/Disable Jumbo Frames.
"""
if self.kdriver == "fm10k":
print utils.RED("RRC not support\n")
return
jumbo_size = 2048
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 max-pkt-len %d" % jumbo_size,
"testpmd> ")
out = self.dut.send_expect("vlan set strip off all", "testpmd> ")
if "fail" not in out:
for port in self.ports:
self.dut.send_expect("vlan set filter on %d" % port,
"testpmd> ")
self.dut.send_expect("rx_vlan add 1 %d" % port, "testpmd> ")
self.dut.send_expect("set fwd mac", "testpmd>")
self.dut.send_expect("port start all", "testpmd> ", 100)
self.dut.send_expect("start", "testpmd> ")
if self.nic in [
'magnolia_park', 'niantic', 'twinpond', 'kawela_4',
'ironpond', 'springfountain', 'springville', 'powerville',
'sageville', 'sagepond'
]:
# nantic vlan length will not be calculated
vlan_jumbo_size = jumbo_size + 4
else:
vlan_jumbo_size = jumbo_size
out = self.dut.send_expect("show port cap %d" % port, "testpmd> ")
state = re.findall("VLAN stripped:\s*([a-z]*)", out)
if state[0] == 'on':
vlan_strip = True
else:
vlan_strip = False
self.check_forwarding(pktSize=vlan_jumbo_size - 1,
vlan=True,
vlan_strip=vlan_strip)
self.check_forwarding(pktSize=vlan_jumbo_size,
vlan=True,
vlan_strip=vlan_strip)
self.check_forwarding(pktSize=vlan_jumbo_size + 1,
received=False,
vlan=True,
vlan_strip=vlan_strip)
self.dut.send_expect("stop", "testpmd> ")
self.dut.send_expect("port stop all", "testpmd> ", 100)
self.dut.send_expect("port config all hw-vlan off", "testpmd> ")
self.dut.send_expect("port start all", "testpmd> ", 100)
self.dut.send_expect("start", "testpmd> ")
"""
On 1G NICs, when the jubmo frame MTU set as X, the software adjust it to (X + 4).
"""
if self.nic in ["powerville", "springville", "kawela_4"]:
jumbo_size += 4
self.check_forwarding(pktSize=jumbo_size - 1)
self.check_forwarding(pktSize=jumbo_size)
self.check_forwarding(pktSize=jumbo_size + 1, received=False)
def test_enable_disablerss(self):
"""
Enable/Disable RSS.
"""
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 rss ip", "testpmd> ")
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()
def test_change_numberrxdtxd(self):
"""
Change numbers of rxd and 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()
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_change_thresholds(self):
"""
Change RX/TX thresholds
"""
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 txfreet 32", "testpmd> ")
self.dut.send_expect("port config all txrst 32", "testpmd> ")
self.dut.send_expect("port config all rxfreet 32", "testpmd> ")
self.dut.send_expect("port config all txpt 64", "testpmd> ")
self.dut.send_expect("port config all txht 64", "testpmd> ")
self.dut.send_expect("port config all txwt 0", "testpmd> ")
self.dut.send_expect("port config all rxpt 64", "testpmd> ")
self.dut.send_expect("port config all rxht 64", "testpmd> ")
self.dut.send_expect("port config all rxwt 64", "testpmd> ")
self.dut.send_expect("port start all", "testpmd> ", 100)
out = self.dut.send_expect("show config rxtx", "testpmd> ")
self.verify("RX free threshold=32" in out,
"RX descriptor not reconfigured properly")
self.verify("TX free threshold=32" in out,
"TX descriptor not reconfigured properly")
self.verify("TX RS bit threshold=32" in out,
"TX descriptor not reconfigured properly")
self.verify("pthresh=64" in out,
"TX descriptor not reconfigured properly")
self.verify("hthresh=64" in out,
"TX descriptor not reconfigured properly")
self.verify("wthresh=64" in out,
"TX descriptor not reconfigured properly")
self.verify("pthresh=64" in out,
"TX descriptor not reconfigured properly")
self.verify("hthresh=64" in out,
"TX descriptor not reconfigured properly")
self.verify("wthresh=64" in out,
"TX descriptor not reconfigured properly")
self.dut.send_expect("set fwd mac", "testpmd>")
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_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 tear_down(self):
"""
Run after each test case.
"""
self.dut.kill_all()
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()
