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()