def test_perf_ipfrag_throughtput(self): """ Performance test for 64, 1518, 1519, 2k and 9k. """ self.tester.send_expect("ifconfig %s mtu 9600" % self.tester.get_interface(self.tester.get_local_port(P0)), "#") self.tester.send_expect("ifconfig %s mtu 9600" % self.tester.get_interface(self.tester.get_local_port(P1)), "#") sizes = [64, 1518, 1519, 2000, 9000] tblheader = ["Ports", "S/C/T", "SW threads"] for size in sizes: tblheader.append("%dB Mpps" % size) tblheader.append("%d" % size) dts.results_table_add_header(tblheader) lcores = [("1S/1C/1T", 2), ("1S/1C/2T", 2), ("1S/2C/1T", 2), ("2S/1C/1T", 2)] index = 1 for (lcore, numThr) in lcores: self.benchmark(index, lcore, numThr, sizes) index += 1 dts.results_table_print() self.tester.send_expect("ifconfig %s mtu 1500" % self.tester.get_interface(self.tester.get_local_port(P0)), "#") self.tester.send_expect("ifconfig %s mtu 1500" % self.tester.get_interface(self.tester.get_local_port(P1)), "#")
def test_perf_checksum_throughtput(self): """ Test checksum offload performance. """ self.dut_ports = self.dut.get_ports_performance() # Verify that enough ports are available self.verify(len(self.dut_ports) >= 2, "Insufficient ports for testing") # sizes = [64, 128, 256, 512, 1024] sizes = [64, 128] pkts = { 'IP/UDP': 'Ether(dst="%s", src="52:00:00:00:00:00")/IP()/UDP()/("X"*(%d-46))', 'IP/TCP': 'Ether(dst="%s", src="52:00:00:00:00:00")/IP()/TCP()/("X"*(%d-58))', 'IP/SCTP': 'Ether(dst="%s", src="52:00:00:00:00:00")/IP()/SCTP()/("X"*(%d-50+2))', 'IPv6/UDP': 'Ether(dst="%s", src="52:00:00:00:00:00")/IPv6()/UDP()/("X"* (lambda x: x - 66 if x > 66 else 0)(%d))', 'IPv6/TCP': 'Ether(dst="%s", src="52:00:00:00:00:00")/IPv6()/TCP()/("X"* (lambda x: x - 78 if x > 78 else 0)(%d))' } lcore = "1S/2C/1T" portMask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]]) for mode in ["sw", "hw"]: self.logger.info("%s performance" % mode) rst.write_text(mode + " Performance" + '\r\n') tblheader = ["Ports", "S/C/T", "Packet Type", "Mode"] for size in sizes: tblheader.append("%sB mpps" % str(size)) tblheader.append("%sB %% " % str(size)) dts.results_table_add_header(tblheader) self.pmdout.start_testpmd(lcore, "--portmask=%s" % self.portMask, socket=self.ports_socket) self.dut.send_expect("set verbose 1", "testpmd> ") self.dut.send_expect("set fwd csum", "testpmd> ") if mode == "hw": self.checksum_enablehw(self.dut_ports[0]) self.checksum_enablehw(self.dut_ports[1]) else: self.checksum_enablesw(self.dut_ports[0]) self.checksum_enablesw(self.dut_ports[1]) self.dut.send_expect("start", "testpmd> ", 3) for ptype in pkts.keys(): self.benchmark(lcore, ptype, mode, pkts[ptype], sizes, self.nic) self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "#", 10) dts.results_table_print()
def lcore_table_print(self, horizontal=False): if not horizontal: dts.results_table_add_header(['Socket', 'Core', 'Thread']) for lcore in self.cores: dts.results_table_add_row([lcore['socket'], lcore['core'], lcore['thread']]) dts.results_table_print() else: dts.results_table_add_header(['X'] + [''] * len(self.cores)) dts.results_table_add_row(['Thread'] + [n['thread'] for n in self.cores]) dts.results_table_add_row(['Core'] + [n['core'] for n in self.cores]) dts.results_table_add_row(['Socket'] + [n['socket'] for n in self.cores]) dts.results_table_print()
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 lcore_table_print(self, horizontal=False): if not horizontal: dts.results_table_add_header(['Socket', 'Core', 'Thread']) for lcore in self.cores: dts.results_table_add_row( [lcore['socket'], lcore['core'], lcore['thread']]) dts.results_table_print() else: dts.results_table_add_header(['X'] + [''] * len(self.cores)) dts.results_table_add_row(['Thread'] + [n['thread'] for n in self.cores]) dts.results_table_add_row(['Core'] + [n['core'] for n in self.cores]) dts.results_table_add_row(['Socket'] + [n['socket'] for n in self.cores]) 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 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_multiprocess_client_serverperformance(self): """ Benchmark Multiprocess client-server performance. """ self.dut.kill_all() self.dut.send_expect("fg", "# ") dutPorts = self.dut.get_ports() txPort = self.tester.get_local_port(dutPorts[0]) rxPort = self.tester.get_local_port(dutPorts[1]) mac = self.tester.get_mac(txPort) self.tester.scapy_append('dmac="%s"' % self.dut.get_mac_address(dutPorts[0])) self.tester.scapy_append('smac="%s"' % mac) if not self.dut.want_perf_tests: self.tester.scapy_append( 'flows = [Ether(src=smac, dst=dmac)/IP(src="192.168.1.%s" % src, dst="192.168.1.%s" % dst)/("X"*26) for src in range(64) for dst in range(64)]' ) else: self.tester.scapy_append( 'flows = [Ether(src=smac, dst=dmac)/IP(src="192.168.1.1", dst="192.168.1.1")/("X"*26)]' ) self.tester.scapy_append('wrpcap("test.pcap", flows)') self.tester.scapy_execute() validExecutions = [] for execution in executions: if len(self.dut.get_core_list( execution['cores'])) == execution['nprocs']: validExecutions.append(execution) for execution in validExecutions: coreList = self.dut.get_core_list(execution['cores']) coreMask = dts.create_mask(self.dut.get_core_list('1S/1C/1T')) portMask = dts.create_mask([dutPorts[0], dutPorts[1]]) self.dut.send_expect( "./examples/multi_process/client_server_mp/mp_server/client_server_mp/mp_server/%s/mp_server -n %d -c %s -- -p %s -n %d" % (self.target, self.dut.get_memory_channels(), "0xA0", portMask, execution['nprocs']), "Finished Process Init", 20) self.dut.send_expect("^Z", "\r\n") self.dut.send_expect("bg", "# ") for n in range(execution['nprocs']): time.sleep(5) coreMask = dts.create_mask([coreList[n]]) self.dut.send_expect( "./examples/multi_process/client_server_mp/mp_client/client_server_mp/mp_client/%s/mp_client -n %d -c %s --proc-type=secondary -- -n %d" % (self.target, self.dut.get_memory_channels(), coreMask, n), "Finished Process Init") self.dut.send_expect("^Z", "\r\n") self.dut.send_expect("bg", "# ") tgenInput = [] tgenInput.append([txPort, rxPort, "test.pcap"]) _, pps = self.tester.traffic_generator_throughput(tgenInput) execution['pps'] = pps self.dut.kill_all() time.sleep(5) for n in range(len(executions)): self.verify(executions[n]['pps'] is not 0, "No traffic detected") dts.results_table_add_header([ 'Server threads', 'Server Cores/Threads', 'Num-procs', 'Sockets/Cores/Threads', 'Num Ports', 'Frame Size', '%-age Line Rate', 'Packet Rate(mpps)' ]) for execution in validExecutions: dts.results_table_add_row([ 1, '1S/1C/1T', execution['nprocs'], execution['cores'], 2, 64, execution['pps'] / float(100000000 / (8 * 84)), execution['pps'] / float(1000000) ]) 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()