* [dts] [PATCH 0/4] Add vxlan function and performance suite
@ 2015-06-08 2:21 Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 1/4] Optimize get core list function for Haswell cpu Yong Liu
` (4 more replies)
0 siblings, 5 replies; 6+ messages in thread
From: Yong Liu @ 2015-06-08 2:21 UTC (permalink / raw)
To: dts
From: Marvin Liu <yong.liu@intel.com>
Cloud providers build virtual network overlays over existing network
infrastructure that provide tenant isolation and scaling. Tunneling layers
added to the packets carry the virtual networking frames over existing Layer 2
and IP networks.
In this suite, we will verify tunnel vxlan packet detect,checksum offload can
work on FVL card. This suite also supply one approach to meansure the
performance.
Marvin Liu (4):
Optimize get core list function for Haswell cpu.
Add vxlan protocal support in etgen module
Add vxlan test plan.
Add vxlan test suite.
framework/crb.py | 19 +-
framework/etgen.py | 47 +-
framework/settings.py | 3 +-
test_plans/vxlan_test_plan.rst | 392 ++++++++++++++
tests/TestSuite_vxlan.py | 1101 ++++++++++++++++++++++++++++++++++++++++
5 files changed, 1550 insertions(+), 12 deletions(-)
create mode 100644 test_plans/vxlan_test_plan.rst
create mode 100644 tests/TestSuite_vxlan.py
--
1.9.3
^ permalink raw reply [flat|nested] 6+ messages in thread
* [dts] [PATCH 1/4] Optimize get core list function for Haswell cpu.
2015-06-08 2:21 [dts] [PATCH 0/4] Add vxlan function and performance suite Yong Liu
@ 2015-06-08 2:21 ` Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 2/4] Add vxlan protocal support in etgen module Yong Liu
` (3 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: Yong Liu @ 2015-06-08 2:21 UTC (permalink / raw)
To: dts
From: Marvin Liu <yong.liu@intel.com>
Create cpu id map for core allocation. Haswell cpu default core id is
[0, 1, 2, 3, 4, 8, 9, 10, 11, 16, 17, 18, 19, 20, 24, 25, 26, 27].
After conversion, cpu core id will be
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17].
Change set object to list object in get_core_list for get core in sequence.
Signed-off-by: Marvin Liu <yong.liu@intel.com>
diff --git a/framework/crb.py b/framework/crb.py
index 2c01d48..f6ac811 100644
--- a/framework/crb.py
+++ b/framework/crb.py
@@ -423,6 +423,10 @@ class Crb(object):
"grep --color=never \"processor\\|physical id\\|core id\\|^$\" /proc/cpuinfo",
"#", alt_session=True)
cpuinfo = cpuinfo.split('\r\n\r\n')
+ # haswell cpu on cottonwood core id not correct
+ # need addtional coremap for haswell cpu
+ core_id = 0
+ coremap = {}
for line in cpuinfo:
m = re.search("processor\t: (\d+)\r\n" +
"physical id\t: (\d+)\r\n" +
@@ -432,11 +436,16 @@ class Crb(object):
thread = m.group(1)
socket = m.group(2)
core = m.group(3)
+
+ if core not in coremap.keys():
+ coremap[core] = core_id
+ core_id += 1
+
if self.crb['bypass core0'] and core == '0' and socket == '0':
self.logger.info("Core0 bypassed")
continue
self.cores.append(
- {'thread': thread, 'socket': socket, 'core': core})
+ {'thread': thread, 'socket': socket, 'core': coremap[core]})
self.number_of_cores = len(self.cores)
@@ -559,9 +568,9 @@ class Crb(object):
temp = []
for sock in sockList:
- core_list = set([int(n['core']) for n in partial_cores if int(
+ core_list = list([int(n['core']) for n in partial_cores if int(
n['socket']) == sock])
- core_list = list(core_list)[:nr_cores]
+ core_list = core_list[:nr_cores]
temp.extend(core_list)
core_list = temp
@@ -579,9 +588,9 @@ class Crb(object):
coreList_aux = [int(core_list[n])for n in range(
(nr_cores * i), (nr_cores * i + nr_cores))]
for core in coreList_aux:
- thread_list = set([int(n['thread']) for n in partial_cores if (
+ thread_list = list([int(n['thread']) for n in partial_cores if (
(int(n['core']) == core) and (int(n['socket']) == sock))])
- thread_list = list(thread_list)[:nr_threads]
+ thread_list = thread_list[:nr_threads]
temp.extend(thread_list)
thread_list = temp
i += 1
--
1.9.3
^ permalink raw reply [flat|nested] 6+ messages in thread
* [dts] [PATCH 2/4] Add vxlan protocal support in etgen module
2015-06-08 2:21 [dts] [PATCH 0/4] Add vxlan function and performance suite Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 1/4] Optimize get core list function for Haswell cpu Yong Liu
@ 2015-06-08 2:21 ` Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 3/4] Add vxlan test plan Yong Liu
` (2 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: Yong Liu @ 2015-06-08 2:21 UTC (permalink / raw)
To: dts
From: Marvin Liu <yong.liu@intel.com>
Inner packets can not be handled like normal packet. Now parse_pcap function
will strip vxlan inner packet and convert it to hex string. This hex string
will be configured to dataBytes of protocolPad.
Signed-off-by: Marvin Liu <yong.liu@intel.com>
diff --git a/framework/etgen.py b/framework/etgen.py
index 8270f24..fc64b70 100644
--- a/framework/etgen.py
+++ b/framework/etgen.py
@@ -189,11 +189,34 @@ class IxiaPacketGenerator(SSHConnection):
self.send_expect("clearOwnershipAndLogout", "% ")
def parse_pcap(self, fpcap):
- """
- Parse packet in pcap file and convert it into tcl commands.
- """
- self.send_expect("echo {print [i.command() for i in rdpcap('%s', -1)]; exit()} > dumppcap.py" %
- fpcap, "% ")
+ dump_str1 = "cmds = []\n"
+ dump_str2 = "for i in rdpcap('%s', -1):\n" % fpcap
+ dump_str3 = " if 'Vxlan' in i.command():\n" + \
+ " vxlan_str = ''\n" + \
+ " l = len(i[Vxlan])\n" + \
+ " vxlan = str(i[Vxlan])\n" + \
+ " first = True\n" + \
+ " for j in range(l):\n" + \
+ " if first:\n" + \
+ " vxlan_str += \"Vxlan(hexval='%02X\" %ord(vxlan[j])\n" + \
+ " first = False\n" + \
+ " else:\n" + \
+ " vxlan_str += \" %02X\" %ord(vxlan[j])\n" + \
+ " vxlan_str += \"\')\"\n" + \
+ " command = re.sub(r\"Vxlan(.*)\", vxlan_str, i.command())\n" + \
+ " else:\n" + \
+ " command = i.command()\n" + \
+ " cmds.append(command)\n" + \
+ "print cmds\n" + \
+ "exit()"
+
+ f = open("dumppcap.py", "w")
+ f.write(dump_str1)
+ f.write(dump_str2)
+ f.write(dump_str3)
+ f.close()
+
+ self.session.copy_file_to("dumppcap.py")
out = self.send_expect("scapy -c dumppcap.py 2>/dev/null", "% ", 120)
flows = eval(out)
return flows
@@ -254,7 +277,15 @@ class IxiaPacketGenerator(SSHConnection):
self.add_tcl_cmd("udp config -sourcePort %d" % sport)
self.add_tcl_cmd("udp config -destPort %d" % dport)
self.add_tcl_cmd("udp config -length %d" % len)
- self.add_tcl_cmd("udp set %d %d %d" % (self.chasId, port['card'], port['port']))
+ self.add_tcl_cmd("udp set %d %d %d" %
+ (self.chasId, port['card'], port['port']))
+
+ def vxlan(self, port, hexval):
+ self.add_tcl_cmd("protocolPad setDefault")
+ self.add_tcl_cmd("protocol config -enableProtocolPad true")
+ self.add_tcl_cmd("protocolPad config -dataBytes \"%s\"" % hexval)
+ self.add_tcl_cmd("protocolPad set %d %d %d" %
+ (self.chasId, port['card'], port['port']))
def tcp(self, port, sport, dport, seq, ack, dataofs, reserved, flags, window, chksum, urgptr, options=None):
"""
@@ -297,6 +328,10 @@ class IxiaPacketGenerator(SSHConnection):
match = pat.match(header)
params = eval('dict(%s)' % match.group(2))
method_name = match.group(1)
+ if method_name == 'Vxlan':
+ method = getattr(self, method_name.lower())
+ method(txport, **params)
+ break
if method_name in SCAPY2IXIA:
method = getattr(self, method_name.lower())
method(txport, **params)
diff --git a/framework/settings.py b/framework/settings.py
index 2eccc64..19ebe6b 100644
--- a/framework/settings.py
+++ b/framework/settings.py
@@ -124,7 +124,8 @@ HEADER_SIZE = {
'ip': 20,
'ipv6': 40,
'udp': 8,
- 'tcp': 20
+ 'tcp': 20,
+ 'vxlan': 8,
}
--
1.9.3
^ permalink raw reply [flat|nested] 6+ messages in thread
* [dts] [PATCH 3/4] Add vxlan test plan.
2015-06-08 2:21 [dts] [PATCH 0/4] Add vxlan function and performance suite Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 1/4] Optimize get core list function for Haswell cpu Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 2/4] Add vxlan protocal support in etgen module Yong Liu
@ 2015-06-08 2:21 ` Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 4/4] Add vxlan test suite Yong Liu
2015-06-09 6:38 ` [dts] [PATCH] Enhance vxlan checksum offload performance test case Yong Liu
4 siblings, 0 replies; 6+ messages in thread
From: Yong Liu @ 2015-06-08 2:21 UTC (permalink / raw)
To: dts
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain; charset=UTF-8, Size: 22091 bytes --]
From: Marvin Liu <yong.liu@intel.com>
In this suite, we will verify checksum and tunnel filter feature on vxlan.
This suite also contain performance test of checksum and tunnel filter.
Signed-off-by: Marvin Liu <yong.liu@intel.com>
diff --git a/test_plans/vxlan_test_plan.rst b/test_plans/vxlan_test_plan.rst
new file mode 100644
index 0000000..55dc227
--- /dev/null
+++ b/test_plans/vxlan_test_plan.rst
@@ -0,0 +1,392 @@
+.. Copyright (c) <2014>, Intel Corporation
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+
+ - Neither the name of Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPR ESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+
+================
+ Fortville Vxlan
+================
+Cloud providers build virtual network overlays over existing network
+infrastructure that provide tenant isolation and scaling. Tunneling
+layers added to the packets carry the virtual networking frames over
+existing Layer 2 and IP networks. Conceptually, this is similar to
+creating virtual private networks over the Internet. Fortville will
+process these tunneling layers by the hardware.
+
+This document provides test plan for Fortville vxlan packet detecting,
+checksum computing and filtering.
+
+Prerequisites
+=============
+1x Intel® X710 (Fortville) NICs (2x 40GbE full duplex optical ports per NIC)
+plugged into the available PCIe Gen3 8-lane slot.
+
+1x Intel® XL710-DA4 (Eagle Fountain) (1x 10GbE full duplex optical ports per NIC)
+plugged into the avaiable PCIe Gen3 8-lane slot.
+
+DUT board must be two sockets system and each cpu have more than 8 lcores.
+
+Test Case: Vxlan ipv4 packet detect
+===================================
+Start testpmd with tunneling packet type to vxlan::
+
+ testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+
+Set rxonly packet forwarding mode and enable verbose log::
+
+ set fwd rxonly
+ set verbose 1
+
+Send packet as table listed and check dumped packet type the same as column
+"Rx packet type".
+
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Inner L4 | Rx packet type | Pkt Error |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv4 | None | None | None | None | PKT_RX_IPV4_HDR | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv4 | Vxlan | None | Ipv4 | Udp | PKT_RX_IPV4_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv4 | Vxlan | None | Ipv4 | Tcp | PKT_RX_IPV4_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv4 | Vxlan | None | Ipv4 | Sctp | PKT_RX_IPV4_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| Yes | Ipv4 | Vxlan | None | Ipv4 | Udp | PKT_RX_IPV4_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| Yes | Ipv4 | Vxlan | Yes | Ipv4 | Udp | PKT_RX_IPV4_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+
+
+
+Test Case: Vxlan ipv6 packet detect
+===================================
+Start testpmd with tunneling packet type to vxlan::
+
+ testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+
+Set rxonly packet forwarding mode and enable verbose log::
+
+ set fwd rxonly
+ set verbose 1
+
+Send ipv6 packet as table listed and check dumped packet type the same as
+column "Rx packet type".
+
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 | Rx packet type | Pkt Error |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv6 | None | None | None | None | PKT_RX_IPV6_HDR | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv6 | Vxlan | None | Ipv6 | Udp | PKT_RX_IPV6_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv6 | Vxlan | None | Ipv6 | Tcp | PKT_RX_IPV6_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| No | Ipv6 | Vxlan | None | Ipv6 | Sctp | PKT_RX_IPV6_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| Yes | Ipv6 | Vxlan | None | Ipv6 | Udp | PKT_RX_IPV6_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+| Yes | Ipv6 | Vxlan | Yes | Ipv6 | Udp | PKT_RX_IPV6_HDR_EXT | None |
++------------+----------+-----------+------------+----------+-----------+---------------------+-----------+
+
+
+Test Case: Vxlan ipv4 checksum offload
+======================================
+
+Start testpmd with tunneling packet type to vxlan::
+
+ testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+
+Set csum packet forwarding mode and enable verbose log::
+
+ set fwd csum
+ set verbose 1
+
+Enable VXLAN protocal on ports::
+
+ rx_vxlan_port add 4789 0
+ rx_vxlan_port add 4789 1
+
+Enable IP,UDP,TCP,SCTP,VXLAN checksum offload::
+
+ tx_checksum set 0 ip hw
+ tx_checksum set 0 udp hw
+ tx_checksum set 0 tcp hw
+ tx_checksum set 0 sctp hw
+ tx_checksum set 0 vxlan hw
+
+Send packet with valid checksum and check there's no chksum error counter
+increased.
+
++------------+----------+-----------+------------+----------+-----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 | Pkt Error |
++------------+----------+-----------+------------+----------+-----------+-----------+
+| No | Ipv4 | None | None | None | None | None |
++------------+----------+-----------+------------+----------+-----------+-----------+
+
+Send packet with invalid l3 checksum first. Then check forwarded packet checksum
+corrected and there's correct l3 chksum error counter increased.
+
++------------+----------+-----------+------------+----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 |
++------------+----------+-----------+------------+----------+-----------+
+| No | Bad Ipv4 | None | None | None | None |
++------------+----------+-----------+------------+----------+-----------+
+| No | Ipv4 | Vxlan | None | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| No | Bad Ipv4 | Vxlan | None | Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| No | Bad Ipv4 | Vxlan | None | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+
+Send packet with invalid l4 checksum first. Then check forwarded packet checksum
+corrected and there's correct l4 chksum error counter increased.
+
++------------+----------+-----------+------------+----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 |
++------------+----------+-----------+------------+----------+-----------+
+| No | Ipv4 | Vxlan | None | Ipv4 | Bad Udp |
++------------+----------+-----------+------------+----------+-----------+
+| No | Ipv4 | Vxlan | None | Ipv4 | Bad Tcp |
++------------+----------+-----------+------------+----------+-----------+
+| No | Ipv4 | Vxlan | None | Ipv4 | Bad Sctp |
++------------+----------+-----------+------------+----------+-----------+
+
+Send vlan packet with invalid l3 checksum first. Then check forwarded packet
+checksum corrected and there's correct l3 chksum error counter increased.
+
++------------+----------+-----------+------------+----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Bad Ipv4 | Vxlan | None | Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv4 | Vxlan | None | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Bad Ipv4 | Vxlan | None | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Bad Ipv4 | Vxlan | Yes | Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv4 | Vxlan | Yes | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Bad Ipv4 | Vxlan | Yes | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+
+Send vlan packet with invalid l4 checksum first. Then check forwarded packet
+checksum corrected and there's correct l4 chksum error counter increased.
+
++------------+----------+-----------+------------+----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv4 | Vxlan | None | Ipv4 | Bad Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv4 | Vxlan | None | Ipv4 | Bad Tcp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv4 | Vxlan | None | Ipv4 | Bad Sctp |
++------------+----------+-----------+------------+----------+-----------+
+
+
+Test Case: Vxlan ipv6 checksum offload
+======================================
+Start testpmd with tunneling packet type::
+
+ testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+
+Set csum packet forwarding mode and enable verbose log::
+
+ set fwd csum
+ set verbose 1
+
+
+Enable VXLAN protocal on ports::
+
+ rx_vxlan_port add 4789 0
+ rx_vxlan_port add 4789 1
+
+Enable IP,UDP,TCP,SCTP,VXLAN checksum offload::
+
+ tx_checksum set 0 ip hw
+ tx_checksum set 0 udp hw
+ tx_checksum set 0 tcp hw
+ tx_checksum set 0 sctp hw
+
+Send ipv6 packet with valid checksum and check there's no chksum error counter
+increased.
+
++------------+----------+-----------+------------+----------+-----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Innter L4 | Pkt Error |
++------------+----------+-----------+------------+----------+-----------+-----------+
+| No | Ipv6 | None | None | None | None | None |
++------------+----------+-----------+------------+----------+-----------+-----------+
+
+
+Send ipv6 packet with invalid l3 checksum first. Then check forwarded packet
+checksum corrected and there's correct l3 chksum error counter increased.
+
++------------+----------+-----------+------------+----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Inner L4 |
++------------+----------+-----------+------------+----------+-----------+
+| No | Ipv6 | Vxlan | None | Ipv4 | None |
++------------+----------+-----------+------------+----------+-----------+
+| No | Ipv6 | Vxlan | None | Bad Ipv4 | Udp |
++------------+----------+-----------+------------+----------+-----------+
+
+Send vlan+ipv6 packet with invalid l4 checksum first. Then check forwarded
+packet checksum corrected and there's correct l4 chksum error counter
+increased.
+
++------------+----------+-----------+------------+----------+-----------+
+| Outer Vlan | Outer IP | Outer UDP | Inner Vlan | Inner L3 | Inner L4 |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv6 | Vxlan | None | Ipv4 | Bad Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv6 | Vxlan | None | Ipv4 | Bad Tcp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv6 | Vxlan | None | Ipv4 | Bad Sctp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv6 | Vxlan | Yes | Ipv4 | Bad Udp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv6 | Vxlan | Yes | Ipv4 | Bad Tcp |
++------------+----------+-----------+------------+----------+-----------+
+| Yes | Ipv6 | Vxlan | Yes | Ipv4 | Bad Sctp |
++------------+----------+-----------+------------+----------+-----------+
+
+Test Case: Clould Filter
+========================
+Start testpmd with tunneling packet type to vxlan and disable receive side
+scale for hardware limitation::
+
+ testpmd -c ffff -n 4 -- -i --tunnel-type=1 --disable-rss --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+
+Set rxonly packet forwarding mode and enable verbose log::
+
+ set fwd rxonly
+ set verbose 1
+
+Add one new Cloud filter as table listed first::
+
+ tunnel_filter add 0 11:22:33:44:55:66 00:00:20:00:00:01 192.168.2.2 1 vxlan imac-ivlan 1 3
+
+Then send one packet and check packet was forwarded into right queue.
+
++------------+------------+------------+----------+----------+--------+-------+
+| Outer Mac | Inner Mac | Inner Vlan | Outer Ip | Inner Ip | Vni ID | Queue |
++------------+------------+------------+----------+----------+--------+-------+
+| No | Yes | Yes | No | No | No | 1 |
++------------+------------+------------+----------+----------+--------+-------+
+| No | Yes | Yes | No | No | Yes | 1 |
++------------+------------+------------+----------+----------+--------+-------+
+| No | Yes | No | No | No | Yes | 1 |
++------------+------------+------------+----------+----------+--------+-------+
+| No | Yes | No | No | No | No | 1 |
++------------+------------+------------+----------+----------+--------+-------+
+| Yes | Yes | No | No | Yes | Yes | 1 |
++------------+------------+------------+----------+----------+--------+-------+
+| No | No | No | No | Yes | No | 1 |
++------------+------------+------------+----------+----------+--------+-------+
+
+
+Add Clould filter to max number will be failed.
+
+Remove Clould filter which has been added. Then send one packet and check
+packet was received in queue 0.
+
+Add Clould filter with invalid Mac address "00:00:00:00:01" will be failed.
+
+Add Clould filter with invalid ip address "192.168.1.256" will be failed.
+
+Add Clould filter with invalid vlan "4097" will be failed.
+
+Add Clould filter with invalid vni "16777216" will be failed.
+
+Add Clould filter with invalid queue id "64" will be failed.
+
+Test Case: Vxlan Checksum Offload Performance Benchmarking
+==========================================================
+
+The throughput is measured for each of these cases for vxlan tx checksum
+offload of "all by software", "inner l3 offload by hardware", "inner l4
+offload by hardware", "inner l3&l4 offload by hardware", "outer l3 offload
+by hardware", "outer l4 offload by hardware", "outer l3&l4 offload by
+hardware", "all by hardware".
+
+The results are printed in the following table:
+
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| Calculate Type | 1S/1C/1T Mpps | % linerate | 1S/1C/2T Mpps | % linerate | 1S/2C/1T Mpps | % linerate |
++================+===============+============+===============+============+===============+============+
+| SOFTWARE ALL | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HW OUTER L3 | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HW OUTER L4 | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HW OUTER L3&L4 | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HW INNER L3 | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HW INNER L4 | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HW INNER L3&L4 | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+| HARDWARE ALL | | | | | | |
++----------------+---------------+------------+---------------+------------+---------------+------------+
+
+Test Case: Vxlan Tunnel filter Performance Benchmarking
+=======================================================
+The throughput is measured for different Vxlan tunnel filter types.
+Queue single mean there's only one flow and forwarded to the first queue.
+Queue multi mean there're two flows and configure to different queues.
+
++--------+------------------+--------+--------+------------+
+| Packet | Filter | Queue | Mpps | % linerate |
++========+==================+========+========+============+
+| Normal | None | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | None | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac-ivlan | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac-ivlan-tenid | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac-tenid | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | omac-imac-tenid | Single | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac-ivlan | Multi | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac-ivlan-tenid | Multi | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac-tenid | Multi | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | imac | Multi | | |
++--------+------------------+--------+--------+------------+
+| Vxlan | omac-imac-tenid | Multi | | |
++--------+------------------+--------+--------+------------+
--
1.9.3
^ permalink raw reply [flat|nested] 6+ messages in thread
* [dts] [PATCH 4/4] Add vxlan test suite.
2015-06-08 2:21 [dts] [PATCH 0/4] Add vxlan function and performance suite Yong Liu
` (2 preceding siblings ...)
2015-06-08 2:21 ` [dts] [PATCH 3/4] Add vxlan test plan Yong Liu
@ 2015-06-08 2:21 ` Yong Liu
2015-06-09 6:38 ` [dts] [PATCH] Enhance vxlan checksum offload performance test case Yong Liu
4 siblings, 0 replies; 6+ messages in thread
From: Yong Liu @ 2015-06-08 2:21 UTC (permalink / raw)
To: dts
From: Marvin Liu <yong.liu@intel.com>
There're eight cases contained in this suite.
1) test_vxlan_ipv4_detect
Check whether FVL card can detect vxlan packets.
2) test_vxlan_ipv6_detect
Check whether FVL card can detect vxlan packets contain ipv6 header.
3) test_vxlan_ipv4_checksum_offload
Check hardware checksum work fine with vxlan packets.
4) test_vxlan_ipv6_checksum_offload
Check hardware checksum work fine with vxlan packets contain ipv6 header.
5) test_tunnel_filter
Check FVL tunnel filter can work with vxlan packets.
6) test_tunnel_filter_invalid
Check invalid tunnel filter command can normally handled.
7) test_perf_vxlan_tunnelfilter_performance_2ports
Performance test of vxlan tunnel filter on FVL.
8) test_perf_vxlan_checksum_performance_2ports
Performance test of vxlan hardware chksum offload.
Signed-off-by: Marvin Liu <yong.liu@intel.com>
diff --git a/tests/TestSuite_vxlan.py b/tests/TestSuite_vxlan.py
new file mode 100644
index 0000000..8b7329c
--- /dev/null
+++ b/tests/TestSuite_vxlan.py
@@ -0,0 +1,1101 @@
+"""
+DPDK Test suite.
+
+Test IPv4 fragmentation features in DPDK.
+
+"""
+
+import dts
+import string
+import re
+import time
+import os
+from pmd_output import PmdOutput
+
+from socket import AF_INET6
+from scapy.utils import struct, socket, wrpcap, rdpcap
+from scapy.layers.inet import Ether, IP, TCP, UDP
+from scapy.layers.inet6 import IPv6
+from scapy.layers.l2 import Dot1Q
+from scapy.layers.vxlan import Vxlan
+from scapy.layers.sctp import SCTP, SCTPChunkData
+from scapy.sendrecv import sniff
+from scapy.config import conf
+from scapy.route import *
+
+from test_case import TestCase
+from settings import HEADER_SIZE
+from etgen import IxiaPacketGenerator
+
+#
+#
+# Test class.
+#
+
+VXLAN_PORT = 4789
+PACKET_LEN = 128
+BIDIRECT = True
+
+
+class VxlanTestConfig(object):
+
+ """
+ Module for config/create/transmit vxlan packet
+ """
+
+ def __init__(self, test_case, **kwargs):
+ self.test_case = test_case
+ self.init()
+ for name in kwargs:
+ setattr(self, name, kwargs[name])
+
+ def init(self):
+ self.packets_config()
+
+ def packets_config(self):
+ """
+ Default vxlan packet format
+ """
+ self.pcap_file = 'vxlan.pcap'
+ self.capture_file = 'capture.pcap'
+ self.outer_mac_src = '00:00:10:00:00:00'
+ self.outer_mac_dst = '11:22:33:44:55:66'
+ self.outer_vlan = 'N/A'
+ self.outer_ip_src = '192.168.1.1'
+ self.outer_ip_dst = '192.168.1.2'
+ self.outer_ip_invalid = 0
+ self.outer_ip6_src = 'N/A'
+ self.outer_ip6_dst = 'N/A'
+ self.outer_ip6_invalid = 0
+ self.outer_udp_src = 63
+ self.outer_udp_dst = VXLAN_PORT
+ self.outer_udp_invalid = 0
+ self.vni = 1
+ self.inner_mac_src = '00:00:20:00:00:00'
+ self.inner_mac_dst = '00:00:20:00:00:01'
+ self.inner_vlan = 'N/A'
+ self.inner_ip_src = '192.168.2.1'
+ self.inner_ip_dst = '192.168.2.2'
+ self.inner_ip_invalid = 0
+ self.inner_ip6_src = 'N/A'
+ self.inner_ip6_dst = 'N/A'
+ self.inner_ip6_invalid = 0
+ self.payload_size = 18
+ self.inner_l4_type = 'UDP'
+ self.inner_l4_invalid = 0
+
+ def packet_type(self):
+ """
+ Return vxlan packet type
+ """
+ if self.outer_udp_dst != VXLAN_PORT:
+ if self.outer_ip6_src != 'N/A':
+ return 'PKT_RX_IPV6_HDR'
+ else:
+ return 'PKT_RX_IPV4_HDR'
+ else:
+ if self.outer_ip6_src != 'N/A':
+ return 'PKT_RX_TUNNEL_IPV6_HDR'
+ else:
+ return 'PKT_RX_TUNNEL_IPV4_HDR'
+
+ def create_pcap(self, scp=True):
+ """
+ Create pcap file and copy it to tester if configured
+ Return scapy packet object for later usage
+ """
+ if self.inner_l4_type == 'SCTP':
+ self.inner_payload = SCTPChunkData(data='X' * 16)
+ else:
+ self.inner_payload = ("X" * self.payload_size)
+
+ if self.inner_l4_type == 'TCP':
+ l4_pro = TCP()
+ elif self.inner_l4_type == 'SCTP':
+ l4_pro = SCTP()
+ else:
+ l4_pro = UDP()
+
+ if self.inner_ip6_src != 'N/A':
+ inner_l3 = IPv6()
+ else:
+ inner_l3 = IP()
+
+ if self.inner_vlan != 'N/A':
+ inner = Ether() / Dot1Q() / inner_l3 / l4_pro / self.inner_payload
+ inner[Dot1Q].vlan = self.inner_vlan
+ else:
+ inner = Ether() / inner_l3 / l4_pro / self.inner_payload
+
+ if self.inner_ip6_src != 'N/A':
+ inner[inner_l3.name].src = self.inner_ip6_src
+ inner[inner_l3.name].dst = self.inner_ip6_dst
+ else:
+ inner[inner_l3.name].src = self.inner_ip_src
+ inner[inner_l3.name].dst = self.inner_ip_dst
+
+ if self.inner_ip_invalid == 1:
+ inner[inner_l3.name].chksum = 0
+
+ # when udp checksum is 0, will skip checksum
+ if self.inner_l4_invalid == 1:
+ if self.inner_l4_type == 'SCTP':
+ inner[SCTP].chksum = 0
+ else:
+ inner[self.inner_l4_type].chksum = 1
+
+ inner[Ether].src = self.inner_mac_src
+ inner[Ether].dst = self.inner_mac_dst
+
+ if self.outer_ip6_src != 'N/A':
+ outer_l3 = IPv6()
+ else:
+ outer_l3 = IP()
+
+ if self.outer_vlan != 'N/A':
+ outer = Ether() / Dot1Q() / outer_l3 / UDP()
+ outer[Dot1Q].vlan = self.outer_vlan
+ else:
+ outer = Ether() / outer_l3 / UDP()
+
+ outer[Ether].src = self.outer_mac_src
+ outer[Ether].dst = self.outer_mac_dst
+
+ if self.outer_ip6_src != 'N/A':
+ outer[outer_l3.name].src = self.outer_ip6_src
+ outer[outer_l3.name].dst = self.outer_ip6_dst
+ else:
+ outer[outer_l3.name].src = self.outer_ip_src
+ outer[outer_l3.name].dst = self.outer_ip_dst
+
+ outer[UDP].src = self.outer_udp_src
+ outer[UDP].dst = self.outer_udp_dst
+
+ if self.outer_ip_invalid == 1:
+ outer[outer_l3.name].chksum = 0
+ # when udp checksum is 0, will skip checksum
+ if self.outer_udp_invalid == 1:
+ outer[UDP].chksum = 1
+
+ if self.outer_udp_dst == VXLAN_PORT:
+ self.pkt = outer / Vxlan(vni=self.vni) / inner
+ else:
+ self.pkt = outer / ("X" * self.payload_size)
+
+ if scp is True:
+ wrpcap(self.pcap_file, self.pkt)
+ self.test_case.tester.session.copy_file_to(self.pcap_file)
+
+ return self.pkt
+
+ def get_chksums(self, pcap=None, tester=False):
+ """
+ get chksum values of Outer and Inner packet L3&L4
+ Skip outer udp for it will be calculated by software
+ """
+ chk_sums = {}
+ if pcap is None:
+ if tester is True:
+ self.test_case.tester.session.copy_file_from(self.pcap_file)
+ pkts = rdpcap(self.pcap_file)
+ else:
+ if tester is True:
+ self.test_case.tester.session.copy_file_from(pcap)
+ pkts = rdpcap(pcap)
+
+ time.sleep(1)
+
+ if pkts[0].guess_payload_class(pkts[0]).name == "IP":
+ chk_sums['outer_ip'] = hex(pkts[0][IP].chksum)
+
+ if pkts[0].haslayer(Vxlan) == 1:
+ inner = pkts[0][Vxlan]
+ if inner.haslayer(IP) == 1:
+ chk_sums['inner_ip'] = hex(inner[IP].chksum)
+ if inner[IP].proto == 6:
+ chk_sums['inner_tcp'] = hex(inner[TCP].chksum)
+ if inner[IP].proto == 17:
+ chk_sums['inner_udp'] = hex(inner[UDP].chksum)
+ if inner[IP].proto == 132:
+ chk_sums['inner_sctp'] = hex(inner[SCTP].chksum)
+ elif inner.haslayer(IPv6) == 1:
+ if inner[IPv6].nh == 6:
+ chk_sums['inner_tcp'] = hex(inner[TCP].chksum)
+ if inner[IPv6].nh == 17:
+ chk_sums['inner_udp'] = hex(inner[UDP].chksum)
+ # scapy can not get sctp checksum, so extracted manually
+ if inner[IPv6].nh == 59:
+ load = str(inner[IPv6].payload)
+ chk_sums['inner_sctp'] = hex((ord(load[8]) << 24) |
+ (ord(load[9]) << 16) |
+ (ord(load[10]) << 8) |
+ (ord(load[11])))
+
+ return chk_sums
+
+ def send_pcap(self, iface=""):
+ """
+ Send vxlan pcap file by iface
+ """
+ self.test_case.tester.scapy_append(
+ 'pcap = rdpcap("%s")' % self.pcap_file)
+ self.test_case.tester.scapy_append(
+ 'sendp(pcap, iface="%s")' % iface)
+ self.test_case.tester.scapy_execute()
+
+ def pcap_len(self):
+ """
+ Return length of pcap packet, will plus 4 bytes crc
+ """
+ # add four bytes crc
+ return len(self.pkt) + 4
+
+
+class TestVxlan(TestCase, IxiaPacketGenerator):
+
+ def set_up_all(self):
+ """
+ vxlan Prerequisites
+ """
+ # this feature only enable in FVL now
+ self.verify(self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single"],
+ "Vxlan Only supported by Fortville")
+ # Based on h/w type, choose how many ports to use
+ ports = self.dut.get_ports()
+
+ # update IxiaPacketGenerator function by local
+ self.tester.extend_external_packet_generator(TestVxlan, self)
+
+ # Verify that enough ports are available
+ self.verify(len(ports) >= 2, "Insufficient ports for testing")
+ global valports
+ valports = [_ for _ in ports if self.tester.get_local_port(_) != -1]
+
+ self.portMask = dts.create_mask(valports[:2])
+
+ # Verify that enough threads are available
+ netdev = self.dut.ports_info[ports[0]]['port']
+ self.ports_socket = netdev.socket
+ cores = self.dut.get_core_list("1S/5C/2T", socket=self.ports_socket)
+ self.verify(cores is not None, "Insufficient cores for speed testing")
+ self.coremask = dts.create_mask(cores)
+
+ # start testpmd
+ self.pmdout = PmdOutput(self.dut)
+
+ # init port config
+ self.dut_port = valports[0]
+ self.dut_port_mac = self.dut.get_mac_address(self.dut_port)
+ tester_port = self.tester.get_local_port(self.dut_port)
+ self.tester_iface = self.tester.get_interface(tester_port)
+ self.recv_port = valports[1]
+ tester_recv_port = self.tester.get_local_port(self.recv_port)
+ self.recv_iface = self.tester.get_interface(tester_recv_port)
+
+ # invalid parameter
+ self.invalid_mac = "00:00:00:00:01"
+ self.invalid_ip = "192.168.1.256"
+ self.invalid_vlan = 4097
+ self.invalid_queue = 64
+
+ # vxlan payload length for performance test
+ # inner packet not contain crc, should need add four
+ self.vxlan_payload = PACKET_LEN - HEADER_SIZE['eth'] - \
+ HEADER_SIZE['ip'] - HEADER_SIZE['udp'] - \
+ HEADER_SIZE['vxlan'] - HEADER_SIZE['eth'] - \
+ HEADER_SIZE['ip'] - HEADER_SIZE['udp'] + 4
+
+ # performance test cycle
+ self.test_cycles = [
+ {'cores': '1S/1C/1T', 'Mpps': {}, 'pct': {}},
+ {'cores': '1S/1C/2T', 'Mpps': {}, 'pct': {}},
+ {'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {}}
+ ]
+
+ self.cal_type = [
+ {'Type': 'SOFTWARE ALL', 'csum': []},
+ {'Type': 'HW L3', 'csum': ['ip']},
+ {'Type': 'HW L4', 'csum': ['udp']},
+ {'Type': 'HW L3&L4', 'csum': ['ip', 'udp']},
+ ]
+
+ self.table_header = ['Calculate Type']
+ for test_cycle in self.test_cycles:
+ self.table_header.append("%s Mpps" % test_cycle['cores'])
+ self.table_header.append("% linerate")
+
+ # tunnel filter performance test
+ self.default_vlan = 1
+ self.tunnel_multiqueue = 2
+ self.tunnel_header = [
+ 'Packet', 'Filter', 'Queue', 'Mpps', '% linerate']
+ self.tunnel_perf = [
+ {'Packet': 'Normal', 'tunnel_filter': 'None',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'None',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac-ivlan',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac-ivlan-tenid',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac-tenid',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'omac-imac-tenid',
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'None',
+ 'recvqueue': 'Multi', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac-ivlan',
+ 'recvqueue': 'Multi', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac-ivlan-tenid',
+ 'recvqueue': 'Multi', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac-tenid',
+ 'recvqueue': 'Multi', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter': 'imac',
+ 'recvqueue': 'Multi', 'Mpps': {}, 'pct': {}},
+ {'Packet': 'Vxlan', 'tunnel_filter':
+ 'omac-imac-tenid', 'recvqueue': 'Multi'}
+ ]
+
+ def send_and_detect(self, **kwargs):
+ """
+ send vxlan packet and check whether testpmd detect the correct
+ packet type
+ """
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
+ " --nb-cores=8 --portmask=%(PORT)s --txqflags=0x0"
+ pmd_cmd = pmd_temp % {'TARGET': self.target,
+ 'COREMASK': self.coremask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORT': self.portMask}
+ self.dut.send_expect(pmd_cmd, "testpmd>", 30)
+
+ self.dut.send_expect("set fwd rxonly", "testpmd>", 10)
+ self.dut.send_expect("set verbose 1", "testpmd>", 10)
+ self.enable_vxlan(self.dut_port)
+ self.enable_vxlan(self.recv_port)
+
+ arg_str = ""
+ for arg in kwargs:
+ arg_str += "[%s = %s]" % (arg, kwargs[arg])
+
+ # create pcap file with supplied arguments
+ self.logger.info("send vxlan pkts %s" % arg_str)
+ config = VxlanTestConfig(self, **kwargs)
+ # now cloud filter will default enable L2 mac filter, so dst mac must
+ # be same
+ config.outer_mac_dst = self.dut_port_mac
+ config.create_pcap()
+ config.send_pcap(self.tester_iface)
+
+ # check whether detect vxlan type
+ out = self.dut.send_expect("start", "testpmd>", 10)
+ self.verify(config.packet_type() in out, "Vxlan Packet not detected")
+ out = self.dut.send_expect("stop", "testpmd>", 10)
+ self.dut.send_expect("quit", "#", 10)
+
+ def increment_ip_address(self, addr):
+ """
+ Returns the IP address from a given one, like
+ 192.168.1.1 ->192.168.1.2
+ If disable ip hw chksum, csum routine will increase ip
+ """
+ ip2int = lambda ipstr: struct.unpack('!I', socket.inet_aton(ipstr))[0]
+ x = ip2int(addr)
+ int2ip = lambda n: socket.inet_ntoa(struct.pack('!I', n))
+ return int2ip(x + 1)
+
+ def increment_ipv6_address(self, addr):
+ """
+ Returns the IP address from a given one, like
+ FE80:0:0:0:0:0:0:0 -> FE80::1
+ csum routine will increase ip
+ """
+ ipv6addr = struct.unpack('!8H', socket.inet_pton(AF_INET6, addr))
+ addr = list(ipv6addr)
+ addr[7] += 1
+ ipv6 = socket.inet_ntop(AF_INET6, struct.pack(
+ '!8H', addr[0], addr[1], addr[2], addr[3], addr[4], addr[5],
+ addr[6], addr[7]))
+ return ipv6
+
+ def send_and_check(self, **kwargs):
+ """
+ send vxlan packet and check whether receive packet with correct
+ checksum
+ """
+ # create pcap file with supplied arguments
+ args = {}
+ for arg in kwargs:
+ if "invalid" not in arg:
+ args[arg] = kwargs[arg]
+
+ config = VxlanTestConfig(self, **args)
+ # now cloud filter will default enable L2 mac filter, so dst mac must
+ # be same
+ config.outer_mac_dst = self.dut_port_mac
+ # csum function will auto add outer ipv src address
+ if config.outer_ip6_src != "N/A":
+ config.outer_ip6_src = self.increment_ipv6_address(
+ config.outer_ip6_src)
+ else:
+ config.outer_ip_src = self.increment_ip_address(
+ config.outer_ip_src)
+
+ # csum function will auto add vxlan inner ipv src address
+ if config.outer_udp_dst == VXLAN_PORT:
+ if config.inner_ip6_src != "N/A":
+ config.inner_ip6_src = self.increment_ipv6_address(
+ config.inner_ip6_src)
+ else:
+ config.inner_ip_src = self.increment_ip_address(
+ config.inner_ip_src)
+
+ # extract the checksum value of vxlan packet
+ config.create_pcap()
+ chksums_ref = config.get_chksums()
+ self.logger.info("chksums_ref" + str(chksums_ref))
+
+ # start testpmd with 2queue/1port
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
+ " --nb-cores=8 --portmask=%(PORT)s --txqflags=0x0"
+ pmd_cmd = pmd_temp % {'TARGET': self.target,
+ 'COREMASK': self.coremask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORT': self.portMask}
+ self.dut.send_expect(pmd_cmd, "testpmd>", 30)
+
+ # enable tx checksum offload
+ self.dut.send_expect("set fwd csum", "testpmd>", 10)
+ self.csum_set_type('ip', self.dut_port)
+ self.csum_set_type('outer-ip', self.dut_port)
+ self.csum_set_type('udp', self.dut_port)
+ self.csum_set_type('tcp', self.dut_port)
+ self.csum_set_type('sctp', self.dut_port)
+ self.csum_set_type('ip', self.recv_port)
+ self.csum_set_type('outer-ip', self.recv_port)
+ self.csum_set_type('udp', self.recv_port)
+ self.csum_set_type('tcp', self.recv_port)
+ self.csum_set_type('sctp', self.recv_port)
+ self.dut.send_expect("csum parse_tunnel on %d" %
+ self.dut_port, "testpmd>", 10)
+ self.dut.send_expect("csum parse_tunnel on %d" %
+ self.recv_port, "testpmd>", 10)
+
+ self.enable_vxlan(self.dut_port)
+ self.enable_vxlan(self.recv_port)
+
+ # log the vxlan format
+ arg_str = ""
+ for arg in kwargs:
+ arg_str += "[%s = %s]" % (arg, kwargs[arg])
+
+ self.logger.info("vxlan packet %s" % arg_str)
+
+ out = self.dut.send_expect("start", "testpmd>", 10)
+
+ # create pcap file with supplied arguments
+ config = VxlanTestConfig(self, **kwargs)
+ config.outer_mac_dst = self.dut_port_mac
+ config.create_pcap()
+
+ # remove tempory files
+ self.tester.send_expect("rm -rf /root/%s" % config.capture_file, "# ")
+ # save the capture packet into pcap format
+ self.tester.scapy_background()
+ self.tester.scapy_append(
+ 'p=sniff(iface="%s",count=1,timeout=5)' % self.recv_iface)
+ self.tester.scapy_append(
+ 'wrpcap(\"/root/%s\", p)' % config.capture_file)
+ self.tester.scapy_foreground()
+
+ config.send_pcap(self.tester_iface)
+ time.sleep(5)
+
+ # extract the checksum offload from saved pcap file
+ chksums = config.get_chksums(pcap=config.capture_file, tester=True)
+ os.remove(config.capture_file)
+ self.logger.info("chksums" + str(chksums))
+
+ out = self.dut.send_expect("stop", "testpmd>", 10)
+
+ # verify detected l4 invalid checksum
+ if "inner_l4_invalid" in kwargs and config.inner_l4_type is not 'UDP':
+ self.verify(self.pmdout.get_pmd_value("Bad-l4csum:", out)
+ == 1, "Failed to count inner l4 chksum error")
+
+ # verify detected l3 invalid checksum
+ if "inner_ip_invalid" in kwargs:
+ self.verify(self.pmdout.get_pmd_value("Bad-ipcsum:", out)
+ == 1, "Failed to count inner ip chksum error")
+
+ self.dut.send_expect("quit", "#", 10)
+
+ # verify saved pcap checksum same to expected checksum
+ for key in chksums_ref:
+ self.verify(chksums[key] == chksums_ref[
+ key], "%s not matched to %s" % (key, chksums_ref[key]))
+
+ def filter_and_check(self, filter_type="imac-ivlan", queue_id=3,
+ vlan=False, remove=False):
+ """
+ send vxlan packet and check whether receive packet in assigned queue
+ """
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
+ " --nb-cores=8 --portmask=%(PORT)s --txqflags=0x0"
+ pmd_cmd = pmd_temp % {'TARGET': self.target,
+ 'COREMASK': self.coremask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORT': self.portMask}
+ self.dut.send_expect(pmd_cmd, "testpmd>", 30)
+
+ self.dut.send_expect("set fwd rxonly", "testpmd>", 10)
+ self.dut.send_expect("set verbose 1", "testpmd>", 10)
+ self.enable_vxlan(self.dut_port)
+ self.enable_vxlan(self.recv_port)
+
+ if vlan is not False:
+ config = VxlanTestConfig(self, inner_vlan=vlan)
+ vlan_id = vlan
+ else:
+ config = VxlanTestConfig(self)
+ vlan_id = 1
+
+ # now cloud filter will default enable L2 mac filter, so dst mac must
+ # be same
+ config.outer_mac_dst = self.dut_port_mac
+
+ args = [self.dut_port, config.outer_mac_dst, config.inner_mac_dst,
+ config.inner_ip_dst, vlan_id, filter_type, config.vni,
+ queue_id]
+
+ self.tunnel_filter_add(*args)
+
+ # invalid case request to remove tunnel filter
+ if remove is True:
+ queue_id = 0
+ args = [self.dut_port, config.outer_mac_dst, config.inner_mac_dst,
+ config.inner_ip_dst, vlan_id, filter_type, config.vni,
+ queue_id]
+ self.tunnel_filter_del(*args)
+
+ # send vxlan packet
+ config.create_pcap()
+ config.send_pcap(self.tester_iface)
+ out = self.dut.send_expect("start", "testpmd>", 10)
+
+ queue = -1
+ pattern = re.compile("VNI = (\d) - Receive queue=0x(\d)")
+ m = pattern.search(out)
+ if m is not None:
+ queue = m.group(2)
+
+ # verify received in expected queue
+ self.verify(queue_id == int(queue), "invalid receive queue")
+
+ self.dut.send_expect("stop", "testpmd>", 10)
+ self.dut.send_expect("quit", "#", 10)
+
+ def test_vxlan_ipv4_detect(self):
+ """
+ verify vxlan packet detection
+ """
+ # check normal packet
+ self.send_and_detect(outer_udp_dst=1234)
+ # check vxlan + UDP inner packet
+ self.send_and_detect(inner_l4_type='UDP')
+ # check vxlan + TCP inner packet
+ self.send_and_detect(inner_l4_type='TCP')
+ # check vxlan + SCTP inner packet
+ self.send_and_detect(inner_l4_type='SCTP')
+ # check vxlan + vlan inner packet
+ self.send_and_detect(outer_vlan=1)
+ # check vlan vxlan + vlan inner packet
+ self.send_and_detect(outer_vlan=1, inner_vlan=1)
+
+ def test_vxlan_ipv6_detect(self):
+ """
+ verify vxlan packet detection with ipv6 header
+ """
+ # check normal ipv6 packet
+ self.send_and_detect(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ outer_udp_dst=1234)
+ # check ipv6 vxlan + UDP inner packet
+ self.send_and_detect(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_type='UDP')
+ # check ipv6 vxlan + TCP inner packet
+ self.send_and_detect(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_type='TCP')
+ # check ipv6 vxlan + SCTP inner packet
+ self.send_and_detect(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_type='SCTP')
+
+ def test_vxlan_ipv4_checksum_offload(self):
+ """
+ verify vxlan packet checksum offload
+ """
+ # check normal packet + ip checksum invalid
+ self.send_and_check(outer_ip_invalid=1, outer_udp_dst=1234)
+ # check vxlan packet + inner ip checksum invalid
+ self.send_and_check(inner_ip_invalid=1)
+ # check vxlan packet + outer ip checksum invalid
+ self.send_and_check(outer_ip_invalid=1)
+ # check vxlan packet + outer ip + inner ip checksum invalid
+ self.send_and_check(outer_ip_invalid=1, inner_ip_invalid=1)
+ # check vxlan packet + inner udp checksum invalid
+ self.send_and_check(inner_l4_invalid=1)
+ # check vxlan packet + inner tcp checksum invalid
+ self.send_and_check(inner_l4_invalid=1, inner_l4_type='TCP')
+ # check vxlan packet + inner sctp checksum invalid
+ self.send_and_check(inner_l4_invalid=1, inner_l4_type='SCTP')
+ # check vlan vxlan packet + outer ip checksum invalid
+ self.send_and_check(outer_vlan=1, outer_ip_invalid=1)
+ # check vlan vxlan packet + inner ip checksum invalid
+ self.send_and_check(outer_vlan=1, inner_ip_invalid=1)
+ # check vlan vxlan packet + outer&inner ip checksum invalid
+ self.send_and_check(
+ outer_vlan=1, outer_ip_invalid=1, inner_ip_invalid=1)
+ # check vlan vxlan packet + inner vlan + outer ip checksum invalid
+ self.send_and_check(outer_vlan=1, inner_vlan=1, outer_ip_invalid=1)
+ # check vlan vxlan packet + inner vlan + inner ip checksum invalid
+ self.send_and_check(outer_vlan=1, inner_vlan=1, inner_ip_invalid=1)
+ # check vlan vxlan packet + inner vlan + outer&inner ip checksum
+ # invalid
+ self.send_and_check(
+ outer_vlan=1, inner_vlan=1, outer_ip_invalid=1, inner_ip_invalid=1)
+ # check vlan vxlan packet + inner vlan + inner udp checksum invalid
+ self.send_and_check(
+ outer_vlan=1, inner_l4_invalid=1, inner_l4_type='UDP')
+ # check vlan vxlan packet + inner vlan + inner tcp checksum invalid
+ self.send_and_check(
+ outer_vlan=1, inner_l4_invalid=1, inner_l4_type='TCP')
+ # check vlan vxlan packet + inner vlan + inner sctp checksum invalid
+ self.send_and_check(
+ outer_vlan=1, inner_l4_invalid=1, inner_l4_type='SCTP')
+
+ def test_vxlan_ipv6_checksum_offload(self):
+ """
+ verify vxlan packet checksum offload with ipv6 header
+ not support ipv6 + sctp
+ """
+ # check normal ipv6 packet
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1")
+ # check normal ipv6 packet + ip checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ outer_udp_dst=1234)
+ # check ipv6 vxlan packet + inner ip checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_ip_invalid=1)
+ # check ipv6 vxlan packet + inner udp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='UDP')
+ # check ipv6 vxlan packet + inner udp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='UDP')
+ # check ipv6 vxlan packet + inner tcp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='TCP')
+ # check ipv6 vlan vxlan packet + inner udp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='UDP',
+ outer_vlan=1)
+ # check ipv6 vlan vxlan packet + inner tcp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='TCP',
+ outer_vlan=1)
+ # check ipv6 vlan vxlan packet + vlan + inner udp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='UDP',
+ outer_vlan=1, inner_vlan=1)
+ # check ipv6 vlan vxlan packet + vlan + inner tcp checksum invalid
+ self.send_and_check(outer_ip6_src="FE80:0:0:0:0:0:0:0",
+ outer_ip6_dst="FE80:0:0:0:0:0:0:1",
+ inner_l4_invalid=1, inner_l4_type='TCP',
+ outer_vlan=1, inner_vlan=1)
+
+ def test_tunnel_filter(self):
+ """
+ verify tunnel filter feature
+ """
+ # check inner mac + inner vlan filter can work
+ self.filter_and_check(filter_type="imac-ivlan", vlan=1)
+ # check inner mac + inner vlan + tunnel id filter can work
+ self.filter_and_check(filter_type="imac-ivlan-tenid", vlan=1)
+ # check inner mac + tunnel id filter can work
+ self.filter_and_check(filter_type="imac-tenid")
+ # check inner mac filter can work
+ self.filter_and_check(filter_type="imac")
+ # check outer mac + inner mac + tunnel id filter can work
+ self.filter_and_check(filter_type="omac-imac-tenid")
+ # iip not supported by now
+ # self.filter_and_check(filter_type="iip")
+
+ def test_tunnel_filter_invalid(self):
+ """
+ verify tunnel filter parameter check function
+ """
+ # invalid parameter
+ vlan_id = 1
+ filter_type = 'omac-imac-tenid'
+ queue_id = 3
+
+ self.filter_and_check(filter_type="imac", remove=True)
+ config = VxlanTestConfig(self)
+ config.outer_mac_dst = self.dut_port_mac
+
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --disable-rss --rxq=4 --txq=4" + \
+ " --nb-cores=8 --portmask=%(PORT)s --txqflags=0x0"
+ pmd_cmd = pmd_temp % {'TARGET': self.target,
+ 'COREMASK': self.coremask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORT': self.portMask}
+ self.dut.send_expect(pmd_cmd, "testpmd>", 30)
+
+ self.enable_vxlan(self.dut_port)
+ self.enable_vxlan(self.recv_port)
+ args = [self.dut_port, config.outer_mac_dst, self.invalid_mac,
+ config.inner_ip_dst, vlan_id, filter_type, config.vni,
+ queue_id]
+ out = self.tunnel_filter_add(*args)
+ self.verify("Bad arguments" in out, "Failed to detect invalid mac")
+ args = [self.dut_port, config.outer_mac_dst, config.inner_mac_dst,
+ self.invalid_ip, vlan_id, filter_type, config.vni, queue_id]
+ out = self.tunnel_filter_add(*args)
+ self.verify("Bad arguments" in out, "Failed to detect invalid ip")
+ args = [self.dut_port, config.outer_mac_dst, config.inner_mac_dst,
+ config.inner_ip_dst, self.invalid_vlan, filter_type,
+ config.vni, queue_id]
+ out = self.tunnel_filter_add(*args)
+ self.verify("Input/output error" in out,
+ "Failed to detect invalid vlan")
+ args = [self.dut_port, config.outer_mac_dst, config.inner_mac_dst,
+ config.inner_ip_dst, vlan_id, filter_type, config.vni,
+ self.invalid_queue]
+ out = self.tunnel_filter_add(*args)
+ self.verify("Input/output error" in out,
+ "Failed to detect invalid queue")
+
+ self.dut.send_expect("stop", "testpmd>", 10)
+ self.dut.send_expect("quit", "#", 10)
+
+ def config_tunnelfilter(self, dut_port, recv_port, perf_config, pcapfile):
+ pkts = []
+ config = VxlanTestConfig(self, payload_size=self.vxlan_payload - 4)
+ config.inner_vlan = self.default_vlan
+ config.outer_mac_dst = self.dut.get_mac_address(dut_port)
+ config.pcap_file = pcapfile
+
+ tun_filter = perf_config['tunnel_filter']
+ recv_queue = perf_config['recvqueue']
+ # there's known bug that if enable vxlan, rss will be disabled
+ if tun_filter == "None" and recv_queue == 'Multi':
+ print dts.RED("RSS and Tunel filter can't enable in the same time")
+ else:
+ self.enable_vxlan(dut_port)
+
+ if tun_filter != 'None':
+ args = [self.dut_port, config.outer_mac_dst,
+ config.inner_mac_dst, config.inner_ip_dst,
+ config.inner_vlan, tun_filter,
+ config.vni, 0]
+ self.tunnel_filter_add(*args)
+
+ if perf_config['Packet'] == 'Normal':
+ config.outer_udp_dst = 63
+ config.outer_mac_dst = self.dut.get_mac_address(dut_port)
+ config.payload_size = PACKET_LEN - \
+ HEADER_SIZE['eth'] - HEADER_SIZE['ip'] - HEADER_SIZE['udp']
+
+ # add default pkt into pkt list
+ pkt = config.create_pcap(scp=False)
+ pkts.append(pkt)
+
+ # add other pkts into pkt list when enable multi receive queues
+ if recv_queue == 'Multi' and tun_filter != 'None':
+ for queue in range(self.tunnel_multiqueue - 1):
+ if 'imac' in tun_filter:
+ config.inner_mac_dst = "00:00:20:00:00:0%d" % (
+ queue + 2)
+ if 'ivlan' in tun_filter:
+ config.inner_vlan = (queue + 2)
+ if 'tenid' in tun_filter:
+ config.vni = (queue + 2)
+
+ # add tunnel filter the same as pkt
+ pkt = config.create_pcap(scp=False)
+ pkts.append(pkt)
+
+ args = [dut_port, config.outer_mac_dst,
+ config.inner_mac_dst, config.inner_ip_dst,
+ config.inner_vlan, tun_filter,
+ config.vni, (queue + 1)]
+ self.tunnel_filter_add(*args)
+
+ # save pkt list into pcap file
+ wrpcap(config.pcap_file, pkts)
+ self.tester.session.copy_file_to(config.pcap_file)
+
+ def ip_random(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 ipIncrHost')
+ self.add_tcl_cmd('ip config -sourceIpAddrRepeatCount %d' % 64)
+ self.add_tcl_cmd('ip config -destIpAddr "%s"' % dst)
+ self.add_tcl_cmd('ip config -destIpMask "255.255.0.0" ')
+ self.add_tcl_cmd('ip config -destIpAddrMode ipRandom')
+ self.add_tcl_cmd('ip config -destIpAddrRepeatCount 65536')
+ 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 %d" % proto)
+ 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 test_perf_vxlan_tunnelfilter_performance_2ports(self):
+ dts.results_table_add_header(self.tunnel_header)
+ core_list = self.dut.get_core_list(
+ '1S/%dC/1T' % (self.tunnel_multiqueue * 2 + 1),
+ socket=self.ports_socket)
+ core_mask = dts.create_mask(core_list)
+
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --disable-rss --rxq=2 --txq=2" + \
+ " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
+
+ for perf_config in self.tunnel_perf:
+ tun_filter = perf_config['tunnel_filter']
+ recv_queue = perf_config['recvqueue']
+ print dts.GREEN("Measure tunnel performance of [%s %s %s]"
+ % (perf_config['Packet'], tun_filter, recv_queue))
+
+ if tun_filter == "None" and recv_queue == "Multi":
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --rss-udp --rxq=2 --txq=2" + \
+ " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
+
+ pmd_cmd = pmd_temp % {'TARGET': self.target,
+ 'COREMASK': core_mask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORT': self.portMask}
+ self.dut.send_expect(pmd_cmd, "testpmd> ", 100)
+
+ # config flow
+ self.config_tunnelfilter(
+ self.dut_port, self.recv_port, perf_config, "flow1.pcap")
+ # config the flows
+ tgen_input = []
+ tgen_input.append((self.tester.get_local_port(self.dut_port),
+ self.tester.get_local_port(self.recv_port),
+ "flow1.pcap"))
+
+ if BIDIRECT:
+ self.config_tunnelfilter(
+ self.recv_port, self.dut_port, perf_config, "flow2.pcap")
+ tgen_input.append((self.tester.get_local_port(self.recv_port),
+ self.tester.get_local_port(self.dut_port),
+ "flow2.pcap"))
+
+ self.dut.send_expect("set fwd io", "testpmd>", 10)
+ self.dut.send_expect("start", "testpmd>", 10)
+
+ if BIDIRECT:
+ wirespeed = self.wirespeed(self.nic, PACKET_LEN, 2)
+ else:
+ wirespeed = self.wirespeed(self.nic, PACKET_LEN, 1)
+
+ if recv_queue == 'Multi' and tun_filter == "None":
+ ip_ori = self.ip
+ self.ip = self.ip_random
+
+ # run traffic generator
+ _, pps = self.tester.traffic_generator_throughput(tgen_input)
+
+ if recv_queue == 'Multi' and tun_filter == "None":
+ self.ip = ip_ori
+
+ pps /= 1000000.0
+ perf_config['Mpps'] = pps
+ perf_config['pct'] = pps * 100 / wirespeed
+
+ out = self.dut.send_expect("stop", "testpmd>", 10)
+ self.dut.send_expect("quit", "# ", 10)
+
+ # verify every queue work fine
+ if recv_queue == 'Multi':
+ for queue in range(self.tunnel_multiqueue):
+ self.verify("Queue= %d -> TX Port"
+ % (queue) in out,
+ "Queue %d no traffic" % queue)
+
+ table_row = [perf_config['Packet'], tun_filter, recv_queue,
+ perf_config['Mpps'], perf_config['pct']]
+
+ dts.results_table_add_row(table_row)
+
+ dts.results_table_print()
+
+ def test_perf_vxlan_checksum_performance_2ports(self):
+ config = VxlanTestConfig(self, payload_size=self.vxlan_payload)
+ config.outer_mac_dst = self.dut.get_mac_address(self.dut_port)
+ config.pcap_file = "vxlan1.pcap"
+ config.create_pcap()
+ if BIDIRECT:
+ config.outer_mac_dst = self.dut.get_mac_address(self.recv_port)
+ config.pcap_file = "vxlan2.pcap"
+ config.create_pcap()
+
+ all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
+ # configure flows
+ tgen_input = []
+ tgen_input.append((self.tester.get_local_port(self.dut_port),
+ self.tester.get_local_port(self.recv_port),
+ "vxlan1.pcap"))
+ if BIDIRECT:
+ tgen_input.append((self.tester.get_local_port(self.recv_port),
+ self.tester.get_local_port(self.dut_port),
+ "vxlan2.pcap"))
+
+ # socket/core/thread
+ for test_cycle in self.test_cycles:
+ core_config = test_cycle['cores']
+
+ # take care the corelist when enable numa
+ core_list = self.dut.get_core_list(core_config,
+ socket=self.ports_socket)
+
+ core_mask = dts.create_mask(core_list)
+
+ cmd_temp = "./%(TARGET)s/app/testpmd -c %(CORE)s " + \
+ "-n %(CHANNEL)d -- -i --disable-rss --coremask=" + \
+ "%(COREMASK)s --portmask=%(PORTMASK)s"
+ cmd = cmd_temp % {'TARGET': self.target,
+ 'CORE': all_cores_mask,
+ 'COREMASK': core_mask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORTMASK': self.portMask}
+
+ self.dut.send_expect(cmd, "testpmd> ", 100)
+ self.dut.send_expect("set fwd csum", "testpmd>", 10)
+ self.dut.send_expect("csum parse_tunnel on %d" %
+ self.dut_port, "testpmd>", 10)
+ self.dut.send_expect("csum parse_tunnel on %d" %
+ self.recv_port, "testpmd>", 10)
+ self.enable_vxlan(self.dut_port)
+ self.enable_vxlan(self.recv_port)
+
+ # different calculate type
+ for cal in self.cal_type:
+ print dts.GREEN("Measure checksum performance of [%s %s]"
+ % (test_cycle['cores'],
+ cal['csum']))
+ for pro in cal['csum']:
+ self.csum_set_type(pro, self.dut_port)
+ self.csum_set_type(pro, self.recv_port)
+
+ self.dut.send_expect("start", "testpmd>", 10)
+
+ frame_size = config.pcap_len()
+ if BIDIRECT:
+ wirespeed = self.wirespeed(self.nic, frame_size, 2)
+ else:
+ wirespeed = self.wirespeed(self.nic, frame_size, 1)
+ # run traffic generator
+ _, pps = self.tester.traffic_generator_throughput(tgen_input)
+
+ pps /= 1000000.0
+ test_cycle['Mpps'][cal['Type']] = pps
+ test_cycle['pct'][cal['Type']] = pps * 100 / wirespeed
+
+ self.dut.send_expect("stop", "testpmd>", 10)
+
+ self.dut.send_expect("quit", "# ", 10)
+
+ dts.results_table_add_header(self.table_header)
+
+ # save the results
+ for cal in self.cal_type:
+ table_row = [cal['Type']]
+ for test_cycle in self.test_cycles:
+ table_row.append(test_cycle['Mpps'][cal['Type']])
+ table_row.append(test_cycle['pct'][cal['Type']])
+
+ dts.results_table_add_row(table_row)
+
+ dts.results_table_print()
+
+ def enable_vxlan(self, port):
+ self.dut.send_expect("rx_vxlan_port add %d %d"
+ % (VXLAN_PORT, port),
+ "testpmd>", 10)
+
+ def csum_set_type(self, proto, port):
+ out = self.dut.send_expect("csum set %s hw %d" % (proto, port),
+ "testpmd>", 10)
+ self.verify("Bad arguments" not in out, "Failed to set vxlan csum")
+ self.verify("error" not in out, "Failed to set vxlan csum")
+
+ def tunnel_filter_add(self, *args):
+ # tunnel_filter add port_id outer_mac inner_mac ip inner_vlan
+ # tunnel_type(vxlan)
+ # filter_type
+ # (imac-ivlan|imac-ivlan-tenid|imac-tenid|imac|omac-imac-tenid|iip)
+ # tenant_id queue_num
+ out = self.dut.send_expect("tunnel_filter add %d " % args[0] +
+ "%s %s %s " % (args[1], args[2], args[3]) +
+ "%d vxlan %s " % (args[4], args[5]) +
+ "%d %d" % (args[6], args[7]),
+ "testpmd>", 10)
+ self.verify("Bad arguments" not in out, "Failed to add tunnel filter")
+ self.verify("error" not in out, "Failed to add tunnel filter")
+ return out
+
+ def tunnel_filter_del(self, *args):
+ out = self.dut.send_expect("tunnel_filter rm %d " % args[0] +
+ "%s %s %s" % (args[1], args[2], args[3]) +
+ "%d vxlan %s " % (args[4], args[5]) +
+ "%d %d" % (args[6], args[7]),
+ "testpmd>", 10)
+ self.verify("Bad arguments" not in out,
+ "Failed to remove tunnel filter")
+ self.verify("error" not in out, "Failed to remove tunnel filter")
+ return out
+
+ def set_up(self):
+ """
+ Run before each test case.
+ """
+ pass
+
+ def tear_down(self):
+ """
+ Run after each test case.
+ """
+ self.dut.kill_all()
+
+ def tear_down_all(self):
+ """
+ Run after each test suite.
+ """
+ pass
--
1.9.3
^ permalink raw reply [flat|nested] 6+ messages in thread
* [dts] [PATCH] Enhance vxlan checksum offload performance test case.
2015-06-08 2:21 [dts] [PATCH 0/4] Add vxlan function and performance suite Yong Liu
` (3 preceding siblings ...)
2015-06-08 2:21 ` [dts] [PATCH 4/4] Add vxlan test suite Yong Liu
@ 2015-06-09 6:38 ` Yong Liu
4 siblings, 0 replies; 6+ messages in thread
From: Yong Liu @ 2015-06-09 6:38 UTC (permalink / raw)
To: dts
From: Marvin Liu <yong.liu@intel.com>
Add mutli queue performance meansure in checksum offload case.
Optimize test plan for checksum command change in DPDK2.1.
Signed-off-by: Marvin Liu <yong.liu@intel.com>
diff --git a/test_plans/vxlan_test_plan.rst b/test_plans/vxlan_test_plan.rst
index 55dc227..b7961f9 100644
--- a/test_plans/vxlan_test_plan.rst
+++ b/test_plans/vxlan_test_plan.rst
@@ -57,12 +57,13 @@ Test Case: Vxlan ipv4 packet detect
===================================
Start testpmd with tunneling packet type to vxlan::
- testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+ testpmd -c ffff -n 4 -- -i --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2 --txqflags=0x0
Set rxonly packet forwarding mode and enable verbose log::
set fwd rxonly
set verbose 1
+ rx_vxlan_port add 4789 0
Send packet as table listed and check dumped packet type the same as column
"Rx packet type".
@@ -89,12 +90,13 @@ Test Case: Vxlan ipv6 packet detect
===================================
Start testpmd with tunneling packet type to vxlan::
- testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+ testpmd -c ffff -n 4 -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2 --txqflags=0x0
Set rxonly packet forwarding mode and enable verbose log::
set fwd rxonly
set verbose 1
+ rx_vxlan_port add 4789 0
Send ipv6 packet as table listed and check dumped packet type the same as
column "Rx packet type".
@@ -121,25 +123,28 @@ Test Case: Vxlan ipv4 checksum offload
Start testpmd with tunneling packet type to vxlan::
- testpmd -c ffff -n 4 -- -i --tunnel-type=1 --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+ testpmd -c ffff -n 4 -- -i --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2 --txqflags=0x0
Set csum packet forwarding mode and enable verbose log::
set fwd csum
set verbose 1
+ rx_vxlan_port add 4789 0
Enable VXLAN protocal on ports::
rx_vxlan_port add 4789 0
rx_vxlan_port add 4789 1
-Enable IP,UDP,TCP,SCTP,VXLAN checksum offload::
+Enable IP,UDP,TCP,SCTP,OUTER-IP checksum offload::
- tx_checksum set 0 ip hw
- tx_checksum set 0 udp hw
- tx_checksum set 0 tcp hw
- tx_checksum set 0 sctp hw
- tx_checksum set 0 vxlan hw
+ csum parse_tunnel on 0
+ csum parse_tunnel on 1
+ csum set ip hw 0
+ csum set udp hw 0
+ csum set tcp hw 0
+ csum set stcp hw 0
+ csum set outer-ip hw 0
Send packet with valid checksum and check there's no chksum error counter
increased.
@@ -230,10 +235,13 @@ Enable VXLAN protocal on ports::
Enable IP,UDP,TCP,SCTP,VXLAN checksum offload::
- tx_checksum set 0 ip hw
- tx_checksum set 0 udp hw
- tx_checksum set 0 tcp hw
- tx_checksum set 0 sctp hw
+ csum parse_tunnel on 0
+ csum parse_tunnel on 1
+ csum set ip hw 0
+ csum set udp hw 0
+ csum set tcp hw 0
+ csum set stcp hw 0
+ csum set outer-ip hw 0
Send ipv6 packet with valid checksum and check there's no chksum error counter
increased.
@@ -281,7 +289,7 @@ Test Case: Clould Filter
Start testpmd with tunneling packet type to vxlan and disable receive side
scale for hardware limitation::
- testpmd -c ffff -n 4 -- -i --tunnel-type=1 --disable-rss --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2
+ testpmd -c ffff -n 4 -- -i --disable-rss --rxq=4 --txq=4 --nb-cores=8 --nb-ports=2 --txqflags=0x0
Set rxonly packet forwarding mode and enable verbose log::
@@ -330,32 +338,26 @@ Test Case: Vxlan Checksum Offload Performance Benchmarking
==========================================================
The throughput is measured for each of these cases for vxlan tx checksum
-offload of "all by software", "inner l3 offload by hardware", "inner l4
-offload by hardware", "inner l3&l4 offload by hardware", "outer l3 offload
-by hardware", "outer l4 offload by hardware", "outer l3&l4 offload by
-hardware", "all by hardware".
+offload of "all by software", "L3 offload by hardware", "L4 offload by
+hardware", "l3&l4 offload by hardware".
The results are printed in the following table:
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| Calculate Type | 1S/1C/1T Mpps | % linerate | 1S/1C/2T Mpps | % linerate | 1S/2C/1T Mpps | % linerate |
-+================+===============+============+===============+============+===============+============+
-| SOFTWARE ALL | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HW OUTER L3 | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HW OUTER L4 | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HW OUTER L3&L4 | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HW INNER L3 | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HW INNER L4 | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HW INNER L3&L4 | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
-| HARDWARE ALL | | | | | | |
-+----------------+---------------+------------+---------------+------------+---------------+------------+
++----------------+--------+--------+------------+
+| Calculate Type | Queues | Mpps | % linerate |
++================+========+========+============+
+| SOFTWARE ALL | Single | | |
++----------------+--------+--------+------------+
+| HW L4 | Single | | |
++----------------+--------+--------+------------+
+| HW L3&L4 | Single | | |
++----------------+--------+--------+------------+
+| SOFTWARE ALL | Multi | | |
++----------------+--------+--------+------------+
+| HW L4 | Multi | | |
++----------------+--------+--------+------------+
+| HW L3&L4 | Multi | | |
++----------------+--------+--------+------------+
Test Case: Vxlan Tunnel filter Performance Benchmarking
=======================================================
diff --git a/tests/TestSuite_vxlan.py b/tests/TestSuite_vxlan.py
index 8b7329c..6d8f6f8 100644
--- a/tests/TestSuite_vxlan.py
+++ b/tests/TestSuite_vxlan.py
@@ -182,8 +182,9 @@ class VxlanTestConfig(object):
else:
self.pkt = outer / ("X" * self.payload_size)
+ wrpcap(self.pcap_file, self.pkt)
+
if scp is True:
- wrpcap(self.pcap_file, self.pkt)
self.test_case.tester.session.copy_file_to(self.pcap_file)
return self.pkt
@@ -306,24 +307,25 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
HEADER_SIZE['vxlan'] - HEADER_SIZE['eth'] - \
HEADER_SIZE['ip'] - HEADER_SIZE['udp'] + 4
- # performance test cycle
- self.test_cycles = [
- {'cores': '1S/1C/1T', 'Mpps': {}, 'pct': {}},
- {'cores': '1S/1C/2T', 'Mpps': {}, 'pct': {}},
- {'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {}}
- ]
-
self.cal_type = [
- {'Type': 'SOFTWARE ALL', 'csum': []},
- {'Type': 'HW L3', 'csum': ['ip']},
- {'Type': 'HW L4', 'csum': ['udp']},
- {'Type': 'HW L3&L4', 'csum': ['ip', 'udp']},
+ {'Type': 'SOFTWARE ALL', 'csum': [], 'recvqueue': 'Single',
+ 'Mpps': {}, 'pct': {}},
+ {'Type': 'HW L4', 'csum': ['udp'], 'recvqueue': 'Single',
+ 'Mpps': {}, 'pct': {}},
+ {'Type': 'HW L3&L4', 'csum': ['ip', 'udp', 'outer-ip'],
+ 'recvqueue': 'Single', 'Mpps': {}, 'pct': {}},
+ {'Type': 'SOFTWARE ALL', 'csum': [], 'recvqueue': 'Multi',
+ 'Mpps': {}, 'pct': {}},
+ {'Type': 'HW L4', 'csum': ['udp'], 'recvqueue': 'Multi',
+ 'Mpps': {}, 'pct': {}},
+ {'Type': 'HW L3&L4', 'csum': ['ip', 'udp', 'outer-ip'],
+ 'recvqueue': 'Multi', 'Mpps': {}, 'pct': {}},
]
- self.table_header = ['Calculate Type']
- for test_cycle in self.test_cycles:
- self.table_header.append("%s Mpps" % test_cycle['cores'])
- self.table_header.append("% linerate")
+ self.chksum_header = ['Calculate Type']
+ self.chksum_header.append("Queues")
+ self.chksum_header.append("Mpps")
+ self.chksum_header.append("% linerate")
# tunnel filter performance test
self.default_vlan = 1
@@ -873,6 +875,16 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
self.add_tcl_cmd("ip set %d %d %d" %
(self.chasId, port['card'], port['port']))
+ def combine_pcap(self, dest_pcap, src_pcap):
+ pkts = rdpcap(dest_pcap)
+ if len(pkts) != 1:
+ return
+
+ pkts_src = rdpcap(src_pcap)
+ pkts += pkts_src
+
+ wrpcap(dest_pcap, pkts)
+
def test_perf_vxlan_tunnelfilter_performance_2ports(self):
dts.results_table_add_header(self.tunnel_header)
core_list = self.dut.get_core_list(
@@ -957,46 +969,55 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
dts.results_table_print()
def test_perf_vxlan_checksum_performance_2ports(self):
- config = VxlanTestConfig(self, payload_size=self.vxlan_payload)
- config.outer_mac_dst = self.dut.get_mac_address(self.dut_port)
- config.pcap_file = "vxlan1.pcap"
- config.create_pcap()
- if BIDIRECT:
- config.outer_mac_dst = self.dut.get_mac_address(self.recv_port)
- config.pcap_file = "vxlan2.pcap"
- config.create_pcap()
-
- all_cores_mask = dts.create_mask(self.dut.get_core_list("all"))
- # configure flows
- tgen_input = []
- tgen_input.append((self.tester.get_local_port(self.dut_port),
- self.tester.get_local_port(self.recv_port),
- "vxlan1.pcap"))
- if BIDIRECT:
- tgen_input.append((self.tester.get_local_port(self.recv_port),
- self.tester.get_local_port(self.dut_port),
- "vxlan2.pcap"))
+ dts.results_table_add_header(self.chksum_header)
+ vxlan = VxlanTestConfig(self, payload_size=self.vxlan_payload)
+ vxlan.outer_mac_dst = self.dut.get_mac_address(self.dut_port)
+ vxlan.pcap_file = "vxlan1.pcap"
+ vxlan.inner_mac_dst = "00:00:20:00:00:01"
+ vxlan.create_pcap(scp=False)
+
+ vxlan_queue = VxlanTestConfig(self, payload_size=self.vxlan_payload)
+ vxlan_queue.outer_mac_dst = self.dut.get_mac_address(self.dut_port)
+ vxlan_queue.pcap_file = "vxlan1_1.pcap"
+ vxlan_queue.inner_mac_dst = "00:00:20:00:00:02"
+ vxlan_queue.create_pcap(scp=False)
# socket/core/thread
- for test_cycle in self.test_cycles:
- core_config = test_cycle['cores']
+ core_list = self.dut.get_core_list(
+ '1S/%dC/1T' % (self.tunnel_multiqueue * 2 + 1),
+ socket=self.ports_socket)
+ core_mask = dts.create_mask(core_list)
- # take care the corelist when enable numa
- core_list = self.dut.get_core_list(core_config,
- socket=self.ports_socket)
+ tgen_dut = self.tester.get_local_port(self.dut_port)
+ tgen_tester = self.tester.get_local_port(self.recv_port)
+ for cal in self.cal_type:
+ recv_queue = cal['recvqueue']
+ print dts.GREEN("Measure checksum performance of [%s %s %s]"
+ % (cal['Type'], recv_queue, cal['csum']))
- core_mask = dts.create_mask(core_list)
+ # configure flows
+ tgen_input = []
+ if recv_queue == 'Multi':
+ self.combine_pcap("vxlan1.pcap", "vxlan1_1.pcap")
+ self.tester.session.copy_file_to("vxlan1.pcap")
+ tgen_input.append((tgen_dut, tgen_tester, "vxlan1.pcap"))
- cmd_temp = "./%(TARGET)s/app/testpmd -c %(CORE)s " + \
- "-n %(CHANNEL)d -- -i --disable-rss --coremask=" + \
- "%(COREMASK)s --portmask=%(PORTMASK)s"
- cmd = cmd_temp % {'TARGET': self.target,
- 'CORE': all_cores_mask,
- 'COREMASK': core_mask,
- 'CHANNEL': self.dut.get_memory_channels(),
- 'PORTMASK': self.portMask}
+ # multi queue and signle queue commands
+ if recv_queue == 'Multi':
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --disable-rss --rxq=2 --txq=2" + \
+ " --nb-cores=4 --portmask=%(PORT)s --txqflags=0x0"
+ else:
+ pmd_temp = "./%(TARGET)s/app/testpmd -c %(COREMASK)s -n " + \
+ "%(CHANNEL)d -- -i --nb-cores=2 --portmask=%(PORT)s" + \
+ " --txqflags=0x0"
+
+ pmd_cmd = pmd_temp % {'TARGET': self.target,
+ 'COREMASK': core_mask,
+ 'CHANNEL': self.dut.get_memory_channels(),
+ 'PORT': self.portMask}
- self.dut.send_expect(cmd, "testpmd> ", 100)
+ self.dut.send_expect(pmd_cmd, "testpmd> ", 100)
self.dut.send_expect("set fwd csum", "testpmd>", 10)
self.dut.send_expect("csum parse_tunnel on %d" %
self.dut_port, "testpmd>", 10)
@@ -1005,42 +1026,44 @@ class TestVxlan(TestCase, IxiaPacketGenerator):
self.enable_vxlan(self.dut_port)
self.enable_vxlan(self.recv_port)
- # different calculate type
- for cal in self.cal_type:
- print dts.GREEN("Measure checksum performance of [%s %s]"
- % (test_cycle['cores'],
- cal['csum']))
- for pro in cal['csum']:
- self.csum_set_type(pro, self.dut_port)
- self.csum_set_type(pro, self.recv_port)
+ # redirect flow to another queue by tunnel filter
+ args = [self.dut_port, vxlan.outer_mac_dst,
+ vxlan.inner_mac_dst, vxlan.inner_ip_dst,
+ 0, 'imac', vxlan.vni, 0]
+ self.tunnel_filter_add(*args)
- self.dut.send_expect("start", "testpmd>", 10)
+ if recv_queue == 'Multi':
+ args = [self.dut_port, vxlan_queue.outer_mac_dst,
+ vxlan_queue.inner_mac_dst, vxlan_queue.inner_ip_dst,
+ 0, 'imac', vxlan_queue.vni, 1]
+ self.tunnel_filter_add(*args)
- frame_size = config.pcap_len()
- if BIDIRECT:
- wirespeed = self.wirespeed(self.nic, frame_size, 2)
- else:
- wirespeed = self.wirespeed(self.nic, frame_size, 1)
- # run traffic generator
- _, pps = self.tester.traffic_generator_throughput(tgen_input)
+ for pro in cal['csum']:
+ self.csum_set_type(pro, self.dut_port)
+ self.csum_set_type(pro, self.recv_port)
- pps /= 1000000.0
- test_cycle['Mpps'][cal['Type']] = pps
- test_cycle['pct'][cal['Type']] = pps * 100 / wirespeed
+ self.dut.send_expect("start", "testpmd>", 10)
- self.dut.send_expect("stop", "testpmd>", 10)
+ wirespeed = self.wirespeed(self.nic, PACKET_LEN, 1)
- self.dut.send_expect("quit", "# ", 10)
+ # run traffic generator
+ _, pps = self.tester.traffic_generator_throughput(tgen_input)
- dts.results_table_add_header(self.table_header)
+ pps /= 1000000.0
+ cal['Mpps'] = pps
+ cal['pct'] = pps * 100 / wirespeed
- # save the results
- for cal in self.cal_type:
- table_row = [cal['Type']]
- for test_cycle in self.test_cycles:
- table_row.append(test_cycle['Mpps'][cal['Type']])
- table_row.append(test_cycle['pct'][cal['Type']])
+ out = self.dut.send_expect("stop", "testpmd>", 10)
+ self.dut.send_expect("quit", "# ", 10)
+
+ # verify every queue work fine
+ if recv_queue == 'Multi':
+ for queue in range(self.tunnel_multiqueue):
+ self.verify("Queue= %d -> TX Port"
+ % (queue) in out,
+ "Queue %d no traffic" % queue)
+ table_row = [cal['Type'], recv_queue, cal['Mpps'], cal['pct']]
dts.results_table_add_row(table_row)
dts.results_table_print()
--
1.9.3
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2015-06-09 6:38 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-06-08 2:21 [dts] [PATCH 0/4] Add vxlan function and performance suite Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 1/4] Optimize get core list function for Haswell cpu Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 2/4] Add vxlan protocal support in etgen module Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 3/4] Add vxlan test plan Yong Liu
2015-06-08 2:21 ` [dts] [PATCH 4/4] Add vxlan test suite Yong Liu
2015-06-09 6:38 ` [dts] [PATCH] Enhance vxlan checksum offload performance test case Yong Liu
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).