gro: add UDP/IPv4 GRO and VXLAN UDP/IPv4 GRO support
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 SERVER2If 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
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
@@ -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
@@ -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
@@ -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
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 supportFrom: 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.
Signed-off-by Yi Yang <[email protected]>
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
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
@@ -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
@@ -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
@@ -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
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 supportFrom: 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.
Signed-off-by Yi Yang <[email protected]>--- 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.hlib/librte_gro/gro_udp4.h +1
-0@@ -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@@ -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@@ -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@@ -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
-4if (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
-1RTE_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
-0udp_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
-1do_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
-0RTE_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
-0current_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
-0num += gro_tcp4_tbl_timeout_flush(lib/librte_gro/rte_gro.h +3
-0@@ -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
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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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
@@ -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,
JiayuQuoted 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 supportFrom: 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.
Signed-off-by Yi Yang <[email protected]>--- 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.hlib/librte_gro/gro_udp4.h +1
-0@@ -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@@ -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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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@@ -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@@ -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
-4if (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
-1RTE_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
-0udp_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
-1do_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
-0RTE_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
-0current_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_outis read-only and not updated. So it cannot check if 'out' array has enough space. Need to useleft_nb_outinstead. 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
-0num += gro_tcp4_tbl_timeout_flush(lib/librte_gro/rte_gro.h +3
-0@@ -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
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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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 followflush_timestamp. So an ideal change can be this. But is it acceptible if we don't useflush_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@@ -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,
JiayuQuoted 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 supportFrom: 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.
Signed-off-by Yi Yang <[email protected]>--- 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.hlib/librte_gro/gro_udp4.h +1
-0@@ -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@@ -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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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@@ -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@@ -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
-4if (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
-1RTE_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
-0udp_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
-1do_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
-0RTE_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
-0current_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_outis read-only and not updated. So it cannot check if 'out' array has enough space. Need to useleft_nb_outinstead. 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
-0num += gro_tcp4_tbl_timeout_flush(lib/librte_gro/rte_gro.h +3
-0@@ -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
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, andstart_timeof these items is not always in ascending order. Therefore,
you cannot skip checking the items after the item whose
start_timeis greater thanflush_timestamp. This issue alsoexists 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 followflush_timestamp. So an ideal change can be this. But is it acceptible if we don't useflush_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
-0index 061e7b0..ffa35a2 100644
---
a/lib/librte_gro/gro_udp4.c+++
b/lib/librte_gro/gro_udp4.clib/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;
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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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 followflush_timestamp. So an ideal change can be this. But is it acceptible if we don't useflush_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@@ -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;
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; >
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; >
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; >
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; >
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_flushwill be called afterrte_gro_reassembleevery 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; >
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
@@ -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_flushwill be called afterrte_gro_reassembleevery 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; >
Re: [dpdk-dev] [PATCH v6 2/3] gro: add VXLAN UDP/IPv4 GRO support
In reply to yang_y_yiQuoted 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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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 followflush_timestamp. So an ideal change can be this. But is it acceptible if we don't useflush_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@@ -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,
JiayuQuoted 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 supportFrom: 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.
Signed-off-by Yi Yang <[email protected]>--- 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.hlib/librte_gro/gro_udp4.h +1
-0@@ -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@@ -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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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@@ -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@@ -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];
+ structgro_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];
+ structgro_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_outis read-only and not updated. So it cannot check if 'out' array has enough space. Need to useleft_nb_outinstead. 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@@ -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
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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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 followflush_timestamp. So an ideal change can be this. But is it acceptible if we don't useflush_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' inrte_gro_timeout_flush()to 0.rte_gro_reassemble_burst()uses this way to return all packets of a burst to users after GRO.Thanks,
JiayuQuoted 434 lines
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;Quoted 397 lines · Jiayu
Hi Yi,
Some comments are inline.
Thanks,
JiayuQuoted 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 supportFrom: 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.
Signed-off-by Yi Yang <[email protected]>--- 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.hlib/librte_gro/gro_udp4.h +1
-0@@ -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@@ -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, andstart_timeof these items is not always in ascending order. Therefore, you cannot skip checking the items after the item whosestart_timeis greater thanflush_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@@ -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@@ -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];
+ structgro_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];
+ structgro_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_outis read-only and not updated. So it cannot check if 'out' array has enough space. Need to useleft_nb_outinstead. 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@@ -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
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
@@ -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
@@ -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