def test_perf_l3fwd_4ports(self): """ L3fwd main 4 ports. """ # Based on h/w type, choose how many ports to use ports = self.dut.get_ports() # Verify that enough ports are available self.verify(len(ports) >= 4, "Insufficient ports for speed testing") header_row = ["Frame size", "RX Queues/NIC Port", "S/C/T"] for method in TestL3fwd.methods: header_row.append('%s Mpps' % method) header_row.append('% linerate') dts.results_table_add_header(header_row) self.l3fwd_test_results['header'] = header_row self.l3fwd_test_results['data'] = [] for frame_size in TestL3fwd.frame_sizes: # Prepare traffic flow payload_size = frame_size - HEADER_SIZE['udp'] - \ HEADER_SIZE['ip'] - HEADER_SIZE['eth'] for _port in range(4): dmac = self.dut.get_mac_address(valports[_port]) flows = ['Ether(dst="%s")/%s/("X"*%d)' % (dmac, flow, payload_size) for flow in self.flows()[_port * 2:(_port + 1) * 2]] self.tester.scapy_append('wrpcap("dst%d.pcap", [%s])' % (valports[_port], string.join(flows, ','))) self.tester.scapy_execute() dts.report("Flows for 4 ports, %d frame size.\n" % (frame_size), annex=True) dts.report("%s" % string.join(flows, '\n'), frame=True, annex=True) # Get the number of sockets of the board number_sockets = self.dut.send_expect("grep \"processor\|physical id\|core id\|^$\" /proc/cpuinfo | grep physical | sort -u | wc -l", "# ") number_sockets = int(number_sockets.split('\r\n')[0]) # Run case by case for test_case in TestL3fwd.test_cases_4_ports: # Check if the board has sockets enough for the test case if number_sockets >= int(test_case[1].split('/')[0][0]): self.get_throughput(frame_size, *test_case) self.plot_4_ports() dts.results_table_print()
def test_perf_l3fwd_2ports(self): """ L3fwd main 2 ports. """ header_row = ["Frame", "Ports", "S/C/T", "Mpps", "% linerate", "mode"] self.l3fwd_test_results['header'] = header_row dts.results_table_add_header(header_row) self.l3fwd_test_results['data'] = [] for frame_size in TestL3fwd.frame_sizes: # Prepare traffic flow payload_size = frame_size - HEADER_SIZE['udp'] - \ HEADER_SIZE['ip'] - HEADER_SIZE['eth'] flows = ['Ether()/%s/("X"*%d)' % (flow, payload_size) for flow in self.flows()[:4]] dts.report("Flows for 2 ports, %d frame size.\n" % (frame_size), annex=True) dts.report("%s" % string.join(flows, '\n'), frame=True, annex=True) self.tester.scapy_append('wrpcap("test2ports.pcap", [%s])' % string.join(flows, ',')) self.tester.scapy_execute() # Prepare the command line global corelist pat = re.compile("P([0123]),([0123]),(C\{\d.\d.\d\})") coreMask = {} rtCmdLines = dict(TestL3fwd.test_cases_2_ports) for key in rtCmdLines.keys(): corelist = [] while pat.search(rtCmdLines[key]): rtCmdLines[key] = pat.sub(self.repl, rtCmdLines[key]) self.logger.info("%s\n" % str(corelist)) coreMask[key] = dts.create_mask(set(corelist)) # measure by two different mode for mode in TestL3fwd.methods: # start l3fwd index = 0 subtitle = [] for cores in rtCmdLines.keys(): info = "Executing l3fwd using %s mode, 2 ports, %s and %d frame size.\n" % ( mode, cores, frame_size) self.logger.info(info) dts.report(info, annex=True) subtitle.append(cores) cmdline = rtCmdLines[cores] % (TestL3fwd.path + "l3fwd_" + mode, coreMask[cores], self.dut.get_memory_channels(), dts.create_mask(valports[:2])) dts.report(cmdline + "\n", frame=True, annex=True) out = self.dut.send_expect(cmdline, "L3FWD:", 120) # Measure test tgenInput = [] for rxPort in range(2): # No use on rx/tx limitation if rxPort % 2 == 0: txIntf = self.tester.get_local_port(valports[rxPort + 1]) else: txIntf = self.tester.get_local_port(valports[rxPort - 1]) rxIntf = self.tester.get_local_port(valports[rxPort]) tgenInput.append((txIntf, rxIntf, "test2ports.pcap")) _, pps = self.tester.traffic_generator_throughput(tgenInput) self.verify(pps > 0, "No traffic detected") pps /= 1000000.0 linerate = self.wirespeed(self.nic, frame_size, 2) pct = pps * 100 / linerate index += 1 # Stop l3fwd self.dut.send_expect("^C", "#") data_row = [frame_size, 2, cores, str(pps), str(pct), mode] dts.results_table_add_row(data_row) self.l3fwd_test_results['data'].append(data_row) self.plot_2_ports() dts.results_table_print()
def get_throughput(self, frame_size, rx_queues_per_port, cores_config, command_line): """ Get the throughput for a test case from test_cases_4_ports. """ output_pattern = re.compile("P([0123]),([0123]),(C\{\d.\d.\d\})") bps = dict() pps = dict() pct = dict() global corelist corelist = [] while output_pattern.search(command_line): command_line = output_pattern.sub(self.repl, command_line) self.logger.debug("%s\n" % str(corelist)) core_mask = dts.create_mask(set(corelist)) # First, measure by two different methods for method in TestL3fwd.methods: # start l3fwd method_command_line = command_line % (TestL3fwd.path + "l3fwd_" + method, core_mask, self.dut.get_memory_channels(), dts.create_mask(valports[:4])) dts.report(method_command_line + "\n", frame=True, annex=True) out = self.dut.send_expect(method_command_line, "L3FWD:", 120) # measure test tgen_input = [] for rxPort in range(4): if rxPort % 2 == 0: tx_interface = self.tester.get_local_port(valports[rxPort + 1]) else: tx_interface = self.tester.get_local_port(valports[rxPort - 1]) rx_interface = self.tester.get_local_port(valports[rxPort]) tgen_input.append((tx_interface, rx_interface, "dst%d.pcap" % valports[rxPort])) # FIX ME bps[method], pps[method] = self.tester.traffic_generator_throughput(tgen_input) self.verify(pps[method] > 0, "No traffic detected") pps[method] /= 1000000.0 pct[method] = pps[method] * 100 / float(self.wirespeed(self.nic, frame_size, 4)) # stop l3fwd self.dut.send_expect("^C", "#") data_row = [frame_size, rx_queues_per_port, cores_config] for method in TestL3fwd.methods: data_row.append(pps[method]) data_row.append(pct[method]) # generate report table dts.results_table_add_row(data_row) self.l3fwd_test_results['data'].append(data_row)
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_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_perf_l2fwd_performance(self): """ Benchmark performance for frame_sizes. """ ports = [] for port in xrange(self.number_of_ports): ports.append(self.dut_ports[port]) port_mask = dts.create_mask(ports) core_mask = dts.create_mask(self.dut.get_core_list(self.core_config, socket=self.ports_socket)) for frame_size in self.frame_sizes: payload_size = frame_size - self.headers_size tgen_input = [] for port in xrange(self.number_of_ports): rx_port = self.tester.get_local_port(self.dut_ports[port % self.number_of_ports]) tx_port = self.tester.get_local_port(self.dut_ports[(port + 1) % self.number_of_ports]) destination_mac = self.dut.get_mac_address(self.dut_ports[(port + 1) % self.number_of_ports]) self.tester.scapy_append('wrpcap("l2fwd_%d.pcap", [Ether(dst="%s")/IP()/UDP()/("X"*%d)])' % ( port, destination_mac, payload_size)) tgen_input.append((tx_port, rx_port, "l2fwd_%d.pcap" % port)) self.tester.scapy_execute() for queues in self.test_queues: command_line = "./examples/l2fwd/build/app/l2fwd -n %d -c %s -- -q %s -p %s &" % \ (self.dut.get_memory_channels(), core_mask, str(queues['queues']), port_mask) self.dut.send_expect(command_line, "memory mapped", 60) info = "Executing l2fwd using %s queues, frame size %d and %s setup.\n" % \ (queues['queues'], frame_size, self.core_config) self.logger.info(info) dts.report(info, annex=True) dts.report(command_line + "\n\n", frame=True, annex=True) _, pps = self.tester.traffic_generator_throughput(tgen_input) Mpps = pps / 1000000.0 queues['Mpps'][frame_size] = Mpps queues['pct'][frame_size] = Mpps * 100 / float(self.wirespeed( self.nic, frame_size, self.number_of_ports)) self.quit_l2fwd() # Look for transmission error in the results for frame_size in self.frame_sizes: for n in range(len(self.test_queues)): self.verify(self.test_queues[n]['Mpps'][frame_size] > 0, "No traffic detected") # Prepare the results for table and plot printing for frame_size in self.frame_sizes: results_row = [] results_row.append(frame_size) for queue in self.test_queues: results_row.append(queue['Mpps'][frame_size]) results_row.append(queue['pct'][frame_size]) dts.results_table_add_row(results_row) self.plot_results() dts.results_table_print()