gro : packets not getting flushed in heavy-weight mode API
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
@@ -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
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 therte_gro_timeout_flushAPI should be invoked.Signed-off-by Kumara Parameshwaran <[email protected]>---
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@@ -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.1Quoted 1 line
Quoted 1 line
Please ignore this patch, this has an issue will raise a new one.
PATCH v2 1/1 gro : packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
@@ -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
PATCH v3 1/1 gro : packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
@@ -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
PATCH v4 1/1 gro : packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
@@ -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
PATCH v5 1/1 gro : packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
@@ -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
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_flushAPI 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
Signed-off-by Kumara Parameshwaran <[email protected]>---
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 issuev3:
Fix warningsv4:
Fix error and warningsv5:
Fix compilation issue when GRO is not definedapp/test-pmd/csumonly.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)app/test-pmd/csumonly.c +0
-0@@ -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
-0txp = &ports[fs->tx_port]; tx_offloads = txp->dev_conf.txmode.offloads;
PATCH v6 1/1 gro : packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
@@ -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
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_flushAPI 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
Signed-off-by Kumara Parameshwaran <[email protected]>---
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 issuev3:
Fix warningsv4:
Fix error and warningsv5:
Fix compilation issue when GRO is not definedv6:
Address review commentsapp/test-pmd/csumonly.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-)app/test-pmd/csumonly.c +1
-0@@ -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
-1return 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
-3rx_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
-0txp = &ports[fs->tx_port]; tx_offloads = txp->dev_conf.txmode.offloads;
PATCH v7 1/1 app/testpmd : fix packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
v7:
Address review comments
app/test-pmd/csumonly.c | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-)
app/test-pmd/csumonly.c +18 -4
@@ -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
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.
PATCH v8 1/1 app/testpmd : fix packets not getting flushed in heavy-weight mode API
In reply to Kumara ParameshwaranIn 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
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
@@ -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
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_flushAPI should be invoked.Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4 GRO")Signed-off-by Kumara Parameshwaran <[email protected]>---
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 issuev3:
Fix warningsv4:
Fix error and warningsv5:
Fix compilation issue when GRO is not definedv6:
Address review commentsv7:
Address review commentsv8:
Fix spell check warningsapp/test-pmd/csumonly.c | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-)app/test-pmd/csumonly.c +3
-1@@ -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?
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_flushAPI should be invoked.Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4 GRO")Signed-off-by Kumara Parameshwaran <[email protected]>---
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 issuev3:
Fix warningsv4:
Fix error and warningsv5:
Fix compilation issue when GRO is not definedv6:
Address review commentsv7:
Address review commentsv8:
Fix spell check warningsapp/test-pmd/csumonly.c | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-)app/test-pmd/csumonly.c +3
-1@@ -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.
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_flushAPI should be invoked.Fixes b7091f1dcfbc ("app/testpmd: enable the heavyweight mode TCP/IPv4GRO")
Quoted 6 lines
Quoted 6 lines
Signed-off-by Kumara Parameshwaran <[email protected]>---
v1:
Changes to make sure that the GRO flush API is invoked if there areno packets in
Quoted 26 lines
Quoted 26 lines
current poll and timer expiry.
v2:
Fix code organisation issuev3:
Fix warningsv4:
Fix error and warningsv5:
Fix compilation issue when GRO is not definedv6:
Address review commentsv7:
Address review commentsv8:
Fix spell check warningsapp/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@@ -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_CYCLESwhichQuoted 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,
Reviewed-by Ferruh Yigit <[email protected]>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.