Skip to contentSkip to conversation

gro : packets not getting flushed in heavy-weight mode API

PATCH Superseded Kumara Parameshwaran 3 participants 15 messages Jan 17, 2024 – Feb 22, 2024

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 gro : packets not getting flushed in heavy-weight mode API

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed inspite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

 app/test-pmd/csumonly.c | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +12 -4
index c103e54111..42f105ac16 100644
@@ -863,16 +863,24 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
-	if (unlikely(nb_rx == 0))
+	if (unlikely(nb_rx == 0)) {
+#ifdef RTE_LIB_GRO
+		gro_enable = gro_ports[fs->rx_port].enable;
+		if (unlikely(gro_enable && (gro_flush_cycles != GRO_DEFAULT_FLUSH_CYCLES))) {
+			goto init;
+		} else {
+			return false;
+		}
+#else
 		return false;
+#endif
+	}
 
+init:
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
Signature · 1 line
2.25.1
#1 lore raw
Quoted 56 lines · Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be
flushed inspite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no
packets in
current poll and timer expiry.

 app/test-pmd/csumonly.c | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +12 -4
index c103e54111..42f105ac16 100644
@@ -863,16 +863,24 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
        /* receive a burst of packet */
        nb_rx = common_fwd_stream_receive(fs, pkts_burst,
 nb_pkt_per_burst);
-       if (unlikely(nb_rx == 0))
+       if (unlikely(nb_rx == 0)) {
+#ifdef RTE_LIB_GRO
+               gro_enable = gro_ports[fs->rx_port].enable;
+               if (unlikely(gro_enable && (gro_flush_cycles !=
 GRO_DEFAULT_FLUSH_CYCLES))) {
+                       goto init;
+               } else {
+                       return false;
+               }
+#else
                return false;
+#endif
+       }
 
+init:
        rx_bad_ip_csum = 0;
        rx_bad_l4_csum = 0;
        rx_bad_outer_l4_csum = 0;
        rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-       gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
        txp = &ports[fs->tx_port];
        tx_offloads = txp->dev_conf.txmode.offloads;

--
2.25.1

Quoted 1 line
Quoted 1 line

Please ignore this patch, this has an issue will raise a new one.

#2 lore raw

PATCH v2 1/1 gro : packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed inspite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

 app/test-pmd/csumonly.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)
app/test-pmd/csumonly.c +12 -3
index c103e54111..c1fde50126 100644
@@ -863,16 +863,25 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
+#ifdef RTE_LIB_GRO
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (gro_enable && (gro_flush_cycles != GRO_DEFAULT_FLUSH_CYCLES)) {
+			goto init;
+		} else {
+			return false;
+		}
+	}
+#else
 	if (unlikely(nb_rx == 0))
 		return false;
+#endif
 
+init:
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
Signature · 1 line
2.25.1
#3 lore raw

PATCH v3 1/1 gro : packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed inspite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

 app/test-pmd/csumonly.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)
app/test-pmd/csumonly.c +11 -3
index c103e54111..b50f1b01d0 100644
@@ -863,16 +863,24 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
+#ifdef RTE_LIB_GRO
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (gro_enable && (gro_flush_cycles != GRO_DEFAULT_FLUSH_CYCLES))
+			goto init;
+		else 
+			return false;
+	}
+#else
 	if (unlikely(nb_rx == 0))
 		return false;
+#endif
 
+init:
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
Signature · 1 line
2.25.1
#4 lore raw

PATCH v4 1/1 gro : packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

 app/test-pmd/csumonly.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)
app/test-pmd/csumonly.c +11 -3
index c103e54111..4265f98c15 100644
@@ -863,16 +863,24 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
+#ifdef RTE_LIB_GRO
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (gro_enable && (gro_flush_cycles != GRO_DEFAULT_FLUSH_CYCLES))
+			goto init;
+		else
+			return false;
+	}
+#else
 	if (unlikely(nb_rx == 0))
 		return false;
+#endif
 
+init:
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
Signature · 1 line
2.25.1
#5 lore raw

PATCH v5 1/1 gro : packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

 app/test-pmd/csumonly.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +11 -4
index c103e54111..6d9ce99500 100644
@@ -863,16 +863,23 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
+#ifndef RTE_LIB_GRO
 	if (unlikely(nb_rx == 0))
 		return false;
-
+#else
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (gro_enable && (gro_flush_cycles != GRO_DEFAULT_FLUSH_CYCLES))
+			goto init;
+		else
+			return false;
+	}
+init:
+#endif
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
Signature · 1 line
2.25.1
#6 lore raw
Quoted 5 lines · Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Agree on the problem, need a way to flush existing packets in GRO context when no more packet receiving.

Quoted 29 lines

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

 app/test-pmd/csumonly.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +0 -0
index c103e54111..6d9ce99500 100644
@@ -863,16 +863,23 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 874

Quoted 10 lines
app/test-pmd/csumonly.c +6 -1
+#ifndef RTE_LIB_GRO
 	if (unlikely(nb_rx == 0))
 		return false;
-
+#else
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (gro_enable && (gro_flush_cycles != GRO_DEFAULT_FLUSH_CYCLES))
+			goto init;
 

Rest of the function expects 'nb_rx' non zero, so I am concerned about unexpected side effects, like:

- GRO reassembles packets and flush, how reassembles behaves with zero nb_rx?

- If there is no packet in GRO context, what happens to call with zero nb_rx?

To address above issue, what about add 'rte_gro_get_pkt_count()' check and only continue if it return not zero.
Also in below GRO block, call 'rte_gro_reassemble()' only when 'nb_rx' is not zero.

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 883

Quoted 3 lines
app/test-pmd/csumonly.c +2 -0
+		else
+			return false;
 

'goto' can be prevented by changing the condition in if block.

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 883

Quoted 3 lines
app/test-pmd/csumonly.c +2 -0
+	}
+init:
 

Label name 'init' is not a good name.

Quoted 11 lines
app/test-pmd/csumonly.c +1 -3
+#endif
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
app/test-pmd/csumonly.c +0 -0
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
#7 lore raw

PATCH v6 1/1 gro : packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

 app/test-pmd/csumonly.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +10 -4
index c103e54111..21b45b4ba4 100644
@@ -863,16 +863,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
+#ifndef RTE_LIB_GRO
 	if (unlikely(nb_rx == 0))
 		return false;
-
+#else
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES))
+			return false;
+		if ((rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
+	}
+#endif
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
Signature · 1 line
2.25.1
#8 lore raw
Quoted 5 lines · Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Related to the patch title, 'gro: ' indicates a component for gro library (lib/gro), but this is a testpmd patch, can you please update it as:
"app/testpmd: <verb> ..."

And can you please add a fixes tag [1], so this patch can be backported.

[1]
https://doc.dpdk.org/guides/contributing/patches.html#commit-messages-body

Quoted 34 lines

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

 app/test-pmd/csumonly.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +1 -0
index c103e54111..21b45b4ba4 100644
@@ -863,16 +863,22 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
+#ifndef RTE_LIB_GRO
 	if (unlikely(nb_rx == 0))

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 876

Quoted 10 lines
app/test-pmd/csumonly.c +7 -1
 		return false;
-
+#else
+	gro_enable = gro_ports[fs->rx_port].enable;
+	if (unlikely(nb_rx == 0)) {
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES))
+			return false;
+		if ((rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
 

Why not "||" this condition to previous if block, instead of adding a new if?

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 882

Quoted 3 lines
app/test-pmd/csumonly.c +2 -0
+	}
+#endif
 

Can you please put a comment in the GRO block that explains why these checks are done and why we may not want to return although 'nb_rx == 0'?

Another option is make the block as below and keep the code below to get 'gro_enable':

```
if (unlikely(nb_rx == 0)) {
#ifndef RTE_LIB_GRO
	return false;
#else
	// Comment explaining what is done here
	gro_enable = gro_ports[fs->rx_port].enable;
	if (...)
		return false;
#endif
}
```

Above sample that keeps the #ifdef in a narrow scope ("nb_rx == 0" block) looks tidier to me, but both works fine, no strong opinion from me, what do you think?

Quoted 10 lines
app/test-pmd/csumonly.c +0 -3
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
app/test-pmd/csumonly.c +0 -0
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
#9 lore raw

PATCH v7 1/1 app/testpmd : fix packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4 GRO")

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

v7:
Address review comments

 app/test-pmd/csumonly.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +18 -4
index c103e54111..637a46d92a 100644
@@ -863,16 +863,29 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
-	if (unlikely(nb_rx == 0))
+	if (unlikely(nb_rx == 0)) {
+#ifndef RTE_LIB_GRO
 		return false;
+#else
+		gro_enable = gro_ports[fs->rx_port].enable;
+		/*
+		 * Make sure that in case of Heavyweight mode GRO the packets in
+		 * GRO cache should be flushed as the timer could have expired.
+		 *
+		 * The order of condidtions should be the same as gro_ctx is valid
+		 * only when gro_flush_cycles is not the GRO_DEFAULT_FLUSH_CYCLES which
+		 * indicates ligth weight mode GRO
+		 */
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) ||
+			(rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
+#endif
+	}
 
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
@@ -1103,6 +1116,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 	}
 
 #ifdef RTE_LIB_GRO
+	gro_enable = gro_ports[fs->rx_port].enable;
 	if (unlikely(gro_enable)) {
 		if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) {
 			nb_rx = rte_gro_reassemble_burst(pkts_burst, nb_rx,
Signature · 1 line
2.25.1
#10 lore raw

Re: [PATCH v7] app/testpmd : fix packets not getting flushed in heavy-weight mode API

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 875

Quoted 9 lines · On Fri, 16 Feb 2024 09:10:25 +0530 Kumara Parameshwaran…
app/test-pmd/csumonly.c +8 -0
+#ifndef RTE_LIB_GRO
 		return false;
+#else
+		gro_enable = gro_ports[fs->rx_port].enable;
+		/*
+		 * Make sure that in case of Heavyweight mode GRO the packets in
+		 * GRO cache should be flushed as the timer could have expired.
+		 *
+		 * The order of condidtions should be the same as gro_ctx is valid

Run spell check on the comments please

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 882

Quoted 7 lines
app/test-pmd/csumonly.c +7 -0
+		 * only when gro_flush_cycles is not the GRO_DEFAULT_FLUSH_CYCLES which
+		 * indicates ligth weight mode GRO
+		 */
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) ||
+			(rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
+#endif

FYI - Linux kernel GRO does a flush when ever NAPI finishes. Pretty much equivalent to this but flushes more frequently.

#11 lore raw

PATCH v8 1/1 app/testpmd : fix packets not getting flushed in heavy-weight mode API

In reply to Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4 GRO")

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

v7:
Address review comments

v8:
Fix spell check warnings

 app/test-pmd/csumonly.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +18 -4
index c103e54111..a922160f6d 100644
@@ -863,16 +863,29 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
-	if (unlikely(nb_rx == 0))
+	if (unlikely(nb_rx == 0)) {
+#ifndef RTE_LIB_GRO
 		return false;
+#else
+		gro_enable = gro_ports[fs->rx_port].enable;
+		/*
+		 * Make sure that in case of Heavyweight mode GRO the packets in
+		 * GRO cache should be flushed as the timer could have expired.
+		 *
+		 * The order of conditions should be the same as gro_ctx is valid
+		 * only when gro_flush_cycles is not the GRO_DEFAULT_FLUSH_CYCLES which
+		 * indicates light weight mode GRO
+		 */
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) ||
+			(rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
+#endif
+	}
 
 	rx_bad_ip_csum = 0;
 	rx_bad_l4_csum = 0;
 	rx_bad_outer_l4_csum = 0;
 	rx_bad_outer_ip_csum = 0;
-#ifdef RTE_LIB_GRO
-	gro_enable = gro_ports[fs->rx_port].enable;
-#endif
 
 	txp = &ports[fs->tx_port];
 	tx_offloads = txp->dev_conf.txmode.offloads;
@@ -1103,6 +1116,7 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 	}
 
 #ifdef RTE_LIB_GRO
+	gro_enable = gro_ports[fs->rx_port].enable;
 	if (unlikely(gro_enable)) {
 		if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) {
 			nb_rx = rte_gro_reassemble_burst(pkts_burst, nb_rx,
Signature · 1 line
2.25.1
#12 lore raw

Re: [PATCH v8] app/testpmd : fix packets not getting flushed in heavy-weight mode API

Quoted 51 lines · Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4 GRO")

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

v7:
Address review comments

v8:
Fix spell check warnings

 app/test-pmd/csumonly.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +3 -1
index c103e54111..a922160f6d 100644
@@ -863,16 +863,29 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
-	if (unlikely(nb_rx == 0))
+	if (unlikely(nb_rx == 0)) {
+#ifndef RTE_LIB_GRO
 		return false;
+#else

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 879

Quoted 10 lines
app/test-pmd/csumonly.c +9 -0
+		gro_enable = gro_ports[fs->rx_port].enable;
+		/*
+		 * Make sure that in case of Heavyweight mode GRO the packets in
+		 * GRO cache should be flushed as the timer could have expired.
+		 *
+		 * The order of conditions should be the same as gro_ctx is valid
+		 * only when gro_flush_cycles is not the GRO_DEFAULT_FLUSH_CYCLES which
+		 * indicates light weight mode GRO
+		 */
 

Updated comment as below to make it terse, what do you think:
/*
* Check if packets need to be flushed in the GRO context
* due to a timeout.
*
* Continue only in GRO heavyweight mode and if there are
* packets in the GRO context.
*/

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 884

Quoted 6 lines
app/test-pmd/csumonly.c +5 -0
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) ||
+			(rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
+#endif
+	}
 

Another issue but also related to your patch, if there is no packet to Tx after GRO block, should we add another zero packet check:
if (unlikely(nb_rx == 0))

	return false;

To prevent executing GSO and Tx path code with zero packet, do you think does this make sense?

Reviewed-by Applied
#13 lore raw

Re: [PATCH v8] app/testpmd : fix packets not getting flushed in heavy-weight mode API

Quoted 83 lines · Ferruh Yigit
Quoted 51 lines · Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4 GRO")

---
v1:
Changes to make sure that the GRO flush API is invoked if there are no packets in current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

v7:
Address review comments

v8:
Fix spell check warnings

 app/test-pmd/csumonly.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +3 -1
index c103e54111..a922160f6d 100644
@@ -863,16 +863,29 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
 	/* receive a burst of packet */
 	nb_rx = common_fwd_stream_receive(fs, pkts_burst, nb_pkt_per_burst);
-	if (unlikely(nb_rx == 0))
+	if (unlikely(nb_rx == 0)) {
+#ifndef RTE_LIB_GRO
 		return false;
+#else

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 879

Quoted 10 lines
app/test-pmd/csumonly.c +9 -0
+		gro_enable = gro_ports[fs->rx_port].enable;
+		/*
+		 * Make sure that in case of Heavyweight mode GRO the packets in
+		 * GRO cache should be flushed as the timer could have expired.
+		 *
+		 * The order of conditions should be the same as gro_ctx is valid
+		 * only when gro_flush_cycles is not the GRO_DEFAULT_FLUSH_CYCLES which
+		 * indicates light weight mode GRO
+		 */
 

Updated comment as below to make it terse, what do you think:
/*
* Check if packets need to be flushed in the GRO context
* due to a timeout.
*
* Continue only in GRO heavyweight mode and if there are
* packets in the GRO context.
*/

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 884

Quoted 6 lines
app/test-pmd/csumonly.c +5 -0
+		if (!gro_enable || (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) ||
+			(rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))
+			return false;
+#endif
+	}
 

Another issue but also related to your patch, if there is no packet to Tx after GRO block, should we add another zero packet check:
if (unlikely(nb_rx == 0))

Quoted 6 lines
	return false;

To prevent executing GSO and Tx path code with zero packet, do you think does this make sense?

Patch looks good to me, with above comment update, but I am worried about side impacts of this patch that we might be missing, that is why I would like it to be in -rc1, so that it can be tested better. Hence,

Applied to dpdk-next-net/main, thanks. (Updated comment as suggested above while merging.)

Lets continue to discuss return on "nb_rx == 0" case after GRO block, incremental to this patch.

#14 lore raw

Re: [PATCH v8] app/testpmd : fix packets not getting flushed in heavy-weight mode API

Quoted 119 lines · Ferruh Yigit
Quoted 7 lines · Ferruh Yigit
Quoted 6 lines · Kumara Parameshwaran

In heavy-weight mode GRO which is based on timer, the GRO packets will not be flushed in spite of timer expiry if there is no packet in the current poll. If timer mode GRO is enabled the rte_gro_timeout_flush API should be invoked.

Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4

GRO")

Quoted 6 lines
Quoted 6 lines

---
v1:
Changes to make sure that the GRO flush API is invoked if there are

no packets in

Quoted 26 lines
Quoted 26 lines

current poll and timer expiry.

v2:
Fix code organisation issue

v3:
Fix warnings

v4:
Fix error and warnings

v5:
Fix compilation issue when GRO is not defined

v6:
Address review comments

v7:
Address review comments

v8:
Fix spell check warnings

 app/test-pmd/csumonly.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
Quoted 8 lines

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 865

Quoted 8 lines
app/test-pmd/csumonly.c +0 -0
index c103e54111..a922160f6d 100644
@@ -863,16 +863,29 @@ pkt_burst_checksum_forward(struct fwd_stream *fs)
 
     /* receive a burst of packet */
     nb_rx = common_fwd_stream_receive(fs, pkts_burst,

nb_pkt_per_burst);

Quoted 8 lines

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs)

Quoted 8 lines
app/test-pmd/csumonly.c +6 -1
-    if (unlikely(nb_rx == 0))
+    if (unlikely(nb_rx == 0)) {
+#ifndef RTE_LIB_GRO
             return false;
+#else
+            gro_enable = gro_ports[fs->rx_port].enable;
+            /*
+             * Make sure that in case of Heavyweight mode GRO the

packets in

Quoted 1 line

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 873

Quoted 1 line
app/test-pmd/csumonly.c +1 -0
+             * GRO cache should be flushed as the timer could have

expired.

Quoted 2 lines

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 875

Quoted 2 lines
app/test-pmd/csumonly.c +2 -0
+             *
+             * The order of conditions should be the same as gro_ctx

is valid

Quoted 1 line

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 876

Quoted 1 line
app/test-pmd/csumonly.c +1 -0
+             * only when gro_flush_cycles is not the

GRO_DEFAULT_FLUSH_CYCLES which

Quoted 4 lines

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 884

Quoted 3 lines
app/test-pmd/csumonly.c +2 -0
+             * indicates light weight mode GRO
+             */
 
Quoted 11 lines

Updated comment as below to make it terse, what do you think:
/*
* Check if packets need to be flushed in the GRO context
* due to a timeout.
*
* Continue only in GRO heavyweight mode and if there are
* packets in the GRO context.
*/

Quoted 1 line
app/test-pmd/csumonly.c +1 -0
+            if (!gro_enable || (gro_flush_cycles ==

GRO_DEFAULT_FLUSH_CYCLES) ||

Quoted 1 line

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 881

Quoted 1 line
app/test-pmd/csumonly.c +1 -0
+

(rte_gro_get_pkt_count(current_fwd_lcore()->gro_ctx) == 0))

Quoted 5 lines

app/test-pmd/csumonly.c pkt_burst_checksum_forward(struct fwd_stream *fs) · line 884

Quoted 4 lines
app/test-pmd/csumonly.c +3 -0
+                    return false;
+#endif
+    }
 
Quoted 9 lines

Another issue but also related to your patch, if there is no packet to Tx after GRO block, should we add another zero packet check:
if (unlikely(nb_rx == 0))

      return false;

To prevent executing GSO and Tx path code with zero packet, do you think does this make sense?

Patch looks good to me, with above comment update, but I am worried about side impacts of this patch that we might be missing, that is why I would like it to be in -rc1, so that it can be tested better. Hence,

Applied to dpdk-next-net/main, thanks. (Updated comment as suggested above while merging.)

Lets continue to discuss return on "nb_rx == 0" case after GRO block, incremental to this patch.

I was not able to get to this. I will also take a look at the code to see if this can cause any issues.
Thanks.