Skip to contentSkip to conversation

gro: add UDP/IPv4 GRO and VXLAN UDP/IPv4 GRO support

PATCH Superseded [email protected] 2 participants 18 messages Sep 17, 2020 – Sep 24, 2020 Arm/Amlogic Meson SoC support

v6 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v6 cover gro: add UDP/IPv4 GRO and VXLAN UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

In case that UFO or GSO is enabled, GRO is very necessary, especially for UDP, it is more so. Many NICs can't support VXLAN UDP UFO/USO and VLAN UFO/USO, so UDP performance improvement depends on GSO and GRO to a great extent.

This patch series added VLAN UDP/IPv4 GRO and VXLAN UDP/IPv4 GRO support.

I have tested it in OVS DPDK, test scenario is as below:

+-------------------------+   +--------------------------+
|VM1 --- OVS DPDK --- NIC1|---| NIC2 --- OVS-DPDK --- VM2|
+-------------------------+   +--------------------------+
         SERVER1                       SERVER2

If no GSO and GRO, 8k UDP packet can't work in case of UFO or in case that underlay MTU is 1500, so UDP size must meet MTU limitation, my VM MTU is 1450 (consider vxlan header), UDP performance is about 3Gbps, with GSO and GRO enabled, I can send 8K UDP packet, UDP performance is about 6Gbps (Note: with small UDP packet loss rate).

FYI: OVS DPDK patch series
https://patchwork.ozlabs.org/project/openvswitch/list/?series=194621

Changelog
---------
v5 -> v6: add doc update patch for prog_guide and rel_notes
rename udp_check_vxlan_neighbor to udp4_check_vxlan_neighbor remove outer_ip_id and outer_is_atomic
some other misc changes

v4 -> v5: remove duplicate line
fix header length check issue
add unlikely for some low probability condition branch rename udp_check_neighbor to udp4_check_neighbor remove brace for single line else statement remove outer_l2_len and pkt->outer_l3_len because they
are nonsense for non-VXLAN UDP packet

v3 -> v4: split two patches in cleaner way
remove ip_id which is unnecessary for UDP GRO correct hdr_len calculation

v2 -> v3: remove UDP header length check

v1 -> v2: split into two patches

Yi Yang (3):
gro: add UDP/IPv4 GRO support
gro: add VXLAN UDP/IPv4 GRO support
doc: update prog_guide and rel_notes for GRO

 .../prog_guide/generic_receive_offload_lib.rst     |   6 +-
 doc/guides/rel_notes/release_20_11.rst             |   6 +
 lib/librte_gro/gro_udp4.c                          | 430 ++++++++++++++++
 lib/librte_gro/gro_udp4.h                          | 282 +++++++++++
 lib/librte_gro/gro_vxlan_udp4.c                    | 542 +++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h                    | 154 ++++++
 lib/librte_gro/meson.build                         |   2 +-
 lib/librte_gro/rte_gro.c                           | 191 ++++++--
 lib/librte_gro/rte_gro.h                           |   8 +-
 9 files changed, 1584 insertions(+), 37 deletions(-)
 create mode 100644 lib/librte_gro/gro_udp4.c
 create mode 100644 lib/librte_gro/gro_udp4.h
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
Signature · 1 line
1.8.3.1
#1 lore raw

PATCH v6 1/3 gro: add UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble UDP fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VLAN use case.

---
 lib/librte_gro/gro_udp4.c  | 430 +++++++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_udp4.h  | 281 +++++++++++++++++++++++++++++
 lib/librte_gro/meson.build |   2 +-
 lib/librte_gro/rte_gro.c   |  92 ++++++++--
 lib/librte_gro/rte_gro.h   |   5 +-
 5 files changed, 794 insertions(+), 16 deletions(-)
 create mode 100644 lib/librte_gro/gro_udp4.c
 create mode 100644 lib/librte_gro/gro_udp4.h
lib/librte_gro/gro_udp4.c new file +430 -0
new file mode 100644
index 0000000..061e7b0
@@ -0,0 +1,430 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#include <rte_malloc.h>
+#include <rte_mbuf.h>
+#include <rte_cycles.h>
+#include <rte_ethdev.h>
+
+#include "gro_udp4.h"
+
+void *
+gro_udp4_tbl_create(uint16_t socket_id,
+		uint16_t max_flow_num,
+		uint16_t max_item_per_flow)
+{
+	struct gro_udp4_tbl *tbl;
+	size_t size;
+	uint32_t entries_num, i;
+
+	entries_num = max_flow_num * max_item_per_flow;
+	entries_num = RTE_MIN(entries_num, GRO_UDP4_TBL_MAX_ITEM_NUM);
+
+	if (entries_num == 0)
+		return NULL;
+
+	tbl = rte_zmalloc_socket(__func__,
+			sizeof(struct gro_udp4_tbl),
+			RTE_CACHE_LINE_SIZE,
+			socket_id);
+	if (tbl == NULL)
+		return NULL;
+
+	size = sizeof(struct gro_udp4_item) * entries_num;
+	tbl->items = rte_zmalloc_socket(__func__,
+			size,
+			RTE_CACHE_LINE_SIZE,
+			socket_id);
+	if (tbl->items == NULL) {
+		rte_free(tbl);
+		return NULL;
+	}
+	tbl->max_item_num = entries_num;
+
+	size = sizeof(struct gro_udp4_flow) * entries_num;
+	tbl->flows = rte_zmalloc_socket(__func__,
+			size,
+			RTE_CACHE_LINE_SIZE,
+			socket_id);
+	if (tbl->flows == NULL) {
+		rte_free(tbl->items);
+		rte_free(tbl);
+		return NULL;
+	}
+	/* INVALID_ARRAY_INDEX indicates an empty flow */
+	for (i = 0; i < entries_num; i++)
+		tbl->flows[i].start_index = INVALID_ARRAY_INDEX;
+	tbl->max_flow_num = entries_num;
+
+	return tbl;
+}
+
+void
+gro_udp4_tbl_destroy(void *tbl)
+{
+	struct gro_udp4_tbl *udp_tbl = tbl;
+
+	if (udp_tbl) {
+		rte_free(udp_tbl->items);
+		rte_free(udp_tbl->flows);
+	}
+	rte_free(udp_tbl);
+}
+
+static inline uint32_t
+find_an_empty_item(struct gro_udp4_tbl *tbl)
+{
+	uint32_t i;
+	uint32_t max_item_num = tbl->max_item_num;
+
+	for (i = 0; i < max_item_num; i++)
+		if (tbl->items[i].firstseg == NULL)
+			return i;
+	return INVALID_ARRAY_INDEX;
+}
+
+static inline uint32_t
+find_an_empty_flow(struct gro_udp4_tbl *tbl)
+{
+	uint32_t i;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++)
+		if (tbl->flows[i].start_index == INVALID_ARRAY_INDEX)
+			return i;
+	return INVALID_ARRAY_INDEX;
+}
+
+static inline uint32_t
+insert_new_item(struct gro_udp4_tbl *tbl,
+		struct rte_mbuf *pkt,
+		uint64_t start_time,
+		uint32_t prev_idx,
+		uint16_t frag_offset,
+		uint8_t is_last_frag)
+{
+	uint32_t item_idx;
+
+	item_idx = find_an_empty_item(tbl);
+	if (unlikely(item_idx == INVALID_ARRAY_INDEX))
+		return INVALID_ARRAY_INDEX;
+
+	tbl->items[item_idx].firstseg = pkt;
+	tbl->items[item_idx].lastseg = rte_pktmbuf_lastseg(pkt);
+	tbl->items[item_idx].start_time = start_time;
+	tbl->items[item_idx].next_pkt_idx = INVALID_ARRAY_INDEX;
+	tbl->items[item_idx].frag_offset = frag_offset;
+	tbl->items[item_idx].is_last_frag = is_last_frag;
+	tbl->items[item_idx].nb_merged = 1;
+	tbl->item_num++;
+
+	/* if the previous packet exists, chain them together. */
+	if (prev_idx != INVALID_ARRAY_INDEX) {
+		tbl->items[item_idx].next_pkt_idx =
+			tbl->items[prev_idx].next_pkt_idx;
+		tbl->items[prev_idx].next_pkt_idx = item_idx;
+	}
+
+	return item_idx;
+}
+
+static inline uint32_t
+delete_item(struct gro_udp4_tbl *tbl, uint32_t item_idx,
+		uint32_t prev_item_idx)
+{
+	uint32_t next_idx = tbl->items[item_idx].next_pkt_idx;
+
+	/* NULL indicates an empty item */
+	tbl->items[item_idx].firstseg = NULL;
+	tbl->item_num--;
+	if (prev_item_idx != INVALID_ARRAY_INDEX)
+		tbl->items[prev_item_idx].next_pkt_idx = next_idx;
+
+	return next_idx;
+}
+
+static inline uint32_t
+insert_new_flow(struct gro_udp4_tbl *tbl,
+		struct udp4_flow_key *src,
+		uint32_t item_idx)
+{
+	struct udp4_flow_key *dst;
+	uint32_t flow_idx;
+
+	flow_idx = find_an_empty_flow(tbl);
+	if (unlikely(flow_idx == INVALID_ARRAY_INDEX))
+		return INVALID_ARRAY_INDEX;
+
+	dst = &(tbl->flows[flow_idx].key);
+
+	rte_ether_addr_copy(&(src->eth_saddr), &(dst->eth_saddr));
+	rte_ether_addr_copy(&(src->eth_daddr), &(dst->eth_daddr));
+	dst->ip_src_addr = src->ip_src_addr;
+	dst->ip_dst_addr = src->ip_dst_addr;
+	dst->ip_id = src->ip_id;
+
+	tbl->flows[flow_idx].start_index = item_idx;
+	tbl->flow_num++;
+
+	return flow_idx;
+}
+
+/*
+ * update the packet length for the flushed packet.
+ */
+static inline void
+update_header(struct gro_udp4_item *item)
+{
+	struct rte_ipv4_hdr *ipv4_hdr;
+	struct rte_mbuf *pkt = item->firstseg;
+	uint16_t frag_offset;
+
+	ipv4_hdr = (struct rte_ipv4_hdr *)(rte_pktmbuf_mtod(pkt, char *) +
+			pkt->l2_len);
+	ipv4_hdr->total_length = rte_cpu_to_be_16(pkt->pkt_len -
+			pkt->l2_len);
+
+	/* Clear MF bit if it is last fragment */
+	if (item->is_last_frag) {
+		frag_offset = rte_be_to_cpu_16(ipv4_hdr->fragment_offset);
+		ipv4_hdr->fragment_offset =
+			rte_cpu_to_be_16(frag_offset & ~RTE_IPV4_HDR_MF_FLAG);
+	}
+}
+
+int32_t
+gro_udp4_reassemble(struct rte_mbuf *pkt,
+		struct gro_udp4_tbl *tbl,
+		uint64_t start_time)
+{
+	struct rte_ether_hdr *eth_hdr;
+	struct rte_ipv4_hdr *ipv4_hdr;
+	uint16_t ip_dl;
+	uint16_t ip_id, hdr_len;
+	uint16_t frag_offset = 0;
+	uint8_t is_last_frag;
+
+	struct udp4_flow_key key;
+	uint32_t cur_idx, prev_idx, item_idx;
+	uint32_t i, max_flow_num, remaining_flow_num;
+	int cmp;
+	uint8_t find;
+
+	eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
+	ipv4_hdr = (struct rte_ipv4_hdr *)((char *)eth_hdr + pkt->l2_len);
+	hdr_len = pkt->l2_len + pkt->l3_len;
+
+	/*
+	 * Don't process non-fragment packet.
+	 */
+	if (!is_ipv4_fragment(ipv4_hdr))
+		return -1;
+
+	/*
+	 * Don't process the packet whose payload length is less than or
+	 * equal to 0.
+	 */
+	if (pkt->pkt_len <= hdr_len)
+		return -1;
+
+	ip_dl = rte_be_to_cpu_16(ipv4_hdr->total_length);
+	if (ip_dl <= pkt->l3_len)
+		return -1;
+
+	ip_dl -= pkt->l3_len;
+	ip_id = rte_be_to_cpu_16(ipv4_hdr->packet_id);
+	frag_offset = rte_be_to_cpu_16(ipv4_hdr->fragment_offset);
+	is_last_frag = ((frag_offset & RTE_IPV4_HDR_MF_FLAG) == 0) ? 1 : 0;
+	frag_offset = (uint16_t)(frag_offset & RTE_IPV4_HDR_OFFSET_MASK) << 3;
+
+	rte_ether_addr_copy(&(eth_hdr->s_addr), &(key.eth_saddr));
+	rte_ether_addr_copy(&(eth_hdr->d_addr), &(key.eth_daddr));
+	key.ip_src_addr = ipv4_hdr->src_addr;
+	key.ip_dst_addr = ipv4_hdr->dst_addr;
+	key.ip_id = ip_id;
+
+	/* Search for a matched flow. */
+	max_flow_num = tbl->max_flow_num;
+	remaining_flow_num = tbl->flow_num;
+	find = 0;
+	for (i = 0; i < max_flow_num && remaining_flow_num; i++) {
+		if (tbl->flows[i].start_index != INVALID_ARRAY_INDEX) {
+			if (is_same_udp4_flow(tbl->flows[i].key, key)) {
+				find = 1;
+				break;
+			}
+			remaining_flow_num--;
+		}
+	}
+
+	/*
+	 * Fail to find a matched flow. Insert a new flow and store the
+	 * packet into the flow.
+	 */
+	if (find == 0) {
+		item_idx = insert_new_item(tbl, pkt, start_time,
+				INVALID_ARRAY_INDEX, frag_offset,
+				is_last_frag);
+		if (unlikely(item_idx == INVALID_ARRAY_INDEX))
+			return -1;
+		if (insert_new_flow(tbl, &key, item_idx) ==
+				INVALID_ARRAY_INDEX) {
+			/*
+			 * Fail to insert a new flow, so delete the
+			 * stored packet.
+			 */
+			delete_item(tbl, item_idx, INVALID_ARRAY_INDEX);
+			return -1;
+		}
+		return 0;
+	}
+
+	/*
+	 * Check all packets in the flow and try to find a neighbor for
+	 * the input packet.
+	 */
+	cur_idx = tbl->flows[i].start_index;
+	prev_idx = cur_idx;
+	do {
+		cmp = udp4_check_neighbor(&(tbl->items[cur_idx]),
+				frag_offset, ip_dl, 0);
+		if (cmp) {
+			if (merge_two_udp4_packets(&(tbl->items[cur_idx]),
+						pkt, cmp, frag_offset,
+						is_last_frag, 0))
+				return 1;
+			/*
+			 * Fail to merge the two packets, as the packet
+			 * length is greater than the max value. Store
+			 * the packet into the flow.
+			 */
+			if (insert_new_item(tbl, pkt, start_time, prev_idx,
+						frag_offset, is_last_frag) ==
+					INVALID_ARRAY_INDEX)
+				return -1;
+			return 0;
+		}
+
+		/* Ensure inserted items are ordered by frag_offset */
+		if (frag_offset
+			< tbl->items[cur_idx].frag_offset) {
+			break;
+		}
+
+		prev_idx = cur_idx;
+		cur_idx = tbl->items[cur_idx].next_pkt_idx;
+	} while (cur_idx != INVALID_ARRAY_INDEX);
+
+	/* Fail to find a neighbor, so store the packet into the flow. */
+	if (cur_idx == tbl->flows[i].start_index) {
+		/* Insert it before the first packet of the flow */
+		item_idx = insert_new_item(tbl, pkt, start_time,
+				INVALID_ARRAY_INDEX, frag_offset,
+				is_last_frag);
+		if (unlikely(item_idx == INVALID_ARRAY_INDEX))
+			return -1;
+		tbl->items[item_idx].next_pkt_idx = cur_idx;
+		tbl->flows[i].start_index = item_idx;
+	} else {
+		if (insert_new_item(tbl, pkt, start_time, prev_idx,
+				frag_offset, is_last_frag)
+			== INVALID_ARRAY_INDEX)
+			return -1;
+	}
+
+	return 0;
+}
+
+static int
+gro_udp4_merge_items(struct gro_udp4_tbl *tbl,
+			   uint32_t start_idx)
+{
+	uint16_t frag_offset;
+	uint8_t is_last_frag;
+	int16_t ip_dl;
+	struct rte_mbuf *pkt;
+	int cmp;
+	uint32_t item_idx;
+	uint16_t hdr_len;
+
+	item_idx = tbl->items[start_idx].next_pkt_idx;
+	while (item_idx != INVALID_ARRAY_INDEX) {
+		pkt = tbl->items[item_idx].firstseg;
+		hdr_len = pkt->l2_len + pkt->l3_len;
+		ip_dl = pkt->pkt_len - hdr_len;
+		frag_offset = tbl->items[item_idx].frag_offset;
+		is_last_frag = tbl->items[item_idx].is_last_frag;
+		cmp = udp4_check_neighbor(&(tbl->items[start_idx]),
+					frag_offset, ip_dl, 0);
+		if (cmp) {
+			if (merge_two_udp4_packets(
+					&(tbl->items[start_idx]),
+					pkt, cmp, frag_offset,
+					is_last_frag, 0)) {
+				item_idx = delete_item(tbl, item_idx,
+							INVALID_ARRAY_INDEX);
+				tbl->items[start_idx].next_pkt_idx
+					= item_idx;
+			} else
+				return 0;
+		} else
+			return 0;
+	}
+
+	return 0;
+}
+
+uint16_t
+gro_udp4_tbl_timeout_flush(struct gro_udp4_tbl *tbl,
+		uint64_t flush_timestamp,
+		struct rte_mbuf **out,
+		uint16_t nb_out)
+{
+	uint16_t k = 0;
+	uint32_t i, j;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++) {
+		if (unlikely(tbl->flow_num == 0))
+			return k;
+
+		j = tbl->flows[i].start_index;
+		while (j != INVALID_ARRAY_INDEX) {
+			if (tbl->items[j].start_time <= flush_timestamp) {
+				gro_udp4_merge_items(tbl, j);
+				out[k++] = tbl->items[j].firstseg;
+				if (tbl->items[j].nb_merged > 1)
+					update_header(&(tbl->items[j]));
+				/*
+				 * Delete the packet and get the next
+				 * packet in the flow.
+				 */
+				j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+				tbl->flows[i].start_index = j;
+				if (j == INVALID_ARRAY_INDEX)
+					tbl->flow_num--;
+
+				if (unlikely(k == nb_out))
+					return k;
+			} else
+				/*
+				 * The left packets in this flow won't be
+				 * timeout. Go to check other flows.
+				 */
+				break;
+		}
+	}
+	return k;
+}
+
+uint32_t
+gro_udp4_tbl_pkt_count(void *tbl)
+{
+	struct gro_udp4_tbl *gro_tbl = tbl;
+
+	if (gro_tbl)
+		return gro_tbl->item_num;
+
+	return 0;
+}
lib/librte_gro/gro_udp4.h new file +281 -0

281 lines not on this page · raw message

lib/librte_gro/meson.build +1 -1
index 501668c..0d18dc2 100644
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright(c) 2017 Intel Corporation
 
-sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_vxlan_tcp4.c')
+sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c')
 headers = files('rte_gro.h')
 deps += ['ethdev']
lib/librte_gro/rte_gro.c +78 -14

216 lines not on this page · raw message

lib/librte_gro/rte_gro.h +4 -1
index 8d781b5..470f3ed 100644
@@ -31,7 +31,10 @@
 /**< TCP/IPv4 GRO flag */
 #define RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX 1
 #define RTE_GRO_IPV4_VXLAN_TCP_IPV4 (1ULL << RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX)
-/**< VxLAN GRO flag. */
+/**< VxLAN TCP/IPv4 GRO flag. */
+#define RTE_GRO_UDP_IPV4_INDEX 2
+#define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
+/**< UDP/IPv4 GRO flag */
 
 /**
  * Structure used to create GRO context objects or used to pass
Signature · 1 line
1.8.3.1
Acked-by on v6 1/3
#2 lore raw

Re: [dpdk-dev] [PATCH v6 1/3] gro: add UDP/IPv4 GRO support

Quoted 15 lines

-----Original Message-----
From: [email protected] <[email protected]>
Sent: Thursday, September 17, 2020 11:50 AM
To: [email protected]
Cc: Hu, Jiayu <[email protected]>; [email protected]; [email protected]; [email protected]
Subject: [PATCH v6 1/3] gro: add UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

Quoted 7 lines

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble UDP fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VLAN use case.

Quoted 11 lines
---
 lib/librte_gro/gro_udp4.c  | 430
+++++++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_udp4.h  | 281 +++++++++++++++++++++++++++++
 lib/librte_gro/meson.build |   2 +-
 lib/librte_gro/rte_gro.c   |  92 ++++++++--
 lib/librte_gro/rte_gro.h   |   5 +-
 5 files changed, 794 insertions(+), 16 deletions(-)
 create mode 100644 lib/librte_gro/gro_udp4.c
 create mode 100644 lib/librte_gro/gro_udp4.h
#3 lore raw

PATCH v6 2/3 gro: add VXLAN UDP/IPv4 GRO support

In reply to [email protected]

From: Yi Yang <[email protected]>

VXLAN UDP/IPv4 GRO can help improve VM-to-VM UDP
performance when UFO or GSO is enabled in VM, GRO
must be supported if UFO or GSO is enabled,
otherwise, performance can't get big improvement
if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble VXLAN UDP/IPv4 fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case.

Note: outer IP ID isn't used to check if two packets are same flow and can be merged because the difference between outer IP IDs of two packets isn't always +/-1 in case of OVS DPDK.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 542 ++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 154 ++++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 790 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +542 -0

542 lines not on this page · raw message

lib/librte_gro/gro_vxlan_udp4.h new file +154 -0

154 lines not on this page · raw message

lib/librte_gro/meson.build +1 -1
index 0d18dc2..ea8b45c 100644
@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright(c) 2017 Intel Corporation
 
-sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c')
+sources = files('rte_gro.c', 'gro_tcp4.c', 'gro_udp4.c', 'gro_vxlan_tcp4.c', 'gro_vxlan_udp4.c')
 headers = files('rte_gro.h')
 deps += ['ethdev']
lib/librte_gro/rte_gro.c +89 -26

208 lines not on this page · raw message

lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL << RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**
  * Structure used to create GRO context objects or used to pass
Signature · 1 line
1.8.3.1
#4 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Hi Yi,

Some comments are inline.

Thanks,
Jiayu

Quoted 89 lines

-----Original Message-----
From: [email protected] <[email protected]>
Sent: Thursday, September 17, 2020 11:50 AM
To: [email protected]
Cc: Hu, Jiayu <[email protected]>; [email protected]; [email protected]; [email protected]
Subject: [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

VXLAN UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble VXLAN UDP/IPv4 fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case.

Note: outer IP ID isn't used to check if two packets are same flow and can be merged because the difference between outer IP IDs of two packets isn't always +/-1 in case of OVS DPDK.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 542
++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 154 ++++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 790 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +23 -0
new file mode 100644
index 0000000..4eece56
@@ -0,0 +1,542 @@
+
+uint16_t
+gro_vxlan_udp4_tbl_timeout_flush(struct gro_vxlan_udp4_tbl *tbl,
+		uint64_t flush_timestamp,
+		struct rte_mbuf **out,
+		uint16_t nb_out)
+{
+	uint16_t k = 0;
+	uint32_t i, j;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++) {
+		if (unlikely(tbl->flow_num == 0))
+			return k;
+
+		j = tbl->flows[i].start_index;
+		while (j != INVALID_ARRAY_INDEX) {
+			if (tbl->items[j].inner_item.start_time <=
+					flush_timestamp) {
+				gro_vxlan_udp4_merge_items(tbl, j);
+				out[k++] = tbl->items[j].inner_item.firstseg;
+				if (tbl->items[j].inner_item.nb_merged > 1)
+					update_vxlan_header(&(tbl-
Quoted 1 line

items[j]));

lib/librte_gro/gro_vxlan_udp4.c new file +7 -0
+				/*
+				 * Delete the item and get the next packet
+				 * index.
+				 */
+				j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+				tbl->flows[i].start_index = j;
+				if (j == INVALID_ARRAY_INDEX)

lib/librte_gro/gro_vxlan_udp4.c line 527

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+					tbl->flow_num--;
+
+				if (unlikely(k == nb_out))
+					return k;
+			} else
+				/*
+				 * The left packets in the flow won't be
+				 * timeout. Go to check other flows.
+				 */
+				break;

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 28 lines
lib/librte_gro/gro_vxlan_udp4.c new file +4 -0
+		}
+	}
+	return k;
+}
lib/librte_gro/gro_vxlan_udp4.h new file +17 -0
new file mode 100644
index 0000000..6a42fb3
@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#ifndef _GRO_VXLAN_UDP4_H_
+#define _GRO_VXLAN_UDP4_H_
+
+#include "gro_udp4.h"
+
+#define GRO_VXLAN_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
+
+/* Header fields representing a VxLAN flow */
+struct vxlan_udp4_flow_key {
+	struct udp4_flow_key inner_key;
+	struct rte_vxlan_hdr vxlan_hdr;
+
+	struct rte_ether_addr outer_eth_saddr;

lib/librte_gro/gro_vxlan_udp4.h line 27

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+	struct rte_ether_addr outer_eth_daddr;
+
+	uint32_t outer_ip_src_addr;
+	uint32_t outer_ip_dst_addr;
+
+	/* Note: It is unnecessary to save outer_src_port here because it can
+	 * be different for VxLAN UDP fragments from the same flow.
+	 */
+	uint16_t outer_dst_port;
+

The above empty line is unnecessary.

lib/librte_gro/gro_vxlan_udp4.h line 45

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+};
+
+
+struct gro_vxlan_udp4_item {
+	struct gro_udp4_item inner_item;
+	/* Note: VXLAN UDP/IPv4 GRO needn't check outer_ip_id because
+	 * the difference between outer_ip_ids of two received packets
+	 * isn't always +/-1 in case of OVS DPDK. So no outer_ip_id
+	 * and outer_is_atomic fields here.
+	 */

It seems the above comments for outer IP ID is enough, and no need to highlight in the commit log again. How do you think?

Quoted 193 lines
lib/librte_gro/gro_vxlan_udp4.h new file +2 -0
+};
+
lib/librte_gro/rte_gro.c +1 -3
index f623230..db990cf 100644
@@ -11,6 +11,7 @@
 #include "gro_tcp4.h"
 #include "gro_udp4.h"
 #include "gro_vxlan_tcp4.h"
+#include "gro_vxlan_udp4.h"
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
 	struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 = {{0} };
 
 	/* Allocate a reassembly table for VXLAN TCP GRO */
-	struct gro_vxlan_tcp4_tbl vxlan_tbl;
-	struct gro_vxlan_tcp4_flow
 vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-	struct gro_vxlan_tcp4_item

vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +2 -0
+	struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+	struct gro_vxlan_tcp4_flow

vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

lib/librte_gro/rte_gro.c +1 -0
+	struct gro_vxlan_tcp4_item

vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +3 -0
 			= {{{0}, 0, 0} };
 
+	/* Allocate a reassembly table for VXLAN UDP GRO */
+	struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+	struct gro_vxlan_udp4_flow

vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

lib/librte_gro/rte_gro.c +1 -0
+	struct gro_vxlan_udp4_item

vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +27 -10
+			= {{{0}} };
+
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	uint32_t item_num;
 	int32_t ret;
 	uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-	uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+	uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+		do_vxlan_udp_gro = 0;
 
 	if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
 					RTE_GRO_TCP_IPV4 |
+					RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 					RTE_GRO_UDP_IPV4)) == 0))
 		return nb_pkts;
@@ -160,15 +179,28 @@ struct gro_ctx {
 
 	if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
 		for (i = 0; i < item_num; i++)
-			vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-		vxlan_tbl.flows = vxlan_flows;
-		vxlan_tbl.items = vxlan_items;
-		vxlan_tbl.flow_num = 0;
-		vxlan_tbl.item_num = 0;
-		vxlan_tbl.max_flow_num = item_num;
-		vxlan_tbl.max_item_num = item_num;
-		do_vxlan_gro = 1;
+			vxlan_tcp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+		vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+		vxlan_tcp_tbl.items = vxlan_tcp_items;
+		vxlan_tcp_tbl.flow_num = 0;
+		vxlan_tcp_tbl.item_num = 0;
+		vxlan_tcp_tbl.max_flow_num = item_num;
+		vxlan_tcp_tbl.max_item_num = item_num;
+		do_vxlan_tcp_gro = 1;
+	}
+
+	if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+		for (i = 0; i < item_num; i++)
+			vxlan_udp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+		vxlan_udp_tbl.flows = vxlan_udp_flows;
+		vxlan_udp_tbl.items = vxlan_udp_items;
+		vxlan_udp_tbl.flow_num = 0;
+		vxlan_udp_tbl.item_num = 0;
+		vxlan_udp_tbl.max_flow_num = item_num;
+		vxlan_udp_tbl.max_item_num = item_num;
+		do_vxlan_udp_gro = 1;
 	}
lib/librte_gro/rte_gro.c +19 -4
 	if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
 		 * will be flushed from the tables.
 		 */
 		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-				do_vxlan_gro) {
+				do_vxlan_tcp_gro) {
 			ret = gro_vxlan_tcp4_reassemble(pkts[i],
-							&vxlan_tbl, 0);
+							&vxlan_tcp_tbl, 0);
+			if (ret > 0)
+				/* Merge successfully */
+				nb_after_gro--;
+			else if (ret < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_udp_gro) {
+			ret = gro_vxlan_udp4_reassemble(pkts[i],
+							&vxlan_udp_tbl, 0);
 			if (ret > 0)
 				/* Merge successfully */
 				nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
 		 || (unprocess_num < nb_pkts)) {
 		i = 0;
 		/* Flush all packets from the tables */
-		if (do_vxlan_gro) {
-			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+		if (do_vxlan_tcp_gro) {
+			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
 					0, pkts, nb_pkts);
 		}
 
+		if (do_vxlan_udp_gro) {
+			i +=
 gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+					0, &pkts[i], nb_pkts - i);
+
+		}
+
 		if (do_tcp4_gro) {
 			i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
lib/librte_gro/rte_gro.c +2 -2
 					&pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	struct gro_ctx *gro_ctx = ctx;
-	void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+	void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
 	uint64_t current_time;
 	uint16_t i, unprocess_num = 0;
-	uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+	uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro,
 do_vxlan_udp_gro;
 
 	if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4

|

lib/librte_gro/rte_gro.c +2 -1
 					RTE_GRO_TCP_IPV4 |
+					RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 					RTE_GRO_UDP_IPV4)) == 0))
 		return nb_pkts;
 
 	tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-	vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+	vxlan_tcp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

lib/librte_gro/rte_gro.c +1 -0
 	udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+	vxlan_udp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

lib/librte_gro/rte_gro.c +0 -1
 	do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
 		RTE_GRO_TCP_IPV4;
-	do_vxlan_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

lib/librte_gro/rte_gro.c +1 -0
+	do_vxlan_tcp_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

lib/librte_gro/rte_gro.c +1 -0
 		RTE_GRO_IPV4_VXLAN_TCP_IPV4;
 	do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
 		RTE_GRO_UDP_IPV4;
+	do_vxlan_udp_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

lib/librte_gro/rte_gro.c +8 -2
+		RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
 	current_time = rte_rdtsc();
 
 	for (i = 0; i < nb_pkts; i++) {
 		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-				do_vxlan_gro) {
-			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+				do_vxlan_tcp_gro) {
+			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+						current_time) < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_udp_gro) {
+			if (gro_vxlan_udp4_reassemble(pkts[i],

vxlan_udp_tbl,

lib/librte_gro/rte_gro.c +0 -0
 						current_time) < 0)
 				unprocess_pkts[unprocess_num++] = pkts[i];
 		} else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

lib/librte_gro/rte_gro.c struct gro_ctx { · line 401

Quoted 5 lines
lib/librte_gro/rte_gro.c +1 -0
@@ -341,6 +397,13 @@ struct gro_ctx {
 		left_nb_out = max_nb_out - num;
 	}
 
+	if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out >
 0) {

Max_nb_out is read-only and not updated. So it cannot check if 'out' array has enough space. Need to use left_nb_out instead. This issue also existed in UDP/IPv4 GRO, and please correct them both.

Quoted 26 lines
lib/librte_gro/rte_gro.c +6 -0
+		num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+				RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+				flush_timestamp, &out[num], left_nb_out);
+		left_nb_out = max_nb_out - num;
+	}
+
 	/* If no available space in 'out', stop flushing. */
 	if ((gro_types & RTE_GRO_TCP_IPV4) && max_nb_out > 0) {
lib/librte_gro/rte_gro.c +0 -0
 		num += gro_tcp4_tbl_timeout_flush(
lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL <<
 RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**

* Structure used to create GRO context objects or used to pass
--
1.8.3.1

author
#5 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Thanks Jiayu, I have fixed other comments except this one:

Quoted 5 lines

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

lib/librte_gro/gro_udp4.c +0 -7
index 061e7b0..ffa35a2 100644
@@ -391,7 +391,6 @@
 
                j = tbl->flows[i].start_index;
                while (j != INVALID_ARRAY_INDEX) {
-                       if (tbl->items[j].start_time <= flush_timestamp) {
                                gro_udp4_merge_items(tbl, j);
                                out[k++] = tbl->items[j].firstseg;
                                if (tbl->items[j].nb_merged > 1)
@@ -407,12 +406,6 @@
 
                                if (unlikely(k == nb_out))
                                        return k;
-                       } else
-                               /*
-                                * The left packets in this flow won't be
-                                * timeout. Go to check other flows.
-                                */
-                               break;
                }
        }
        return k;
Quoted 397 lines · Jiayu

Hi Yi,

Some comments are inline.

Thanks,
Jiayu

Quoted 89 lines

-----Original Message-----
From: [email protected] <[email protected]>
Sent: Thursday, September 17, 2020 11:50 AM
To: [email protected]
Cc: Hu, Jiayu <[email protected]>; [email protected]; [email protected]; [email protected]
Subject: [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

VXLAN UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble VXLAN UDP/IPv4 fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case.

Note: outer IP ID isn't used to check if two packets are same flow and can be merged because the difference between outer IP IDs of two packets isn't always +/-1 in case of OVS DPDK.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 542
++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 154 ++++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 790 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +23 -0
new file mode 100644
index 0000000..4eece56
@@ -0,0 +1,542 @@
+
+uint16_t
+gro_vxlan_udp4_tbl_timeout_flush(struct gro_vxlan_udp4_tbl *tbl,
+		uint64_t flush_timestamp,
+		struct rte_mbuf **out,
+		uint16_t nb_out)
+{
+	uint16_t k = 0;
+	uint32_t i, j;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++) {
+		if (unlikely(tbl->flow_num == 0))
+			return k;
+
+		j = tbl->flows[i].start_index;
+		while (j != INVALID_ARRAY_INDEX) {
+			if (tbl->items[j].inner_item.start_time <=
+					flush_timestamp) {
+				gro_vxlan_udp4_merge_items(tbl, j);
+				out[k++] = tbl->items[j].inner_item.firstseg;
+				if (tbl->items[j].inner_item.nb_merged > 1)
+					update_vxlan_header(&(tbl-
Quoted 1 line

items[j]));

lib/librte_gro/gro_vxlan_udp4.c new file +7 -0
+				/*
+				 * Delete the item and get the next packet
+				 * index.
+				 */
+				j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+				tbl->flows[i].start_index = j;
+				if (j == INVALID_ARRAY_INDEX)

lib/librte_gro/gro_vxlan_udp4.c

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+					tbl->flow_num--;
+
+				if (unlikely(k == nb_out))
+					return k;
+			} else
+				/*
+				 * The left packets in the flow won't be
+				 * timeout. Go to check other flows.
+				 */
+				break;

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 28 lines
lib/librte_gro/gro_vxlan_udp4.c new file +4 -0
+		}
+	}
+	return k;
+}
lib/librte_gro/gro_vxlan_udp4.h new file +17 -0
new file mode 100644
index 0000000..6a42fb3
@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#ifndef _GRO_VXLAN_UDP4_H_
+#define _GRO_VXLAN_UDP4_H_
+
+#include "gro_udp4.h"
+
+#define GRO_VXLAN_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
+
+/* Header fields representing a VxLAN flow */
+struct vxlan_udp4_flow_key {
+	struct udp4_flow_key inner_key;
+	struct rte_vxlan_hdr vxlan_hdr;
+
+	struct rte_ether_addr outer_eth_saddr;

lib/librte_gro/gro_vxlan_udp4.h line 27

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+	struct rte_ether_addr outer_eth_daddr;
+
+	uint32_t outer_ip_src_addr;
+	uint32_t outer_ip_dst_addr;
+
+	/* Note: It is unnecessary to save outer_src_port here because it can
+	 * be different for VxLAN UDP fragments from the same flow.
+	 */
+	uint16_t outer_dst_port;
+

The above empty line is unnecessary.

lib/librte_gro/gro_vxlan_udp4.h line 37

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+};
+
+
+struct gro_vxlan_udp4_item {
+	struct gro_udp4_item inner_item;
+	/* Note: VXLAN UDP/IPv4 GRO needn't check outer_ip_id because
+	 * the difference between outer_ip_ids of two received packets
+	 * isn't always +/-1 in case of OVS DPDK. So no outer_ip_id
+	 * and outer_is_atomic fields here.
+	 */

It seems the above comments for outer IP ID is enough, and no need to highlight in the commit log again. How do you think?

Quoted 193 lines
lib/librte_gro/gro_vxlan_udp4.h new file +2 -0
+};
+
lib/librte_gro/rte_gro.c +1 -3
index f623230..db990cf 100644
@@ -11,6 +11,7 @@
 #include "gro_tcp4.h"
 #include "gro_udp4.h"
 #include "gro_vxlan_tcp4.h"
+#include "gro_vxlan_udp4.h"
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
 	struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 = {{0} };
 
 	/* Allocate a reassembly table for VXLAN TCP GRO */
-	struct gro_vxlan_tcp4_tbl vxlan_tbl;
-	struct gro_vxlan_tcp4_flow
 vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-	struct gro_vxlan_tcp4_item

vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +2 -0
+	struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+	struct gro_vxlan_tcp4_flow

vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

lib/librte_gro/rte_gro.c +1 -0
+	struct gro_vxlan_tcp4_item

vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +3 -0
 			= {{{0}, 0, 0} };
 
+	/* Allocate a reassembly table for VXLAN UDP GRO */
+	struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+	struct gro_vxlan_udp4_flow

vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

lib/librte_gro/rte_gro.c +1 -0
+	struct gro_vxlan_udp4_item

vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +27 -10
+			= {{{0}} };
+
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	uint32_t item_num;
 	int32_t ret;
 	uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-	uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+	uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+		do_vxlan_udp_gro = 0;
 
 	if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
 					RTE_GRO_TCP_IPV4 |
+					RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 					RTE_GRO_UDP_IPV4)) == 0))
 		return nb_pkts;
@@ -160,15 +179,28 @@ struct gro_ctx {
 
 	if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
 		for (i = 0; i < item_num; i++)
-			vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-		vxlan_tbl.flows = vxlan_flows;
-		vxlan_tbl.items = vxlan_items;
-		vxlan_tbl.flow_num = 0;
-		vxlan_tbl.item_num = 0;
-		vxlan_tbl.max_flow_num = item_num;
-		vxlan_tbl.max_item_num = item_num;
-		do_vxlan_gro = 1;
+			vxlan_tcp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+		vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+		vxlan_tcp_tbl.items = vxlan_tcp_items;
+		vxlan_tcp_tbl.flow_num = 0;
+		vxlan_tcp_tbl.item_num = 0;
+		vxlan_tcp_tbl.max_flow_num = item_num;
+		vxlan_tcp_tbl.max_item_num = item_num;
+		do_vxlan_tcp_gro = 1;
+	}
+
+	if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+		for (i = 0; i < item_num; i++)
+			vxlan_udp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+		vxlan_udp_tbl.flows = vxlan_udp_flows;
+		vxlan_udp_tbl.items = vxlan_udp_items;
+		vxlan_udp_tbl.flow_num = 0;
+		vxlan_udp_tbl.item_num = 0;
+		vxlan_udp_tbl.max_flow_num = item_num;
+		vxlan_udp_tbl.max_item_num = item_num;
+		do_vxlan_udp_gro = 1;
 	}
lib/librte_gro/rte_gro.c +19 -4
 	if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
 		 * will be flushed from the tables.
 		 */
 		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-				do_vxlan_gro) {
+				do_vxlan_tcp_gro) {
 			ret = gro_vxlan_tcp4_reassemble(pkts[i],
-							&vxlan_tbl, 0);
+							&vxlan_tcp_tbl, 0);
+			if (ret > 0)
+				/* Merge successfully */
+				nb_after_gro--;
+			else if (ret < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_udp_gro) {
+			ret = gro_vxlan_udp4_reassemble(pkts[i],
+							&vxlan_udp_tbl, 0);
 			if (ret > 0)
 				/* Merge successfully */
 				nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
 		 || (unprocess_num < nb_pkts)) {
 		i = 0;
 		/* Flush all packets from the tables */
-		if (do_vxlan_gro) {
-			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+		if (do_vxlan_tcp_gro) {
+			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
 					0, pkts, nb_pkts);
 		}
 
+		if (do_vxlan_udp_gro) {
+			i +=
 gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+					0, &pkts[i], nb_pkts - i);
+
+		}
+
 		if (do_tcp4_gro) {
 			i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
lib/librte_gro/rte_gro.c +2 -2
 					&pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	struct gro_ctx *gro_ctx = ctx;
-	void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+	void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
 	uint64_t current_time;
 	uint16_t i, unprocess_num = 0;
-	uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+	uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro,
 do_vxlan_udp_gro;
 
 	if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4

|

lib/librte_gro/rte_gro.c +2 -1
 					RTE_GRO_TCP_IPV4 |
+					RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 					RTE_GRO_UDP_IPV4)) == 0))
 		return nb_pkts;
 
 	tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-	vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+	vxlan_tcp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

lib/librte_gro/rte_gro.c +1 -0
 	udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+	vxlan_udp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

lib/librte_gro/rte_gro.c +0 -1
 	do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
 		RTE_GRO_TCP_IPV4;
-	do_vxlan_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

lib/librte_gro/rte_gro.c +1 -0
+	do_vxlan_tcp_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

lib/librte_gro/rte_gro.c +1 -0
 		RTE_GRO_IPV4_VXLAN_TCP_IPV4;
 	do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
 		RTE_GRO_UDP_IPV4;
+	do_vxlan_udp_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

lib/librte_gro/rte_gro.c +8 -2
+		RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
 	current_time = rte_rdtsc();
 
 	for (i = 0; i < nb_pkts; i++) {
 		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-				do_vxlan_gro) {
-			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+				do_vxlan_tcp_gro) {
+			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+						current_time) < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_udp_gro) {
+			if (gro_vxlan_udp4_reassemble(pkts[i],

vxlan_udp_tbl,

lib/librte_gro/rte_gro.c +0 -0
 						current_time) < 0)
 				unprocess_pkts[unprocess_num++] = pkts[i];
 		} else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

lib/librte_gro/rte_gro.c struct gro_ctx { · line 401

Quoted 5 lines
lib/librte_gro/rte_gro.c +1 -0
@@ -341,6 +397,13 @@ struct gro_ctx {
 		left_nb_out = max_nb_out - num;
 	}
 
+	if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out >
 0) {

Max_nb_out is read-only and not updated. So it cannot check if 'out' array has enough space. Need to use left_nb_out instead. This issue also existed in UDP/IPv4 GRO, and please correct them both.

Quoted 26 lines
lib/librte_gro/rte_gro.c +6 -0
+		num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+				RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+				flush_timestamp, &out[num], left_nb_out);
+		left_nb_out = max_nb_out - num;
+	}
+
 	/* If no available space in 'out', stop flushing. */
 	if ((gro_types & RTE_GRO_TCP_IPV4) && max_nb_out > 0) {
lib/librte_gro/rte_gro.c +0 -0
 		num += gro_tcp4_tbl_timeout_flush(
lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL <<
 RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**

* Structure used to create GRO context objects or used to pass
--
1.8.3.1

author
#6 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

BTW, start_time is checked for the first packet in a flow, gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check start_time, so this still can let some new items in this flow have chance to be merged.

Quoted 449 lines · yang_y_yi

Thanks Jiayu, I have fixed other comments except this one:

Quoted 5 lines

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

lib/librte_gro/gro_udp4.c +0 -7
index 061e7b0..ffa35a2 100644
@@ -391,7 +391,6 @@
 
               j = tbl->flows[i].start_index;
               while (j != INVALID_ARRAY_INDEX) {
-                       if (tbl->items[j].start_time <= flush_timestamp) {
                               gro_udp4_merge_items(tbl, j);
                               out[k++] = tbl->items[j].firstseg;
                               if (tbl->items[j].nb_merged > 1)
@@ -407,12 +406,6 @@
 
                               if (unlikely(k == nb_out))
                                       return k;
-                       } else
-                               /*
-                                * The left packets in this flow won't be
-                                * timeout. Go to check other flows.
-                                */
-                               break;
               }
       }
       return k;
Quoted 397 lines · Jiayu

Hi Yi,

Some comments are inline.

Thanks,
Jiayu

Quoted 89 lines

-----Original Message-----
From: [email protected] <[email protected]>
Sent: Thursday, September 17, 2020 11:50 AM
To: [email protected]
Cc: Hu, Jiayu <[email protected]>; [email protected]; [email protected]; [email protected]
Subject: [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

VXLAN UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble VXLAN UDP/IPv4 fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case.

Note: outer IP ID isn't used to check if two packets are same flow and can be merged because the difference between outer IP IDs of two packets isn't always +/-1 in case of OVS DPDK.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 542
++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 154 ++++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 790 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +23 -0
new file mode 100644
index 0000000..4eece56
@@ -0,0 +1,542 @@
+
+uint16_t
+gro_vxlan_udp4_tbl_timeout_flush(struct gro_vxlan_udp4_tbl *tbl,
+		uint64_t flush_timestamp,
+		struct rte_mbuf **out,
+		uint16_t nb_out)
+{
+	uint16_t k = 0;
+	uint32_t i, j;
+	uint32_t max_flow_num = tbl->max_flow_num;
+
+	for (i = 0; i < max_flow_num; i++) {
+		if (unlikely(tbl->flow_num == 0))
+			return k;
+
+		j = tbl->flows[i].start_index;
+		while (j != INVALID_ARRAY_INDEX) {
+			if (tbl->items[j].inner_item.start_time <=
+					flush_timestamp) {
+				gro_vxlan_udp4_merge_items(tbl, j);
+				out[k++] = tbl->items[j].inner_item.firstseg;
+				if (tbl->items[j].inner_item.nb_merged > 1)
+					update_vxlan_header(&(tbl-
Quoted 1 line

items[j]));

lib/librte_gro/gro_vxlan_udp4.c new file +7 -0
+				/*
+				 * Delete the item and get the next packet
+				 * index.
+				 */
+				j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+				tbl->flows[i].start_index = j;
+				if (j == INVALID_ARRAY_INDEX)

lib/librte_gro/gro_vxlan_udp4.c

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+					tbl->flow_num--;
+
+				if (unlikely(k == nb_out))
+					return k;
+			} else
+				/*
+				 * The left packets in the flow won't be
+				 * timeout. Go to check other flows.
+				 */
+				break;

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 28 lines
lib/librte_gro/gro_vxlan_udp4.c new file +4 -0
+		}
+	}
+	return k;
+}
lib/librte_gro/gro_vxlan_udp4.h new file +17 -0
new file mode 100644
index 0000000..6a42fb3
@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#ifndef _GRO_VXLAN_UDP4_H_
+#define _GRO_VXLAN_UDP4_H_
+
+#include "gro_udp4.h"
+
+#define GRO_VXLAN_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
+
+/* Header fields representing a VxLAN flow */
+struct vxlan_udp4_flow_key {
+	struct udp4_flow_key inner_key;
+	struct rte_vxlan_hdr vxlan_hdr;
+
+	struct rte_ether_addr outer_eth_saddr;

lib/librte_gro/gro_vxlan_udp4.h line 27

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+	struct rte_ether_addr outer_eth_daddr;
+
+	uint32_t outer_ip_src_addr;
+	uint32_t outer_ip_dst_addr;
+
+	/* Note: It is unnecessary to save outer_src_port here because it can
+	 * be different for VxLAN UDP fragments from the same flow.
+	 */
+	uint16_t outer_dst_port;
+

The above empty line is unnecessary.

lib/librte_gro/gro_vxlan_udp4.h line 37

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+};
+
+
+struct gro_vxlan_udp4_item {
+	struct gro_udp4_item inner_item;
+	/* Note: VXLAN UDP/IPv4 GRO needn't check outer_ip_id because
+	 * the difference between outer_ip_ids of two received packets
+	 * isn't always +/-1 in case of OVS DPDK. So no outer_ip_id
+	 * and outer_is_atomic fields here.
+	 */

It seems the above comments for outer IP ID is enough, and no need to highlight in the commit log again. How do you think?

Quoted 193 lines
lib/librte_gro/gro_vxlan_udp4.h new file +2 -0
+};
+
lib/librte_gro/rte_gro.c +1 -3
index f623230..db990cf 100644
@@ -11,6 +11,7 @@
 #include "gro_tcp4.h"
 #include "gro_udp4.h"
 #include "gro_vxlan_tcp4.h"
+#include "gro_vxlan_udp4.h"
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
 	struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 = {{0} };
 
 	/* Allocate a reassembly table for VXLAN TCP GRO */
-	struct gro_vxlan_tcp4_tbl vxlan_tbl;
-	struct gro_vxlan_tcp4_flow
 vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-	struct gro_vxlan_tcp4_item

vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +2 -0
+	struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+	struct gro_vxlan_tcp4_flow

vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

lib/librte_gro/rte_gro.c +1 -0
+	struct gro_vxlan_tcp4_item

vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +3 -0
 			= {{{0}, 0, 0} };
 
+	/* Allocate a reassembly table for VXLAN UDP GRO */
+	struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+	struct gro_vxlan_udp4_flow

vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];

lib/librte_gro/rte_gro.c +1 -0
+	struct gro_vxlan_udp4_item

vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +27 -10
+			= {{{0}} };
+
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	uint32_t item_num;
 	int32_t ret;
 	uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-	uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+	uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+		do_vxlan_udp_gro = 0;
 
 	if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
 					RTE_GRO_TCP_IPV4 |
+					RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 					RTE_GRO_UDP_IPV4)) == 0))
 		return nb_pkts;
@@ -160,15 +179,28 @@ struct gro_ctx {
 
 	if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
 		for (i = 0; i < item_num; i++)
-			vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-		vxlan_tbl.flows = vxlan_flows;
-		vxlan_tbl.items = vxlan_items;
-		vxlan_tbl.flow_num = 0;
-		vxlan_tbl.item_num = 0;
-		vxlan_tbl.max_flow_num = item_num;
-		vxlan_tbl.max_item_num = item_num;
-		do_vxlan_gro = 1;
+			vxlan_tcp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+		vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+		vxlan_tcp_tbl.items = vxlan_tcp_items;
+		vxlan_tcp_tbl.flow_num = 0;
+		vxlan_tcp_tbl.item_num = 0;
+		vxlan_tcp_tbl.max_flow_num = item_num;
+		vxlan_tcp_tbl.max_item_num = item_num;
+		do_vxlan_tcp_gro = 1;
+	}
+
+	if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+		for (i = 0; i < item_num; i++)
+			vxlan_udp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+		vxlan_udp_tbl.flows = vxlan_udp_flows;
+		vxlan_udp_tbl.items = vxlan_udp_items;
+		vxlan_udp_tbl.flow_num = 0;
+		vxlan_udp_tbl.item_num = 0;
+		vxlan_udp_tbl.max_flow_num = item_num;
+		vxlan_udp_tbl.max_item_num = item_num;
+		do_vxlan_udp_gro = 1;
 	}
lib/librte_gro/rte_gro.c +19 -4
 	if (param->gro_types & RTE_GRO_TCP_IPV4) {
@@ -204,9 +236,18 @@ struct gro_ctx {
 		 * will be flushed from the tables.
 		 */
 		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-				do_vxlan_gro) {
+				do_vxlan_tcp_gro) {
 			ret = gro_vxlan_tcp4_reassemble(pkts[i],
-							&vxlan_tbl, 0);
+							&vxlan_tcp_tbl, 0);
+			if (ret > 0)
+				/* Merge successfully */
+				nb_after_gro--;
+			else if (ret < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_udp_gro) {
+			ret = gro_vxlan_udp4_reassemble(pkts[i],
+							&vxlan_udp_tbl, 0);
 			if (ret > 0)
 				/* Merge successfully */
 				nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
 		 || (unprocess_num < nb_pkts)) {
 		i = 0;
 		/* Flush all packets from the tables */
-		if (do_vxlan_gro) {
-			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+		if (do_vxlan_tcp_gro) {
+			i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
 					0, pkts, nb_pkts);
 		}
 
+		if (do_vxlan_udp_gro) {
+			i +=
 gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+					0, &pkts[i], nb_pkts - i);
+
+		}
+
 		if (do_tcp4_gro) {
 			i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
lib/librte_gro/rte_gro.c +2 -2
 					&pkts[i], nb_pkts - i);
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
 	struct rte_mbuf *unprocess_pkts[nb_pkts];
 	struct gro_ctx *gro_ctx = ctx;
-	void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+	void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
 	uint64_t current_time;
 	uint16_t i, unprocess_num = 0;
-	uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+	uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro,
 do_vxlan_udp_gro;
 
 	if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4

|

lib/librte_gro/rte_gro.c +2 -1
 					RTE_GRO_TCP_IPV4 |
+					RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
 					RTE_GRO_UDP_IPV4)) == 0))
 		return nb_pkts;
 
 	tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-	vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+	vxlan_tcp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

lib/librte_gro/rte_gro.c +1 -0
 	udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];
+	vxlan_udp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

lib/librte_gro/rte_gro.c +0 -1
 	do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
 		RTE_GRO_TCP_IPV4;
-	do_vxlan_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

lib/librte_gro/rte_gro.c +1 -0
+	do_vxlan_tcp_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

lib/librte_gro/rte_gro.c +1 -0
 		RTE_GRO_IPV4_VXLAN_TCP_IPV4;
 	do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
 		RTE_GRO_UDP_IPV4;
+	do_vxlan_udp_gro = (gro_ctx->gro_types &

RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

lib/librte_gro/rte_gro.c +8 -2
+		RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
 	current_time = rte_rdtsc();
 
 	for (i = 0; i < nb_pkts; i++) {
 		if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-				do_vxlan_gro) {
-			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+				do_vxlan_tcp_gro) {
+			if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+						current_time) < 0)
+				unprocess_pkts[unprocess_num++] = pkts[i];
+		} else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+				do_vxlan_udp_gro) {
+			if (gro_vxlan_udp4_reassemble(pkts[i],

vxlan_udp_tbl,

lib/librte_gro/rte_gro.c +0 -0
 						current_time) < 0)
 				unprocess_pkts[unprocess_num++] = pkts[i];
 		} else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

lib/librte_gro/rte_gro.c struct gro_ctx { · line 401

Quoted 5 lines
lib/librte_gro/rte_gro.c +1 -0
@@ -341,6 +397,13 @@ struct gro_ctx {
 		left_nb_out = max_nb_out - num;
 	}
 
+	if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out >
 0) {

Max_nb_out is read-only and not updated. So it cannot check if 'out' array has enough space. Need to use left_nb_out instead. This issue also existed in UDP/IPv4 GRO, and please correct them both.

Quoted 26 lines
lib/librte_gro/rte_gro.c +6 -0
+		num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+				RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+				flush_timestamp, &out[num], left_nb_out);
+		left_nb_out = max_nb_out - num;
+	}
+
 	/* If no available space in 'out', stop flushing. */
 	if ((gro_types & RTE_GRO_TCP_IPV4) && max_nb_out > 0) {
lib/librte_gro/rte_gro.c +0 -0
 		num += gro_tcp4_tbl_timeout_flush(
lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL <<
 RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**

* Structure used to create GRO context objects or used to pass
--
1.8.3.1

#7 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Fragments of a flow are sorted by frag_oft, but they may have different timestamp. For example, there are three fragments, whose frag_oft is:
frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are fragments of one UDP packet but are not neighbors. In the first RX burst, host receives frag[1] and calls rte_gro_reassemble(), and we assume the timestamp of frag[1] is 10; in the second RX burst, host receives frag[0] and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the third time, host receives frag[2] and timestamp of frag[2] is 12. The three fragments are stored in three items of a UDP GRO table:
items[0]: frag[0], timestamp is 11
items[1]: frag[1], timestamp is 10
items[2]: frag[2], timestamp is 12
Now we want to flush packets whose timestamp is less than or equal to
10. frag[1] should be returned, but in your code, no packets will be flushed. Because the timestamp of items[0] is greater than 10, the left two fragments will not be checked. This is what I want to say.

From: yang_y_yi <[email protected]>
Sent: Tuesday, September 22, 2020 9:44 AM
To: Hu, Jiayu <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support
Importance: High

BTW, start_time is checked for the first packet in a flow, gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check start_time, so this still can let some new items in this flow have chance to be merged.

Quoted 85 lines · At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]<mailto:[email protected]…

Thanks Jiayu, I have fixed other comments except this one:

Quoted 9 lines

The items of a flow are ordered by frag_oft, and start_time

of these items is not always in ascending order. Therefore,

you cannot skip checking the items after the item whose

start_time is greater than flush_timestamp. This issue also

exists in UDP/IPv4 GRO, and need to correct them both.

I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

lib/librte_gro/gro_udp4.c +0 -0

index 061e7b0..ffa35a2 100644

--- a/lib/librte_gro/gro_udp4.c

+++ b/lib/librte_gro/gro_udp4.c

lib/librte_gro/gro_udp4.c +0 -7
@@ -391,7 +391,6 @@
 
 
 
               j = tbl->flows[i].start_index;
 
               while (j != INVALID_ARRAY_INDEX) {
 
-                       if (tbl->items[j].start_time <= flush_timestamp) {
 
                               gro_udp4_merge_items(tbl, j);
 
                               out[k++] = tbl->items[j].firstseg;
 
                               if (tbl->items[j].nb_merged > 1)
@@ -407,12 +406,6 @@
 
 
 
                               if (unlikely(k == nb_out))
 
                                       return k;
 
-                       } else
 
-                               /*
 
-                                * The left packets in this flow won't be
 
-                                * timeout. Go to check other flows.
 
-                                */
 
-                               break;
 
               }
 
       }
 
       return k;
author
#8 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

Fragments of a flow are sorted by frag_oft, but they may have different

timestamp. For example, there are three fragments, whose frag_oft is:

frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

fragments of one UDP packet but are not neighbors. In the first RX burst,

host receives frag[1] and calls rte_gro_reassemble(), and we assume the

timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

third time, host receives frag[2] and timestamp of frag[2] is 12. The three

fragments are stored in three items of a UDP GRO table:

items[0]: frag[0], timestamp is 11

items[1]: frag[1], timestamp is 10

items[2]: frag[2], timestamp is 12

Now we want to flush packets whose timestamp is less than or equal to

10. frag[1] should be returned, but in your code, no packets will be flushed.

Because the timestamp of items[0] is greater than 10, the left two fragments

will not be checked. This is what I want to say.

From: yang_y_yi <[email protected]>
Sent: Tuesday, September 22, 2020 9:44 AM
To: Hu, Jiayu <[email protected]>
Cc: [email protected]; [email protected]; [email protected]
Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support
Importance: High

BTW, start_time is checked for the first packet in a flow, gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check start_time, so this still can let some new items in this flow have chance to be merged.

Quoted 43 lines · yang_y_yi

Thanks Jiayu, I have fixed other comments except this one:

Quoted 5 lines

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

lib/librte_gro/gro_udp4.c +0 -7
index 061e7b0..ffa35a2 100644
@@ -391,7 +391,6 @@
 
               j = tbl->flows[i].start_index;
               while (j != INVALID_ARRAY_INDEX) {
-                       if (tbl->items[j].start_time <= flush_timestamp) {
                               gro_udp4_merge_items(tbl, j);
                               out[k++] = tbl->items[j].firstseg;
                               if (tbl->items[j].nb_merged > 1)
@@ -407,12 +406,6 @@
 
                               if (unlikely(k == nb_out))
                                       return k;
-                       } else
-                               /*
-                                * The left packets in this flow won't be
-                                * timeout. Go to check other flows.
-                                */
-                               break;
               }
       }
       return k;
#9 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Quoted 2 lines · yang_y_yi

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

who will check the timestamp? I did't get the point.

IMO, this will cause inconsistency of the rte_gro_timeout_flush(). BTW, what stops you to traverse all items and check timestamp before flush them out?

Quoted 149 lines

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

    Fragments of a flow are sorted by frag_oft, but they may have different

    timestamp. For example, there are three fragments, whose frag_oft is:

    frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

    fragments of one UDP packet but are not neighbors. In the first RX burst,

    host receives frag[1] and calls rte_gro_reassemble(), and we assume the

    timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

    and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

    third time, host receives frag[2] and timestamp of frag[2] is 12. The three

    fragments are stored in three items of a UDP GRO table:

    items[0]: frag[0], timestamp is 11

    items[1]: frag[1], timestamp is 10

    items[2]: frag[2], timestamp is 12

    Now we want to flush packets whose timestamp is less than or equal to

    10. frag[1] should be returned, but in your code, no packets will be
    flushed.

    Because the timestamp of items[0] is greater than 10, the left two
    fragments

    will not be checked. This is what I want to say.

     

    From: yang_y_yi <[email protected]>
    Sent: Tuesday, September 22, 2020 9:44 AM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO
    support
    Importance: High

     

    BTW, start_time is checked for the first packet in a flow,
    gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once
    if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check
    start_time, so this still can let some new items in this flow have chance
    to be merged.

    At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]> wrote:

    >Thanks Jiayu, I have fixed other comments except this one:

    > 

    > 

    > 

    >>The items of a flow are ordered by frag_oft, and start_time

    >>of these items is not always in ascending order. Therefore,

    >>you cannot skip checking the items after the item whose

    >>start_time is greater than flush_timestamp. This issue also

    >>exists in UDP/IPv4 GRO, and need to correct them both.

    > 

    > 

    >I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

    > 

    > 

    > 

    > 

    > 

    >diff --git a/lib/librte_gro/gro_udp4.c b/lib/librte_gro/gro_udp4.c

    >index 061e7b0..ffa35a2 100644

    >--- a/lib/librte_gro/gro_udp4.c

    >+++ b/lib/librte_gro/gro_udp4.c

    >@@ -391,7 +391,6 @@

    > 

    >                j = tbl->flows[i].start_index;

    >                while (j != INVALID_ARRAY_INDEX) {

    >-                       if (tbl->items[j].start_time <= flush_timestamp) {

    >                                gro_udp4_merge_items(tbl, j);

    >                                out[k++] = tbl->items[j].firstseg;

    >                                if (tbl->items[j].nb_merged > 1)

    >@@ -407,12 +406,6 @@

    > 

    >                                if (unlikely(k == nb_out))

    >                                        return k;

    >-                       } else

    >-                               /*

    >-                                * The left packets in this flow won't be

    >-                                * timeout. Go to check other flows.

    >-                                */

    >-                               break;

    >                }

    >        }

    >        return k;

    > 
author
#10 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

The problem is timestamp of which one item in a flow we should use as timestamp reference base for this flow, for merge (reassemble), only the first packet can trigger merge of all the packets, merge is forward not backward, if you traverse the whole linked list in this flow to get the oldest timestamp and compare it with flushtime, that will be not worthy, in the worst case (say I send a 64K UDP packet and MTU is 1450), you will have 46 items to check to get the oldest timestamp by linked list.

I'm not sure what inconsistentcy you're saying mean.

Quoted 159 lines · Jiayu Hu
Quoted 2 lines · yang_y_yi

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

who will check the timestamp? I did't get the point.

IMO, this will cause inconsistency of the rte_gro_timeout_flush(). BTW, what stops you to traverse all items and check timestamp before flush them out?

Quoted 149 lines

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

    Fragments of a flow are sorted by frag_oft, but they may have different

    timestamp. For example, there are three fragments, whose frag_oft is:

    frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

    fragments of one UDP packet but are not neighbors. In the first RX burst,

    host receives frag[1] and calls rte_gro_reassemble(), and we assume the

    timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

    and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

    third time, host receives frag[2] and timestamp of frag[2] is 12. The three

    fragments are stored in three items of a UDP GRO table:

    items[0]: frag[0], timestamp is 11

    items[1]: frag[1], timestamp is 10

    items[2]: frag[2], timestamp is 12

    Now we want to flush packets whose timestamp is less than or equal to

    10. frag[1] should be returned, but in your code, no packets will be
    flushed.

    Because the timestamp of items[0] is greater than 10, the left two
    fragments

    will not be checked. This is what I want to say.

     

    From: yang_y_yi <[email protected]>
    Sent: Tuesday, September 22, 2020 9:44 AM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO
    support
    Importance: High

     

    BTW, start_time is checked for the first packet in a flow,
    gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once
    if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check
    start_time, so this still can let some new items in this flow have chance
    to be merged.

    At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]> wrote:

    >Thanks Jiayu, I have fixed other comments except this one:

    > 

    > 

    > 

    >>The items of a flow are ordered by frag_oft, and start_time

    >>of these items is not always in ascending order. Therefore,

    >>you cannot skip checking the items after the item whose

    >>start_time is greater than flush_timestamp. This issue also

    >>exists in UDP/IPv4 GRO, and need to correct them both.

    > 

    > 

    >I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

    > 

    > 

    > 

    > 

    > 

    >diff --git a/lib/librte_gro/gro_udp4.c b/lib/librte_gro/gro_udp4.c

    >index 061e7b0..ffa35a2 100644

    >--- a/lib/librte_gro/gro_udp4.c

    >+++ b/lib/librte_gro/gro_udp4.c

    >@@ -391,7 +391,6 @@

    > 

    >                j = tbl->flows[i].start_index;

    >                while (j != INVALID_ARRAY_INDEX) {

    >-                       if (tbl->items[j].start_time <= flush_timestamp) {

    >                                gro_udp4_merge_items(tbl, j);

    >                                out[k++] = tbl->items[j].firstseg;

    >                                if (tbl->items[j].nb_merged > 1)

    >@@ -407,12 +406,6 @@

    > 

    >                                if (unlikely(k == nb_out))

    >                                        return k;

    >-                       } else

    >-                               /*

    >-                                * The left packets in this flow won't be

    >-                                * timeout. Go to check other flows.

    >-                                */

    >-                               break;

    >                }

    >        }

    >        return k;

    > 
#11 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Quoted 7 lines · yang_y_yi

The problem is timestamp of which one item in a flow we should use as timestamp reference base for this flow, for merge (reassemble), only the first packet can trigger merge of all the packets, merge is forward not backward, if you traverse the whole linked list in this flow to get the oldest timestamp and compare it with flushtime, that will be not worthy, in the worst case (say I send a 64K UDP packet and MTU is 1450), you will have 46 items to check to get the oldest timestamp by linked list.

OK, I got the point. I agree to flush packets without strictly obeying timestamp. But you need to change the comment in the code and clarify the design for both UDP and VxLAN GRO patch. Current comment "The left packets in ..." is not appropriate for your design.

Quoted 169 lines

I'm not sure what inconsistentcy you're saying mean.

Quoted 159 lines · Jiayu Hu
Quoted 2 lines · yang_y_yi

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

who will check the timestamp? I did't get the point.

IMO, this will cause inconsistency of the rte_gro_timeout_flush(). BTW, what stops you to traverse all items and check timestamp before flush them out?

Quoted 149 lines

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

    Fragments of a flow are sorted by frag_oft, but they may have different

    timestamp. For example, there are three fragments, whose frag_oft is:

    frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

    fragments of one UDP packet but are not neighbors. In the first RX burst,

    host receives frag[1] and calls rte_gro_reassemble(), and we assume the

    timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

    and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

    third time, host receives frag[2] and timestamp of frag[2] is 12. The three

    fragments are stored in three items of a UDP GRO table:

    items[0]: frag[0], timestamp is 11

    items[1]: frag[1], timestamp is 10

    items[2]: frag[2], timestamp is 12

    Now we want to flush packets whose timestamp is less than or equal to

    10. frag[1] should be returned, but in your code, no packets will be
    flushed.

    Because the timestamp of items[0] is greater than 10, the left two
    fragments

    will not be checked. This is what I want to say.



    From: yang_y_yi <[email protected]>
    Sent: Tuesday, September 22, 2020 9:44 AM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO
    support
    Importance: High



    BTW, start_time is checked for the first packet in a flow,
    gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once
    if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check
    start_time, so this still can let some new items in this flow have chance
    to be merged.

    At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]> wrote:

    >Thanks Jiayu, I have fixed other comments except this one:

    >

    >

    >

    >>The items of a flow are ordered by frag_oft, and start_time

    >>of these items is not always in ascending order. Therefore,

    >>you cannot skip checking the items after the item whose

    >>start_time is greater than flush_timestamp. This issue also

    >>exists in UDP/IPv4 GRO, and need to correct them both.

    >

    >

    >I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

    >

    >

    >

    >

    >

    >diff --git a/lib/librte_gro/gro_udp4.c b/lib/librte_gro/gro_udp4.c

    >index 061e7b0..ffa35a2 100644

    >--- a/lib/librte_gro/gro_udp4.c

    >+++ b/lib/librte_gro/gro_udp4.c

    >@@ -391,7 +391,6 @@

    >

    >                j = tbl->flows[i].start_index;

    >                while (j != INVALID_ARRAY_INDEX) {

    >-                       if (tbl->items[j].start_time <= flush_timestamp) {

    >                                gro_udp4_merge_items(tbl, j);

    >                                out[k++] = tbl->items[j].firstseg;

    >                                if (tbl->items[j].nb_merged > 1)

    >@@ -407,12 +406,6 @@

    >

    >                                if (unlikely(k == nb_out))

    >                                        return k;

    >-                       } else

    >-                               /*

    >-                                * The left packets in this flow won't be

    >-                                * timeout. Go to check other flows.

    >-                                */

    >-                               break;

    >                }

    >        }

    >        return k;

    >
author
#12 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Thanks Jiayu, do you mean not comparing timestamp and flush all the packets in a flow as I showed code, right? If so, we shouldn't provide argument flush_timestamp. But this will result in very bad issues, rte_gro_timeout_flush will be called after rte_gro_reassemble every time, so the result may be you can't reassemble out any original UDP packet because every UDP fragments will be flushed very soon, no chance to reassemble.

Quoted 184 lines · Jiayu Hu
Quoted 7 lines · yang_y_yi

The problem is timestamp of which one item in a flow we should use as timestamp reference base for this flow, for merge (reassemble), only the first packet can trigger merge of all the packets, merge is forward not backward, if you traverse the whole linked list in this flow to get the oldest timestamp and compare it with flushtime, that will be not worthy, in the worst case (say I send a 64K UDP packet and MTU is 1450), you will have 46 items to check to get the oldest timestamp by linked list.

OK, I got the point. I agree to flush packets without strictly obeying timestamp. But you need to change the comment in the code and clarify the design for both UDP and VxLAN GRO patch. Current comment "The left packets in ..." is not appropriate for your design.

Quoted 169 lines

I'm not sure what inconsistentcy you're saying mean.

Quoted 159 lines · Jiayu Hu
Quoted 2 lines · yang_y_yi

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

who will check the timestamp? I did't get the point.

IMO, this will cause inconsistency of the rte_gro_timeout_flush(). BTW, what stops you to traverse all items and check timestamp before flush them out?

Quoted 149 lines

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

    Fragments of a flow are sorted by frag_oft, but they may have different

    timestamp. For example, there are three fragments, whose frag_oft is:

    frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

    fragments of one UDP packet but are not neighbors. In the first RX burst,

    host receives frag[1] and calls rte_gro_reassemble(), and we assume the

    timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

    and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

    third time, host receives frag[2] and timestamp of frag[2] is 12. The three

    fragments are stored in three items of a UDP GRO table:

    items[0]: frag[0], timestamp is 11

    items[1]: frag[1], timestamp is 10

    items[2]: frag[2], timestamp is 12

    Now we want to flush packets whose timestamp is less than or equal to

    10. frag[1] should be returned, but in your code, no packets will be
    flushed.

    Because the timestamp of items[0] is greater than 10, the left two
    fragments

    will not be checked. This is what I want to say.



    From: yang_y_yi <[email protected]>
    Sent: Tuesday, September 22, 2020 9:44 AM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO
    support
    Importance: High



    BTW, start_time is checked for the first packet in a flow,
    gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once
    if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check
    start_time, so this still can let some new items in this flow have chance
    to be merged.

    At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]> wrote:

    >Thanks Jiayu, I have fixed other comments except this one:

    >

    >

    >

    >>The items of a flow are ordered by frag_oft, and start_time

    >>of these items is not always in ascending order. Therefore,

    >>you cannot skip checking the items after the item whose

    >>start_time is greater than flush_timestamp. This issue also

    >>exists in UDP/IPv4 GRO, and need to correct them both.

    >

    >

    >I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

    >

    >

    >

    >

    >

    >diff --git a/lib/librte_gro/gro_udp4.c b/lib/librte_gro/gro_udp4.c

    >index 061e7b0..ffa35a2 100644

    >--- a/lib/librte_gro/gro_udp4.c

    >+++ b/lib/librte_gro/gro_udp4.c

    >@@ -391,7 +391,6 @@

    >

    >                j = tbl->flows[i].start_index;

    >                while (j != INVALID_ARRAY_INDEX) {

    >-                       if (tbl->items[j].start_time <= flush_timestamp) {

    >                                gro_udp4_merge_items(tbl, j);

    >                                out[k++] = tbl->items[j].firstseg;

    >                                if (tbl->items[j].nb_merged > 1)

    >@@ -407,12 +406,6 @@

    >

    >                                if (unlikely(k == nb_out))

    >                                        return k;

    >-                       } else

    >-                               /*

    >-                                * The left packets in this flow won't be

    >-                                * timeout. Go to check other flows.

    >-                                */

    >-                               break;

    >                }

    >        }

    >        return k;

    >
#13 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Quoted 6 lines · yang_y_yi

Thanks Jiayu, do you mean not comparing timestamp and flush all the packets in a flow as I showed code, right? If so, we shouldn't provide argument flush_timestamp. But this will result in very bad issues, rte_gro_timeout_flush will be called after rte_gro_reassemble every time, so the result may be you can't reassemble out any original UDP packet because every UDP fragments will be flushed very soon, no chance to reassemble.

No, I mean the design in your patch, which stops flushing packets once find one whose timestamp is greater than flush_timestamp.

Quoted 191 lines
Quoted 184 lines · Jiayu Hu
Quoted 7 lines · yang_y_yi

The problem is timestamp of which one item in a flow we should use as timestamp reference base for this flow, for merge (reassemble), only the first packet can trigger merge of all the packets, merge is forward not backward, if you traverse the whole linked list in this flow to get the oldest timestamp and compare it with flushtime, that will be not worthy, in the worst case (say I send a 64K UDP packet and MTU is 1450), you will have 46 items to check to get the oldest timestamp by linked list.

OK, I got the point. I agree to flush packets without strictly obeying timestamp. But you need to change the comment in the code and clarify the design for both UDP and VxLAN GRO patch. Current comment "The left packets in ..." is not appropriate for your design.

Quoted 169 lines

I'm not sure what inconsistentcy you're saying mean.

Quoted 159 lines · Jiayu Hu
Quoted 2 lines · yang_y_yi

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

who will check the timestamp? I did't get the point.

IMO, this will cause inconsistency of the rte_gro_timeout_flush(). BTW, what stops you to traverse all items and check timestamp before flush them out?

Quoted 149 lines

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

    Fragments of a flow are sorted by frag_oft, but they may have different

    timestamp. For example, there are three fragments, whose frag_oft is:

    frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

    fragments of one UDP packet but are not neighbors. In the first RX burst,

    host receives frag[1] and calls rte_gro_reassemble(), and we assume the

    timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

    and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

    third time, host receives frag[2] and timestamp of frag[2] is 12. The three

    fragments are stored in three items of a UDP GRO table:

    items[0]: frag[0], timestamp is 11

    items[1]: frag[1], timestamp is 10

    items[2]: frag[2], timestamp is 12

    Now we want to flush packets whose timestamp is less than or equal to

    10. frag[1] should be returned, but in your code, no packets will be
    flushed.

    Because the timestamp of items[0] is greater than 10, the left two
    fragments

    will not be checked. This is what I want to say.



    From: yang_y_yi <[email protected]>
    Sent: Tuesday, September 22, 2020 9:44 AM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO
    support
    Importance: High



    BTW, start_time is checked for the first packet in a flow,
    gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once
    if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check
    start_time, so this still can let some new items in this flow have chance
    to be merged.

    At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]> wrote:

    >Thanks Jiayu, I have fixed other comments except this one:

    >

    >

    >

    >>The items of a flow are ordered by frag_oft, and start_time

    >>of these items is not always in ascending order. Therefore,

    >>you cannot skip checking the items after the item whose

    >>start_time is greater than flush_timestamp. This issue also

    >>exists in UDP/IPv4 GRO, and need to correct them both.

    >

    >

    >I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

    >

    >

    >

    >

    >

    >diff --git a/lib/librte_gro/gro_udp4.c b/lib/librte_gro/gro_udp4.c

    >index 061e7b0..ffa35a2 100644

    >--- a/lib/librte_gro/gro_udp4.c

    >+++ b/lib/librte_gro/gro_udp4.c

    >@@ -391,7 +391,6 @@

    >

    >                j = tbl->flows[i].start_index;

    >                while (j != INVALID_ARRAY_INDEX) {

    >-                       if (tbl->items[j].start_time <= flush_timestamp) {

    >                                gro_udp4_merge_items(tbl, j);

    >                                out[k++] = tbl->items[j].firstseg;

    >                                if (tbl->items[j].nb_merged > 1)

    >@@ -407,12 +406,6 @@

    >

    >                                if (unlikely(k == nb_out))

    >                                        return k;

    >-                       } else

    >-                               /*

    >-                                * The left packets in this flow won't be

    >-                                * timeout. Go to check other flows.

    >-                                */

    >-                               break;

    >                }

    >        }

    >        return k;

    >
author
#14 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Jiayu, is this comment ok?

lib/librte_gro/gro_udp4.c +4 -2
index 061e7b0..93e368a 100644
@@ -409,8 +409,10 @@
                                        return k;
                        } else
                                /*
-                                * The left packets in this flow won't be
-                                * timeout. Go to check other flows.
+                                * If start_time of one item is greater than
+                                * flush_timestamp, that means the left packets
+                                * in this flow won't be flushed this time. Go
+                                * to check other flows.
                                 */
                                break;
                }
Quoted 202 lines · Jiayu Hu
Quoted 6 lines · yang_y_yi

Thanks Jiayu, do you mean not comparing timestamp and flush all the packets in a flow as I showed code, right? If so, we shouldn't provide argument flush_timestamp. But this will result in very bad issues, rte_gro_timeout_flush will be called after rte_gro_reassemble every time, so the result may be you can't reassemble out any original UDP packet because every UDP fragments will be flushed very soon, no chance to reassemble.

No, I mean the design in your patch, which stops flushing packets once find one whose timestamp is greater than flush_timestamp.

Quoted 191 lines
Quoted 184 lines · Jiayu Hu
Quoted 7 lines · yang_y_yi

The problem is timestamp of which one item in a flow we should use as timestamp reference base for this flow, for merge (reassemble), only the first packet can trigger merge of all the packets, merge is forward not backward, if you traverse the whole linked list in this flow to get the oldest timestamp and compare it with flushtime, that will be not worthy, in the worst case (say I send a 64K UDP packet and MTU is 1450), you will have 46 items to check to get the oldest timestamp by linked list.

OK, I got the point. I agree to flush packets without strictly obeying timestamp. But you need to change the comment in the code and clarify the design for both UDP and VxLAN GRO patch. Current comment "The left packets in ..." is not appropriate for your design.

Quoted 169 lines

I'm not sure what inconsistentcy you're saying mean.

Quoted 159 lines · Jiayu Hu
Quoted 2 lines · yang_y_yi

Not a question, in next flush, they will be flushed, we have to check timestamp in the first time unless we don't strictly follow this time limitation.

who will check the timestamp? I did't get the point.

IMO, this will cause inconsistency of the rte_gro_timeout_flush(). BTW, what stops you to traverse all items and check timestamp before flush them out?

Quoted 149 lines

At 2020-09-22 14:14:00, "Hu, Jiayu" <[email protected]> wrote:

    Fragments of a flow are sorted by frag_oft, but they may have different

    timestamp. For example, there are three fragments, whose frag_oft is:

    frag[0].frag_oft=0, frag[1].frag_oft=4, frag[2].frag_oft=6; and they are

    fragments of one UDP packet but are not neighbors. In the first RX burst,

    host receives frag[1] and calls rte_gro_reassemble(), and we assume the

    timestamp of frag[1] is 10; in the second RX burst, host receives frag[0]

    and also call rte_gro_reassemble(), and timestamp of frag[0] is 11; the

    third time, host receives frag[2] and timestamp of frag[2] is 12. The three

    fragments are stored in three items of a UDP GRO table:

    items[0]: frag[0], timestamp is 11

    items[1]: frag[1], timestamp is 10

    items[2]: frag[2], timestamp is 12

    Now we want to flush packets whose timestamp is less than or equal to

    10. frag[1] should be returned, but in your code, no packets will be
    flushed.

    Because the timestamp of items[0] is greater than 10, the left two
    fragments

    will not be checked. This is what I want to say.



    From: yang_y_yi <[email protected]>
    Sent: Tuesday, September 22, 2020 9:44 AM
    To: Hu, Jiayu <[email protected]>
    Cc: [email protected]; [email protected]; [email protected]
    Subject: Re:Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO
    support
    Importance: High



    BTW, start_time is checked for the first packet in a flow,
    gro_udp4_merge_items(tbl, j) will merge all the packets in this flow once
    if they can be reassembled, gro_udp4_merge_items(tbl, j) doesn't check
    start_time, so this still can let some new items in this flow have chance
    to be merged.

    At 2020-09-22 09:29:38, "yang_y_yi" <[email protected]> wrote:

    >Thanks Jiayu, I have fixed other comments except this one:

    >

    >

    >

    >>The items of a flow are ordered by frag_oft, and start_time

    >>of these items is not always in ascending order. Therefore,

    >>you cannot skip checking the items after the item whose

    >>start_time is greater than flush_timestamp. This issue also

    >>exists in UDP/IPv4 GRO, and need to correct them both.

    >

    >

    >I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

    >

    >

    >

    >

    >

    >diff --git a/lib/librte_gro/gro_udp4.c b/lib/librte_gro/gro_udp4.c

    >index 061e7b0..ffa35a2 100644

    >--- a/lib/librte_gro/gro_udp4.c

    >+++ b/lib/librte_gro/gro_udp4.c

    >@@ -391,7 +391,6 @@

    >

    >                j = tbl->flows[i].start_index;

    >                while (j != INVALID_ARRAY_INDEX) {

    >-                       if (tbl->items[j].start_time <= flush_timestamp) {

    >                                gro_udp4_merge_items(tbl, j);

    >                                out[k++] = tbl->items[j].firstseg;

    >                                if (tbl->items[j].nb_merged > 1)

    >@@ -407,12 +406,6 @@

    >

    >                                if (unlikely(k == nb_out))

    >                                        return k;

    >-                       } else

    >-                               /*

    >-                                * The left packets in this flow won't be

    >-                                * timeout. Go to check other flows.

    >-                                */

    >-                               break;

    >                }

    >        }

    >        return k;

    >
#15 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

In reply to yang_y_yi
Quoted 9 lines · yang_y_yi

Thanks Jiayu, I have fixed other comments except this one:

Quoted 5 lines

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 6 lines

I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

You cannot simplily delete the code, as rte_gro_timeout_flush() is designed to flush packets according to cycles. If users want to flush all packets from the table, they can set 'timeout_cycles' in rte_gro_timeout_flush() to 0. rte_gro_reassemble_burst() uses this way to return all packets of a burst to users after GRO.

Thanks,
Jiayu

Quoted 434 lines
lib/librte_gro/gro_udp4.c +0 -7
index 061e7b0..ffa35a2 100644
@@ -391,7 +391,6 @@
 
                j = tbl->flows[i].start_index;
                while (j != INVALID_ARRAY_INDEX) {
-                       if (tbl->items[j].start_time <= flush_timestamp) {
                                gro_udp4_merge_items(tbl, j);
                                out[k++] = tbl->items[j].firstseg;
                                if (tbl->items[j].nb_merged > 1)
@@ -407,12 +406,6 @@
 
                                if (unlikely(k == nb_out))
                                        return k;
-                       } else
-                               /*
-                                * The left packets in this flow won't be
-                                * timeout. Go to check other flows.
-                                */
-                               break;
                }
        }
        return k;
Quoted 397 lines · Jiayu

Hi Yi,

Some comments are inline.

Thanks,
Jiayu

Quoted 89 lines

-----Original Message-----
From: [email protected] <[email protected]>
Sent: Thursday, September 17, 2020 11:50 AM
To: [email protected]
Cc: Hu, Jiayu <[email protected]>; [email protected]; [email protected]; [email protected]
Subject: [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

VXLAN UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble VXLAN UDP/IPv4 fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case.

Note: outer IP ID isn't used to check if two packets are same flow and can be merged because the difference between outer IP IDs of two packets isn't always +/-1 in case of OVS DPDK.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 542
++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 154 ++++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 790 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +23 -0
new file mode 100644
index 0000000..4eece56
@@ -0,0 +1,542 @@
+
+uint16_t
+gro_vxlan_udp4_tbl_timeout_flush(struct gro_vxlan_udp4_tbl *tbl,
+            uint64_t flush_timestamp,
+            struct rte_mbuf **out,
+            uint16_t nb_out)
+{
+    uint16_t k = 0;
+    uint32_t i, j;
+    uint32_t max_flow_num = tbl->max_flow_num;
+
+    for (i = 0; i < max_flow_num; i++) {
+            if (unlikely(tbl->flow_num == 0))
+                    return k;
+
+            j = tbl->flows[i].start_index;
+            while (j != INVALID_ARRAY_INDEX) {
+                    if (tbl->items[j].inner_item.start_time <=
+                                    flush_timestamp) {
+                            gro_vxlan_udp4_merge_items(tbl, j);
+                            out[k++] = tbl->items[j].inner_item.firstseg;
+                            if (tbl->items[j].inner_item.nb_merged > 1)
+                                    update_vxlan_header(&(tbl-
Quoted 1 line

items[j]));

lib/librte_gro/gro_vxlan_udp4.c new file +7 -0
+                            /*
+                             * Delete the item and get the next packet
+                             * index.
+                             */
+                            j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+                            tbl->flows[i].start_index = j;
+                            if (j == INVALID_ARRAY_INDEX)

lib/librte_gro/gro_vxlan_udp4.c

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+                                    tbl->flow_num--;
+
+                            if (unlikely(k == nb_out))
+                                    return k;
+                    } else
+                            /*
+                             * The left packets in the flow won't be
+                             * timeout. Go to check other flows.
+                             */
+                            break;

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 28 lines
lib/librte_gro/gro_vxlan_udp4.c new file +4 -0
+            }
+    }
+    return k;
+}
lib/librte_gro/gro_vxlan_udp4.h new file +17 -0
new file mode 100644
index 0000000..6a42fb3
@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#ifndef _GRO_VXLAN_UDP4_H_
+#define _GRO_VXLAN_UDP4_H_
+
+#include "gro_udp4.h"
+
+#define GRO_VXLAN_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
+
+/* Header fields representing a VxLAN flow */
+struct vxlan_udp4_flow_key {
+    struct udp4_flow_key inner_key;
+    struct rte_vxlan_hdr vxlan_hdr;
+
+    struct rte_ether_addr outer_eth_saddr;

lib/librte_gro/gro_vxlan_udp4.h line 27

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+    struct rte_ether_addr outer_eth_daddr;
+
+    uint32_t outer_ip_src_addr;
+    uint32_t outer_ip_dst_addr;
+
+    /* Note: It is unnecessary to save outer_src_port here because it can
+     * be different for VxLAN UDP fragments from the same flow.
+     */
+    uint16_t outer_dst_port;
+

The above empty line is unnecessary.

lib/librte_gro/gro_vxlan_udp4.h line 37

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+};
+
+
+struct gro_vxlan_udp4_item {
+    struct gro_udp4_item inner_item;
+    /* Note: VXLAN UDP/IPv4 GRO needn't check outer_ip_id because
+     * the difference between outer_ip_ids of two received packets
+     * isn't always +/-1 in case of OVS DPDK. So no outer_ip_id
+     * and outer_is_atomic fields here.
+     */

It seems the above comments for outer IP ID is enough, and no need to highlight in the commit log again. How do you think?

Quoted 193 lines
lib/librte_gro/gro_vxlan_udp4.h new file +2 -0
+};
+
lib/librte_gro/rte_gro.c +1 -3
index f623230..db990cf 100644
@@ -11,6 +11,7 @@
 #include "gro_tcp4.h"
 #include "gro_udp4.h"
 #include "gro_vxlan_tcp4.h"
+#include "gro_vxlan_udp4.h"
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 = {{0} };
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
-    struct gro_vxlan_tcp4_flow
 vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-    struct gro_vxlan_tcp4_item

vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +2 -0
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+    struct gro_vxlan_tcp4_flow

vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+ struct gro_vxlan_tcp4_item
vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

                     = {{{0}, 0, 0} };
lib/librte_gro/rte_gro.c +3 -0
+    /* Allocate a reassembly table for VXLAN UDP GRO */
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+    struct gro_vxlan_udp4_flow

vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+ struct gro_vxlan_udp4_item
vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +27 -10
+                    = {{{0}} };
+
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     uint32_t item_num;
     int32_t ret;
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+            do_vxlan_udp_gro = 0;
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
@@ -160,15 +179,28 @@ struct gro_ctx {
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
             for (i = 0; i < item_num; i++)
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-            vxlan_tbl.flows = vxlan_flows;
-            vxlan_tbl.items = vxlan_items;
-            vxlan_tbl.flow_num = 0;
-            vxlan_tbl.item_num = 0;
-            vxlan_tbl.max_flow_num = item_num;
-            vxlan_tbl.max_item_num = item_num;
-            do_vxlan_gro = 1;
+                    vxlan_tcp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
+            vxlan_tcp_tbl.flow_num = 0;
+            vxlan_tcp_tbl.item_num = 0;
+            vxlan_tcp_tbl.max_flow_num = item_num;
+            vxlan_tcp_tbl.max_item_num = item_num;
+            do_vxlan_tcp_gro = 1;
+    }
+
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+            for (i = 0; i < item_num; i++)
+                    vxlan_udp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
+            vxlan_udp_tbl.items = vxlan_udp_items;
+            vxlan_udp_tbl.flow_num = 0;
+            vxlan_udp_tbl.item_num = 0;
+            vxlan_udp_tbl.max_flow_num = item_num;
+            vxlan_udp_tbl.max_item_num = item_num;
+            do_vxlan_udp_gro = 1;
     }
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
lib/librte_gro/rte_gro.c +19 -4
@@ -204,9 +236,18 @@ struct gro_ctx {
              * will be flushed from the tables.
              */
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
+                            do_vxlan_tcp_gro) {
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
-                                                    &vxlan_tbl, 0);
+                                                    &vxlan_tcp_tbl, 0);
+                    if (ret > 0)
+                            /* Merge successfully */
+                            nb_after_gro--;
+                    else if (ret < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
+                                                    &vxlan_udp_tbl, 0);
                     if (ret > 0)
                             /* Merge successfully */
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
              || (unprocess_num < nb_pkts)) {
             i = 0;
             /* Flush all packets from the tables */
-            if (do_vxlan_gro) {
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+            if (do_vxlan_tcp_gro) {
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
                                     0, pkts, nb_pkts);
             }
 
+            if (do_vxlan_udp_gro) {
+                    i +=
 gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+                                    0, &pkts[i], nb_pkts - i);
+
+            }
+
             if (do_tcp4_gro) {
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
                                     &pkts[i], nb_pkts - i);
lib/librte_gro/rte_gro.c +2 -2
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     struct gro_ctx *gro_ctx = ctx;
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
     uint64_t current_time;
     uint16_t i, unprocess_num = 0;
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro,
 do_vxlan_udp_gro;
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4

|

                                     RTE_GRO_TCP_IPV4 |
lib/librte_gro/rte_gro.c +2 -1
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+    vxlan_tcp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];

+ vxlan_udp_tbl = gro_ctx-

Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
             RTE_GRO_TCP_IPV4;

- do_vxlan_gro = (gro_ctx->gro_types &
RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
+ do_vxlan_tcp_gro = (gro_ctx->gro_types &
RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
             RTE_GRO_UDP_IPV4;

+ do_vxlan_udp_gro = (gro_ctx->gro_types &
RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

lib/librte_gro/rte_gro.c +8 -2
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
     current_time = rte_rdtsc();
 
     for (i = 0; i < nb_pkts; i++) {
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+                            do_vxlan_tcp_gro) {
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+                                            current_time) < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    if (gro_vxlan_udp4_reassemble(pkts[i],

vxlan_udp_tbl,

                                             current_time) < 0)
                             unprocess_pkts[unprocess_num++] = pkts[i];
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

lib/librte_gro/rte_gro.c struct gro_ctx { · line 401

Quoted 5 lines
lib/librte_gro/rte_gro.c +1 -0
@@ -341,6 +397,13 @@ struct gro_ctx {
             left_nb_out = max_nb_out - num;
     }
 
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out >
 0) {

Max_nb_out is read-only and not updated. So it cannot check if 'out' array has enough space. Need to use left_nb_out instead. This issue also existed in UDP/IPv4 GRO, and please correct them both.

Quoted 26 lines
lib/librte_gro/rte_gro.c +6 -0
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+                            flush_timestamp, &out[num], left_nb_out);
+            left_nb_out = max_nb_out - num;
+    }
+
     /* If no available space in 'out', stop flushing. */
     if ((gro_types & RTE_GRO_TCP_IPV4) && max_nb_out > 0) {
             num += gro_tcp4_tbl_timeout_flush(
lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL <<
 RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**

* Structure used to create GRO context objects or used to pass
--
1.8.3.1

author
#16 lore raw

Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

Jiayu, you didn't get my point. I just show what you want by code, but that isn't a good way. I think current code is most reasonable. Please check my comments in last email, actually, only the first packet of a flow is checked by timestamp, if this flow includes some new items (you're saying), they can be merged, so it isn't the case you're saying.

Quoted 460 lines · Jiayu Hu
Quoted 9 lines · yang_y_yi

Thanks Jiayu, I have fixed other comments except this one:

Quoted 5 lines

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 6 lines

I think the issue here is if we should strictly follow flush_timestamp, it is possible there are new items in items chain. we have chance to merge more packets if we don't follow flush_timestamp. So an ideal change can be this. But is it acceptible if we don't use flush_timestamp? It can flush some packets in advance therefore miss next merge window. Maybe current way is most resonable and a tradeoff between two exterem cases.

You cannot simplily delete the code, as rte_gro_timeout_flush() is designed to flush packets according to cycles. If users want to flush all packets from the table, they can set 'timeout_cycles' in rte_gro_timeout_flush() to 0. rte_gro_reassemble_burst() uses this way to return all packets of a burst to users after GRO.

Thanks,
Jiayu

Quoted 434 lines
lib/librte_gro/gro_udp4.c +0 -7
index 061e7b0..ffa35a2 100644
@@ -391,7 +391,6 @@
 
                j = tbl->flows[i].start_index;
                while (j != INVALID_ARRAY_INDEX) {
-                       if (tbl->items[j].start_time <= flush_timestamp) {
                                gro_udp4_merge_items(tbl, j);
                                out[k++] = tbl->items[j].firstseg;
                                if (tbl->items[j].nb_merged > 1)
@@ -407,12 +406,6 @@
 
                                if (unlikely(k == nb_out))
                                        return k;
-                       } else
-                               /*
-                                * The left packets in this flow won't be
-                                * timeout. Go to check other flows.
-                                */
-                               break;
                }
        }
        return k;
Quoted 397 lines · Jiayu

Hi Yi,

Some comments are inline.

Thanks,
Jiayu

Quoted 89 lines

-----Original Message-----
From: [email protected] <[email protected]>
Sent: Thursday, September 17, 2020 11:50 AM
To: [email protected]
Cc: Hu, Jiayu <[email protected]>; [email protected]; [email protected]; [email protected]
Subject: [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support

From: Yi Yang <[email protected]>

VXLAN UDP/IPv4 GRO can help improve VM-to-VM UDP performance when UFO or GSO is enabled in VM, GRO must be supported if UFO or GSO is enabled, otherwise, performance can't get big improvement if only GSO is there.

With this enabled in DPDK, OVS DPDK can leverage it to improve VM-to-VM UDP performance, it will reassemble VXLAN UDP/IPv4 fragments immediate after they are received from a physical NIC. It is very helpful in OVS DPDK VXLAN use case.

Note: outer IP ID isn't used to check if two packets are same flow and can be merged because the difference between outer IP IDs of two packets isn't always +/-1 in case of OVS DPDK.

---
 lib/librte_gro/gro_udp4.h       |   1 +
 lib/librte_gro/gro_vxlan_udp4.c | 542
++++++++++++++++++++++++++++++++++++++++
 lib/librte_gro/gro_vxlan_udp4.h | 154 ++++++++++++
 lib/librte_gro/meson.build      |   2 +-
 lib/librte_gro/rte_gro.c        | 115 +++++++--
 lib/librte_gro/rte_gro.h        |   3 +
 6 files changed, 790 insertions(+), 27 deletions(-)
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.c
 create mode 100644 lib/librte_gro/gro_vxlan_udp4.h
lib/librte_gro/gro_udp4.h +1 -0
index 0a078e4..d38b393 100644
@@ -7,6 +7,7 @@
 
 #include <rte_ip.h>
 #include <rte_udp.h>
+#include <rte_vxlan.h>
 
 #define INVALID_ARRAY_INDEX 0xffffffffUL
 #define GRO_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
lib/librte_gro/gro_vxlan_udp4.c new file +23 -0
new file mode 100644
index 0000000..4eece56
@@ -0,0 +1,542 @@
+
+uint16_t
+gro_vxlan_udp4_tbl_timeout_flush(struct gro_vxlan_udp4_tbl *tbl,
+            uint64_t flush_timestamp,
+            struct rte_mbuf **out,
+            uint16_t nb_out)
+{
+    uint16_t k = 0;
+    uint32_t i, j;
+    uint32_t max_flow_num = tbl->max_flow_num;
+
+    for (i = 0; i < max_flow_num; i++) {
+            if (unlikely(tbl->flow_num == 0))
+                    return k;
+
+            j = tbl->flows[i].start_index;
+            while (j != INVALID_ARRAY_INDEX) {
+                    if (tbl->items[j].inner_item.start_time <=
+                                    flush_timestamp) {
+                            gro_vxlan_udp4_merge_items(tbl, j);
+                            out[k++] = tbl->items[j].inner_item.firstseg;
+                            if (tbl->items[j].inner_item.nb_merged > 1)
+                                    update_vxlan_header(&(tbl-
Quoted 1 line

items[j]));

lib/librte_gro/gro_vxlan_udp4.c new file +7 -0
+                            /*
+                             * Delete the item and get the next packet
+                             * index.
+                             */
+                            j = delete_item(tbl, j, INVALID_ARRAY_INDEX);
+                            tbl->flows[i].start_index = j;
+                            if (j == INVALID_ARRAY_INDEX)

lib/librte_gro/gro_vxlan_udp4.c

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.c new file +10 -0
+                                    tbl->flow_num--;
+
+                            if (unlikely(k == nb_out))
+                                    return k;
+                    } else
+                            /*
+                             * The left packets in the flow won't be
+                             * timeout. Go to check other flows.
+                             */
+                            break;

The items of a flow are ordered by frag_oft, and start_time of these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whose start_time is greater than flush_timestamp. This issue also exists in UDP/IPv4 GRO, and need to correct them both.

Quoted 28 lines
lib/librte_gro/gro_vxlan_udp4.c new file +4 -0
+            }
+    }
+    return k;
+}
lib/librte_gro/gro_vxlan_udp4.h new file +17 -0
new file mode 100644
index 0000000..6a42fb3
@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Inspur Corporation
+ */
+
+#ifndef _GRO_VXLAN_UDP4_H_
+#define _GRO_VXLAN_UDP4_H_
+
+#include "gro_udp4.h"
+
+#define GRO_VXLAN_UDP4_TBL_MAX_ITEM_NUM (1024UL * 1024UL)
+
+/* Header fields representing a VxLAN flow */
+struct vxlan_udp4_flow_key {
+    struct udp4_flow_key inner_key;
+    struct rte_vxlan_hdr vxlan_hdr;
+
+    struct rte_ether_addr outer_eth_saddr;

lib/librte_gro/gro_vxlan_udp4.h line 27

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+    struct rte_ether_addr outer_eth_daddr;
+
+    uint32_t outer_ip_src_addr;
+    uint32_t outer_ip_dst_addr;
+
+    /* Note: It is unnecessary to save outer_src_port here because it can
+     * be different for VxLAN UDP fragments from the same flow.
+     */
+    uint16_t outer_dst_port;
+

The above empty line is unnecessary.

lib/librte_gro/gro_vxlan_udp4.h line 37

Quoted 10 lines
lib/librte_gro/gro_vxlan_udp4.h new file +10 -0
+};
+
+
+struct gro_vxlan_udp4_item {
+    struct gro_udp4_item inner_item;
+    /* Note: VXLAN UDP/IPv4 GRO needn't check outer_ip_id because
+     * the difference between outer_ip_ids of two received packets
+     * isn't always +/-1 in case of OVS DPDK. So no outer_ip_id
+     * and outer_is_atomic fields here.
+     */

It seems the above comments for outer IP ID is enough, and no need to highlight in the commit log again. How do you think?

Quoted 193 lines
lib/librte_gro/gro_vxlan_udp4.h new file +2 -0
+};
+
lib/librte_gro/rte_gro.c +1 -3
index f623230..db990cf 100644
@@ -11,6 +11,7 @@
 #include "gro_tcp4.h"
 #include "gro_udp4.h"
 #include "gro_vxlan_tcp4.h"
+#include "gro_vxlan_udp4.h"
 
 /*
  * GRO context structure. It keeps the table structures, which are
@@ -137,19 +148,27 @@ struct gro_ctx {
     struct gro_udp4_item udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]
 = {{0} };
 
     /* Allocate a reassembly table for VXLAN TCP GRO */
-    struct gro_vxlan_tcp4_tbl vxlan_tbl;
-    struct gro_vxlan_tcp4_flow
 vxlan_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
-    struct gro_vxlan_tcp4_item

vxlan_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +2 -0
+    struct gro_vxlan_tcp4_tbl vxlan_tcp_tbl;
+    struct gro_vxlan_tcp4_flow

vxlan_tcp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+ struct gro_vxlan_tcp4_item
vxlan_tcp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

                     = {{{0}, 0, 0} };
lib/librte_gro/rte_gro.c +3 -0
+    /* Allocate a reassembly table for VXLAN UDP GRO */
+    struct gro_vxlan_udp4_tbl vxlan_udp_tbl;
+    struct gro_vxlan_udp4_flow

vxlan_udp_flows[RTE_GRO_MAX_BURST_ITEM_NUM];
+ struct gro_vxlan_udp4_item
vxlan_udp_items[RTE_GRO_MAX_BURST_ITEM_NUM]

lib/librte_gro/rte_gro.c +27 -10
+                    = {{{0}} };
+
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     uint32_t item_num;
     int32_t ret;
     uint16_t i, unprocess_num = 0, nb_after_gro = nb_pkts;
-    uint8_t do_tcp4_gro = 0, do_vxlan_gro = 0, do_udp4_gro = 0;
+    uint8_t do_tcp4_gro = 0, do_vxlan_tcp_gro = 0, do_udp4_gro = 0,
+            do_vxlan_udp_gro = 0;
 
     if (unlikely((param->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4 |
                                     RTE_GRO_TCP_IPV4 |
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
@@ -160,15 +179,28 @@ struct gro_ctx {
 
     if (param->gro_types & RTE_GRO_IPV4_VXLAN_TCP_IPV4) {
             for (i = 0; i < item_num; i++)
-                    vxlan_flows[i].start_index = INVALID_ARRAY_INDEX;
-
-            vxlan_tbl.flows = vxlan_flows;
-            vxlan_tbl.items = vxlan_items;
-            vxlan_tbl.flow_num = 0;
-            vxlan_tbl.item_num = 0;
-            vxlan_tbl.max_flow_num = item_num;
-            vxlan_tbl.max_item_num = item_num;
-            do_vxlan_gro = 1;
+                    vxlan_tcp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+            vxlan_tcp_tbl.flows = vxlan_tcp_flows;
+            vxlan_tcp_tbl.items = vxlan_tcp_items;
+            vxlan_tcp_tbl.flow_num = 0;
+            vxlan_tcp_tbl.item_num = 0;
+            vxlan_tcp_tbl.max_flow_num = item_num;
+            vxlan_tcp_tbl.max_item_num = item_num;
+            do_vxlan_tcp_gro = 1;
+    }
+
+    if (param->gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) {
+            for (i = 0; i < item_num; i++)
+                    vxlan_udp_flows[i].start_index =
 INVALID_ARRAY_INDEX;
+
+            vxlan_udp_tbl.flows = vxlan_udp_flows;
+            vxlan_udp_tbl.items = vxlan_udp_items;
+            vxlan_udp_tbl.flow_num = 0;
+            vxlan_udp_tbl.item_num = 0;
+            vxlan_udp_tbl.max_flow_num = item_num;
+            vxlan_udp_tbl.max_item_num = item_num;
+            do_vxlan_udp_gro = 1;
     }
     if (param->gro_types & RTE_GRO_TCP_IPV4) {
lib/librte_gro/rte_gro.c +19 -4
@@ -204,9 +236,18 @@ struct gro_ctx {
              * will be flushed from the tables.
              */
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
+                            do_vxlan_tcp_gro) {
                     ret = gro_vxlan_tcp4_reassemble(pkts[i],
-                                                    &vxlan_tbl, 0);
+                                                    &vxlan_tcp_tbl, 0);
+                    if (ret > 0)
+                            /* Merge successfully */
+                            nb_after_gro--;
+                    else if (ret < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    ret = gro_vxlan_udp4_reassemble(pkts[i],
+                                                    &vxlan_udp_tbl, 0);
                     if (ret > 0)
                             /* Merge successfully */
                             nb_after_gro--;
@@ -236,11 +277,17 @@ struct gro_ctx {
              || (unprocess_num < nb_pkts)) {
             i = 0;
             /* Flush all packets from the tables */
-            if (do_vxlan_gro) {
-                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tbl,
+            if (do_vxlan_tcp_gro) {
+                    i = gro_vxlan_tcp4_tbl_timeout_flush(&vxlan_tcp_tbl,
                                     0, pkts, nb_pkts);
             }
 
+            if (do_vxlan_udp_gro) {
+                    i +=
 gro_vxlan_udp4_tbl_timeout_flush(&vxlan_udp_tbl,
+                                    0, &pkts[i], nb_pkts - i);
+
+            }
+
             if (do_tcp4_gro) {
                     i += gro_tcp4_tbl_timeout_flush(&tcp_tbl, 0,
                                     &pkts[i], nb_pkts - i);
lib/librte_gro/rte_gro.c +2 -2
@@ -269,33 +316,42 @@ struct gro_ctx {
 {
     struct rte_mbuf *unprocess_pkts[nb_pkts];
     struct gro_ctx *gro_ctx = ctx;
-    void *tcp_tbl, *udp_tbl, *vxlan_tbl;
+    void *tcp_tbl, *udp_tbl, *vxlan_tcp_tbl, *vxlan_udp_tbl;
     uint64_t current_time;
     uint16_t i, unprocess_num = 0;
-    uint8_t do_tcp4_gro, do_vxlan_gro, do_udp4_gro;
+    uint8_t do_tcp4_gro, do_vxlan_tcp_gro, do_udp4_gro,
 do_vxlan_udp_gro;
 
     if (unlikely((gro_ctx->gro_types & (RTE_GRO_IPV4_VXLAN_TCP_IPV4

|

                                     RTE_GRO_TCP_IPV4 |
lib/librte_gro/rte_gro.c +2 -1
+                                    RTE_GRO_IPV4_VXLAN_UDP_IPV4 |
                                     RTE_GRO_UDP_IPV4)) == 0))
             return nb_pkts;
 
     tcp_tbl = gro_ctx->tbls[RTE_GRO_TCP_IPV4_INDEX];
-    vxlan_tbl = gro_ctx->tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];
+    vxlan_tcp_tbl = gro_ctx-
Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_TCP_IPV4_INDEX];

     udp_tbl = gro_ctx->tbls[RTE_GRO_UDP_IPV4_INDEX];

+ vxlan_udp_tbl = gro_ctx-

Quoted 1 line

tbls[RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX];

     do_tcp4_gro = (gro_ctx->gro_types & RTE_GRO_TCP_IPV4) ==
             RTE_GRO_TCP_IPV4;

- do_vxlan_gro = (gro_ctx->gro_types &
RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==
+ do_vxlan_tcp_gro = (gro_ctx->gro_types &
RTE_GRO_IPV4_VXLAN_TCP_IPV4) ==

             RTE_GRO_IPV4_VXLAN_TCP_IPV4;
     do_udp4_gro = (gro_ctx->gro_types & RTE_GRO_UDP_IPV4) ==
             RTE_GRO_UDP_IPV4;

+ do_vxlan_udp_gro = (gro_ctx->gro_types &
RTE_GRO_IPV4_VXLAN_UDP_IPV4) ==

lib/librte_gro/rte_gro.c +8 -2
+            RTE_GRO_IPV4_VXLAN_UDP_IPV4;
 
     current_time = rte_rdtsc();
 
     for (i = 0; i < nb_pkts; i++) {
             if (IS_IPV4_VXLAN_TCP4_PKT(pkts[i]->packet_type) &&
-                            do_vxlan_gro) {
-                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tbl,
+                            do_vxlan_tcp_gro) {
+                    if (gro_vxlan_tcp4_reassemble(pkts[i], vxlan_tcp_tbl,
+                                            current_time) < 0)
+                            unprocess_pkts[unprocess_num++] = pkts[i];
+            } else if (IS_IPV4_VXLAN_UDP4_PKT(pkts[i]->packet_type) &&
+                            do_vxlan_udp_gro) {
+                    if (gro_vxlan_udp4_reassemble(pkts[i],

vxlan_udp_tbl,

                                             current_time) < 0)
                             unprocess_pkts[unprocess_num++] = pkts[i];
             } else if (IS_IPV4_TCP_PKT(pkts[i]->packet_type) &&

lib/librte_gro/rte_gro.c struct gro_ctx { · line 401

Quoted 5 lines
lib/librte_gro/rte_gro.c +1 -0
@@ -341,6 +397,13 @@ struct gro_ctx {
             left_nb_out = max_nb_out - num;
     }
 
+    if ((gro_types & RTE_GRO_IPV4_VXLAN_UDP_IPV4) && max_nb_out >
 0) {

Max_nb_out is read-only and not updated. So it cannot check if 'out' array has enough space. Need to use left_nb_out instead. This issue also existed in UDP/IPv4 GRO, and please correct them both.

Quoted 26 lines
lib/librte_gro/rte_gro.c +6 -0
+            num += gro_vxlan_udp4_tbl_timeout_flush(gro_ctx->tbls[
+                            RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX],
+                            flush_timestamp, &out[num], left_nb_out);
+            left_nb_out = max_nb_out - num;
+    }
+
     /* If no available space in 'out', stop flushing. */
     if ((gro_types & RTE_GRO_TCP_IPV4) && max_nb_out > 0) {
             num += gro_tcp4_tbl_timeout_flush(
lib/librte_gro/rte_gro.h +3 -0
index 470f3ed..9f9ed49 100644
@@ -35,6 +35,9 @@
 #define RTE_GRO_UDP_IPV4_INDEX 2
 #define RTE_GRO_UDP_IPV4 (1ULL << RTE_GRO_UDP_IPV4_INDEX)
 /**< UDP/IPv4 GRO flag */
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX 3
+#define RTE_GRO_IPV4_VXLAN_UDP_IPV4 (1ULL <<
 RTE_GRO_IPV4_VXLAN_UDP_IPV4_INDEX)
+/**< VxLAN UDP/IPv4 GRO flag. */
 
 /**

* Structure used to create GRO context objects or used to pass
--
1.8.3.1

#17 lore raw

PATCH v6 3/3 doc: update prog_guide and rel_notes for GRO

In reply to [email protected]

From: Yi Yang <[email protected]>

Release 20.11 added UDP/IPv4 and VXLAN UDP/IPv4 support for GRO, so update prog_guide and rel_notes to reflect these changes.

---
 doc/guides/prog_guide/generic_receive_offload_lib.rst | 6 +++---
 doc/guides/rel_notes/release_20_11.rst                | 6 ++++++
 2 files changed, 9 insertions(+), 3 deletions(-)
doc/guides/prog_guide/generic_receive_offload_lib.rst +3 -3
index 5b3fb91..98a5d29 100644
@@ -30,9 +30,9 @@ assumes the packets are complete (i.e., MF==0 && frag_off==0), when IP
 fragmentation is possible (i.e., DF==0). Additionally, it complies RFC
 6864 to process the IPv4 ID field.
 
-Currently, the GRO library provides GRO supports for TCP/IPv4 packets and
-VxLAN packets which contain an outer IPv4 header and an inner TCP/IPv4
-packet.
+Currently, the GRO library provides GRO supports for TCP/IPv4 and UDP/IPv4
+packets as well as VxLAN packets which contain an outer IPv4 header and an
+inner TCP/IPv4 or UDP/IPv4 packet.
 
 Two Sets of API
 ---------------
doc/guides/rel_notes/release_20_11.rst +6 -0
index cc72609..2842063 100644
@@ -55,6 +55,12 @@ New Features
      Also, make sure to start the actual text at the margin.
      =======================================================
 
+* **Add UDP/IPv4 GRO support for VxLAN and non-VxLAN packets.**
+
+  Add UDP/IPv4 GRO support for VxLAN and non-VxLAN packets. For
+  VxLAN packets, this adds inner UDP/IPv4 support, for non-VxLAN
+  packets, this adds UDP/IPv4 support.
+
 
 Removed Items
 -------------
Signature · 1 line
1.8.3.1