new file mode 100644
@@ -0,0 +1,358 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2023 Intel Corporation
+#
+
+"""
+DPDK Test suite.
+"""
+
+import os
+import re
+import time
+
+from framework.exception import VerifyFailure
+from framework.pktgen import PacketGeneratorHelper
+from framework.pmd_output import PmdOutput
+from framework.settings import HEADER_SIZE
+from framework.test_case import TestCase
+
+
+class TestIceIavfChecksumPerf(TestCase):
+ def set_up_all(self):
+ """
+ Run at the start of each test suite.
+ PMD prerequisites.
+ """
+ self.verify(
+ self.nic
+ in ["ICE_100G-E810C_QSFP", "ICE_25G-E810C_SFP", "ICE_25G-E810_XXV_SFP"],
+ "NIC Unsupported: " + str(self.nic),
+ )
+ self.dut_ports = self.dut.get_ports(self.nic)
+ self.verify(len(self.dut_ports) >= 1, "At least 1 port is required to test")
+ self.socket = self.dut.get_numa_id(self.dut_ports[0])
+
+ self.core_offset = 3
+ self.test_content = self.get_test_content_from_cfg(self.get_suite_cfg())
+ # Get dts output path
+ if self.logger.log_path.startswith(os.sep):
+ self.output_path = self.logger.log_path
+ else:
+ cur_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+ self.output_path = os.sep.join([cur_path, self.logger.log_path])
+ self.vfs_mac = ["00:12:34:56:78:0%d" % (i + 1) for i in self.dut_ports]
+ self.pmdout = PmdOutput(self.dut)
+ # Create an instance to set stream field setting
+ self.pktgen_helper = PacketGeneratorHelper()
+
+ def set_up(self):
+ """
+ Run before each test case.
+ It's more convenient to load suite configuration here than
+ set_up_all in debug mode.
+ """
+ self.test_result = {"header": [], "date": []}
+ self.vf_port_info = {}
+
+ def parse_test_config(self, config):
+ """
+ [n]C/[mT]-[i]Q
+ n: how many physical core use for polling.
+ m: how many cpu thread use for polling, if Hyper-threading disabled
+ in BIOS, m equals n, if enabled, m is 2 times as n.
+ i: how many queues use per port, so total queues = i x nb_port
+ """
+ pat = "(.*)/(.*)-(.*)"
+ result = re.findall(pat, config)
+ if not result:
+ msg = f"{config} is wrong format, please check"
+ raise VerifyFailure(msg)
+ cores, threads, queue = result[0]
+ _thread_num = int(int(threads[:-1]) // int(cores[:-1]))
+
+ _thread = str(_thread_num) + "T"
+ _cores = str(self.core_offset + int(cores[:-1])) + "C"
+ cores_config = "/".join(["1S", _cores, _thread])
+ queues_per_port = int(queue[:-1])
+ return cores_config, _thread_num, queues_per_port
+
+ def get_test_configs(self, test_parameters):
+ configs = []
+ frame_sizes_grp = []
+ for test_item, frame_sizes in sorted(test_parameters.items()):
+ _frame_sizes = [int(frame_size) for frame_size in frame_sizes]
+ frame_sizes_grp.extend([int(item) for item in _frame_sizes])
+ cores, thread_num, queues = self.parse_test_config(test_item)
+ corelist = self.dut.get_core_list(cores, self.socket)
+ core_list = corelist[(self.core_offset - 1) * thread_num :]
+ if "2T" in cores:
+ core_list = core_list[1:2] + core_list[0::2] + core_list[1::2][1:]
+ _core_list = core_list[thread_num - 1 :]
+ configs.append(
+ [
+ test_item,
+ _core_list,
+ [
+ " --txd=1024 --rxd=1024"
+ + " --rxq={0} --txq={0}".format(queues)
+ + " --nb-cores={}".format(len(core_list) - thread_num)
+ + " --enable-rx-cksum"
+ ],
+ ]
+ )
+ return configs, sorted(set(frame_sizes_grp))
+
+ def get_test_content_from_cfg(self, test_content):
+ configs, frame_sizes = self.get_test_configs(test_content["test_parameters"])
+ test_content["configs"] = configs
+ test_content["frame_sizes"] = frame_sizes
+ return test_content
+
+ def vf_create(self):
+ """
+ Require enough PF ports, create 1 VF from each PF.
+ """
+ # Get vf assign method
+ vf_driver = self.test_content.get("vf_driver")
+ if vf_driver is None:
+ vf_driver = self.drivername
+ for port_id in self.dut_ports:
+ pf_driver = self.dut.ports_info[port_id]["port"].default_driver
+ self.dut.generate_sriov_vfs_by_port(port_id, 1, driver=pf_driver)
+ pf_pci = self.dut.ports_info[port_id]["port"].pci
+ sriov_vfs_port = self.dut.ports_info[port_id].get("vfs_port")
+ if not sriov_vfs_port:
+ msg = f"failed to create vf on dut port {pf_pci}"
+ self.logger.error(msg)
+ continue
+ self.vf_port_info[port_id] = {
+ "pf_pci": pf_pci,
+ "vf_pci": self.dut.ports_info[port_id]["port"].get_sriov_vfs_pci(),
+ }
+ pf_intf = self.dut.ports_info[port_id]["intf"]
+ # Set vf mac
+ self.dut.send_expect(
+ "ip link set %s vf 0 mac %s" % (pf_intf, self.vfs_mac[port_id]), "#"
+ )
+ self.dut.send_expect("ip link set %s vf 0 trust on" % pf_intf, "#")
+ self.dut.send_expect("ip link set %s vf 0 spoofchk off" % pf_intf, "#")
+ # Bind vf to dpdk
+ try:
+ for port in sriov_vfs_port:
+ port.bind_driver(driver=vf_driver)
+ except Exception as e:
+ self.vf_destroy()
+ raise Exception(e)
+
+ def vf_destroy(self):
+ """
+ Destroy the setup VFs
+ """
+ if not self.vf_port_info:
+ return
+ for port_id, _ in self.vf_port_info.items():
+ self.dut.destroy_sriov_vfs_by_port(port_id)
+ self.dut.ports_info[port_id]["port"].bind_driver(self.drivername)
+ self.vf_port_info = None
+
+ def checksum_enable(self, csum, csum_config):
+ self.dut.send_expect("stop", "testpmd> ", 15)
+ self.dut.send_expect("set fwd csum", "testpmd> ", 15)
+ self.dut.send_expect("port stop all", "testpmd> ", 15)
+ for port_id in self.dut_ports:
+ self.dut.send_expect("csum set ip %s %d" % (csum, port_id), "testpmd> ", 15)
+ if csum_config:
+ self.dut.send_expect(
+ "csum set udp %s %d" % (csum, port_id), "testpmd> ", 15
+ )
+ self.dut.send_expect(
+ "csum set outer-ip %s %d" % (csum, port_id), "testpmd> ", 15
+ )
+ self.dut.send_expect(
+ "csum set outer-udp %s %d" % (csum, port_id), "testpmd> ", 15
+ )
+ self.dut.send_expect(
+ "csum set parse-tunnel on %d" % (port_id), "testpmd> ", 15
+ )
+ self.dut.send_expect("port start all", "testpmd> ", 15)
+ if csum == "hw":
+ self.dut.send_expect("set promisc all on", "testpmd> ", 15)
+
+ def start_testpmd(self, core_list, pci_para, eal, csum, csum_config):
+ self.pmdout.start_testpmd(core_list, eal, pci_para, socket=self.socket)
+ if csum:
+ self.checksum_enable(csum, csum_config)
+ self.dut.send_expect("start", "testpmd> ", 15)
+
+ def create_pcaps_file(self, frame_size, pkt_type):
+ """
+ Prepare traffic flow
+ """
+ if pkt_type == "vxlan":
+ headers_size = sum(
+ [
+ HEADER_SIZE[x]
+ for x in ["eth", "ip", "udp", "vxlan", "eth", "ip", "udp"]
+ ]
+ )
+ else:
+ headers_size = sum([HEADER_SIZE[x] for x in ["eth", "ip"]])
+ payload_size = frame_size - headers_size
+ pcaps = {}
+ # Modify the incorrect checksum of IP and UDP for inner and outer.
+ for _port in self.dut_ports:
+ if 1 == len(self.dut_ports):
+ if pkt_type == "vxlan":
+ flow = [
+ 'Ether(dst="%s")/IP(dst="192.18.1.%d",chksum=1)/UDP(chksum=1)/VXLAN(vni=0x1)/Ether()/IP(dst="192.18.%d.0,chksum=1)/UDP(chksum=1)/("X"*%d)'
+ % (self.vfs_mac[_port], _port, _port, payload_size)
+ ]
+ else:
+ flow = [
+ 'Ether(dst="%s")/IP(dst="192.18.1.%d",chksum=1)/("X"*%d)'
+ % (self.vfs_mac[_port], _port, payload_size)
+ ]
+ pcap = os.sep.join([self.output_path, "dst{0}.pcap".format(_port)])
+ self.tester.scapy_append('wrpcap("%s", [%s])' % (pcap, ",".join(flow)))
+ self.tester.scapy_execute()
+ pcaps[_port] = []
+ pcaps[_port].append(pcap)
+ else:
+ cnt = 0
+ for i in range(len(self.dut_ports) ** 2)[_port * 2 : (_port + 1) * 2]:
+ if pkt_type == "vxlan":
+ flow = [
+ 'Ether(dst="%s")/IP(dst="192.18.%d.%d",chksum=1)/UDP(chksum=1)/VXLAN(vni=0x1)/Ether()/IP(dst="192.18.%d.0",chksum=1)/UDP(chksum=1)/("X"*%d)'
+ % (self.vfs_mac[_port], i, _port, i + 1, payload_size)
+ ]
+ else:
+ flow = [
+ 'Ether(dst="%s")/IP(dst="192.18.%d.%d",chksum=1)/("X"*%d)'
+ % (self.vfs_mac[_port], i, _port, payload_size)
+ ]
+ pcap = os.sep.join(
+ [self.output_path, "dst{0}_{1}.pcap".format(_port, cnt)]
+ )
+ self.tester.scapy_append(
+ 'wrpcap("%s", [%s])' % (pcap, ",".join(flow))
+ )
+ self.tester.scapy_execute()
+ if _port not in pcaps:
+ pcaps[_port] = []
+ pcaps[_port].append(pcap)
+ cnt += 1
+ return pcaps
+
+ def prepare_stream(self, pcaps):
+ """
+ Create streams for ports, one port one stream
+ """
+ tgen_input = []
+ port_num = len(self.dut_ports)
+ if 1 == port_num:
+ txIntf = self.tester.get_local_port(self.dut_ports[0])
+ rxIntf = txIntf
+ for pcap in pcaps[0]:
+ tgen_input.append((txIntf, rxIntf, pcap))
+ else:
+ for rxPort in self.dut_ports:
+ if rxPort % port_num == 0 or rxPort ** 2 == port_num:
+ txIntf = self.tester.get_local_port(self.dut_ports[rxPort + 1])
+ port_id = self.dut_ports[rxPort + 1]
+ else:
+ txIntf = self.tester.get_local_port(self.dut_ports[rxPort - 1])
+ port_id = self.dut_ports[rxPort - 1]
+ rxIntf = self.tester.get_local_port(self.dut_ports[rxPort])
+ for pcap in pcaps[port_id]:
+ tgen_input.append((txIntf, rxIntf, pcap))
+ return tgen_input
+
+ def throughput(self, frame_size, pkt_type):
+ pcaps = self.create_pcaps_file(frame_size, pkt_type)
+ tgenInput = self.prepare_stream(pcaps)
+ # Get traffic option
+ duration = self.test_content.get("test_duration")
+ traffic_stop_wait_time = self.test_content.get("traffic_stop_wait_time", 0)
+ vm_config = self.set_fields()
+ # Clear streams before add new streams
+ self.tester.pktgen.clear_streams()
+ streams = self.pktgen_helper.prepare_stream_from_tginput(
+ tgenInput, 100, vm_config, self.tester.pktgen
+ )
+ # Set traffic option
+ traffic_option = {
+ "method": "throughput",
+ "duration": duration,
+ }
+ # Run packet generator
+ result = self.tester.pktgen.measure(streams, traffic_option)
+ time.sleep(traffic_stop_wait_time)
+ # Statistics result
+ _, pps = result
+ self.verify(pps > 0, "No traffic detected")
+ pps /= 1000000
+ self.logger.info(
+ "Throughput of " + "framesize: {}, is: {} Mpps".format(frame_size, pps)
+ )
+ return pps
+
+ def perf_test(self, csum="", csum_config="", pkt_type="ipv4"):
+ """
+ Performance Benchmarking test
+ """
+ pci_para = ""
+ for port_id in self.dut_ports:
+ pci_para += " -a " + self.vf_port_info[port_id]["vf_pci"][0]
+ results = []
+
+ for config, core_list, eal in self.test_content["configs"]:
+ self.logger.info(
+ ("Executing Test Using cores: {0} of config {1}, ").format(
+ core_list, config
+ )
+ )
+ self.start_testpmd(core_list, pci_para, eal[0], csum, csum_config)
+ for frame_size in self.test_content["frame_sizes"]:
+ self.logger.info("Test running at framesize: {}".format(frame_size))
+ result = self.throughput(frame_size, pkt_type)
+ if result:
+ results.append([config, frame_size, result])
+
+ self.dut.send_expect("stop", "testpmd> ", 15)
+ self.dut.send_expect("quit", "# ", 15)
+
+ def test_perf_enable_sw_checksum_offload(self):
+ self.vf_create()
+ self.perf_test()
+ self.perf_test(csum="sw", pkt_type="ipv4")
+ self.perf_test(csum="sw", pkt_type="vxlan")
+
+ def test_perf_enable_hw_checksum_offload(self):
+ self.vf_create()
+ self.perf_test(csum="hw", pkt_type="ipv4")
+ self.perf_test(csum="hw", pkt_type="vxlan")
+ self.perf_test(csum="hw", csum_config="all", pkt_type="ipv4")
+ self.perf_test(csum="hw", csum_config="all", pkt_type="vxlan")
+
+ def set_fields(self):
+ """
+ Set ip protocol field behavior
+ """
+ fields_config = {
+ "ip": {
+ "src": {"action": "random"},
+ },
+ }
+ return fields_config
+
+ def tear_down(self):
+ """
+ Run after each test case.
+ """
+ self.vf_destroy()
+
+ def tear_down_all(self):
+ """
+ Run after each test suite.
+ """
+ self.dut.kill_all()