From patchwork Sun Sep 3 06:30:16 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Hu, Jiayu" X-Patchwork-Id: 28304 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id BDD797CAB; Sun, 3 Sep 2017 08:27:47 +0200 (CEST) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by dpdk.org (Postfix) with ESMTP id 0FA8F7CA9 for ; Sun, 3 Sep 2017 08:27:44 +0200 (CEST) Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga105.jf.intel.com with ESMTP; 02 Sep 2017 23:27:42 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.41,467,1498546800"; d="scan'208";a="144932659" Received: from dpdk15.sh.intel.com ([10.67.111.77]) by orsmga005.jf.intel.com with ESMTP; 02 Sep 2017 23:27:40 -0700 From: Jiayu Hu To: dev@dpdk.org Cc: ferruh.yigit@intel.com, konstantin.ananyev@intel.com, jianfeng.tan@intel.com, jingjing.wu@intel.com, Jiayu Hu Date: Sun, 3 Sep 2017 14:30:16 +0800 Message-Id: <1504420216-3258-1-git-send-email-jiayu.hu@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1502960892-112960-1-git-send-email-jiayu.hu@intel.com> References: <1502960892-112960-1-git-send-email-jiayu.hu@intel.com> Subject: [dpdk-dev] [PATCH v3] app/testpmd: enable the heavyweight mode TCP/IPv4 GRO X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" The GRO library provides two modes to reassemble packets. Currently, the csum forwarding engine has supported to use the lightweight mode to reassemble TCP/IPv4 packets. This patch introduces the heavyweight mode for TCP/IPv4 GRO in the csum forwarding engine. With the command "set port gro on|off", users can enable TCP/IPv4 GRO for a given port. With the command "set gro flush ", users can determine when the GROed TCP/IPv4 packets are flushed from reassembly tables. With the command "show port gro", users can display GRO configuration. Signed-off-by: Jiayu Hu Reviewed-by: Ferruh Yigit --- changes in v3: - remove "heavyweight mode" and "lightweight mode" from GRO commands - combine two patches into one - use consistent help string for GRO commands - remove the unnecessary command "gro set (max_flow_num) (max_item_num_per_flow) (port_id)" changes in v2: - use "set" and "show" as the root level command - add a new command to show GRO configuration - fix l2_len/l3_len/l4_len unset etc. bugs app/test-pmd/cmdline.c | 206 ++++++++++++++++------------ app/test-pmd/config.c | 67 +++++++-- app/test-pmd/csumonly.c | 31 ++++- app/test-pmd/testpmd.c | 18 ++- app/test-pmd/testpmd.h | 16 ++- doc/guides/testpmd_app_ug/testpmd_funcs.rst | 45 ++++-- 6 files changed, 263 insertions(+), 120 deletions(-) diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c index cd8c358..d628250 100644 --- a/app/test-pmd/cmdline.c +++ b/app/test-pmd/cmdline.c @@ -423,13 +423,16 @@ static void cmd_help_long_parsed(void *parsed_result, "tso show (portid)" " Display the status of TCP Segmentation Offload.\n\n" - "gro (on|off) (port_id)" + "set port (port_id) gro on|off\n" " Enable or disable Generic Receive Offload in" " csum forwarding engine.\n\n" - "gro set (max_flow_num) (max_item_num_per_flow) (port_id)\n" - " Set max flow number and max packet number per-flow" - " for GRO.\n\n" + "show port (port_id) gro\n" + " Display GRO configuration.\n\n" + + "set gro flush (cycles)\n" + " Set the cycle to flush GROed packets from" + " reassembly tables.\n\n" "set fwd (%s)\n" " Set packet forwarding mode.\n\n" @@ -3850,115 +3853,145 @@ cmdline_parse_inst_t cmd_tunnel_tso_show = { }; /* *** SET GRO FOR A PORT *** */ -struct cmd_gro_result { +struct cmd_gro_enable_result { + cmdline_fixed_string_t cmd_set; + cmdline_fixed_string_t cmd_port; cmdline_fixed_string_t cmd_keyword; - cmdline_fixed_string_t mode; - uint8_t port_id; + cmdline_fixed_string_t cmd_onoff; + uint8_t cmd_pid; }; static void -cmd_enable_gro_parsed(void *parsed_result, +cmd_gro_enable_parsed(void *parsed_result, __attribute__((unused)) struct cmdline *cl, __attribute__((unused)) void *data) { - struct cmd_gro_result *res; + struct cmd_gro_enable_result *res; res = parsed_result; - setup_gro(res->mode, res->port_id); -} - -cmdline_parse_token_string_t cmd_gro_keyword = - TOKEN_STRING_INITIALIZER(struct cmd_gro_result, + if (!strcmp(res->cmd_keyword, "gro")) + setup_gro(res->cmd_onoff, res->cmd_pid); +} + +cmdline_parse_token_string_t cmd_gro_enable_set = + TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result, + cmd_set, "set"); +cmdline_parse_token_string_t cmd_gro_enable_port = + TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result, + cmd_keyword, "port"); +cmdline_parse_token_num_t cmd_gro_enable_pid = + TOKEN_NUM_INITIALIZER(struct cmd_gro_enable_result, + cmd_pid, UINT8); +cmdline_parse_token_string_t cmd_gro_enable_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result, cmd_keyword, "gro"); -cmdline_parse_token_string_t cmd_gro_mode = - TOKEN_STRING_INITIALIZER(struct cmd_gro_result, - mode, "on#off"); -cmdline_parse_token_num_t cmd_gro_pid = - TOKEN_NUM_INITIALIZER(struct cmd_gro_result, - port_id, UINT8); +cmdline_parse_token_string_t cmd_gro_enable_onoff = + TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result, + cmd_onoff, "on#off"); -cmdline_parse_inst_t cmd_enable_gro = { - .f = cmd_enable_gro_parsed, +cmdline_parse_inst_t cmd_gro_enable = { + .f = cmd_gro_enable_parsed, .data = NULL, - .help_str = "gro (on|off) (port_id)", + .help_str = "set port gro on|off", .tokens = { - (void *)&cmd_gro_keyword, - (void *)&cmd_gro_mode, - (void *)&cmd_gro_pid, + (void *)&cmd_gro_enable_set, + (void *)&cmd_gro_enable_port, + (void *)&cmd_gro_enable_pid, + (void *)&cmd_gro_enable_keyword, + (void *)&cmd_gro_enable_onoff, NULL, }, }; -/* *** SET MAX FLOW NUMBER AND ITEM NUM PER FLOW FOR GRO *** */ -struct cmd_gro_set_result { - cmdline_fixed_string_t gro; - cmdline_fixed_string_t mode; - uint16_t flow_num; - uint16_t item_num_per_flow; - uint8_t port_id; +/* *** DISPLAY GRO CONFIGURATION *** */ +struct cmd_gro_show_result { + cmdline_fixed_string_t cmd_show; + cmdline_fixed_string_t cmd_port; + cmdline_fixed_string_t cmd_keyword; + uint8_t cmd_pid; }; static void -cmd_gro_set_parsed(void *parsed_result, - __attribute__((unused)) struct cmdline *cl, - __attribute__((unused)) void *data) +cmd_gro_show_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) { - struct cmd_gro_set_result *res = parsed_result; + struct cmd_gro_show_result *res; - if (port_id_is_invalid(res->port_id, ENABLED_WARN)) - return; - if (test_done == 0) { - printf("Before set GRO flow_num and item_num_per_flow," - " please stop forwarding first\n"); - return; - } + res = parsed_result; + if (!strcmp(res->cmd_keyword, "gro")) + show_gro(res->cmd_pid); +} + +cmdline_parse_token_string_t cmd_gro_show_show = + TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result, + cmd_show, "show"); +cmdline_parse_token_string_t cmd_gro_show_port = + TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result, + cmd_port, "port"); +cmdline_parse_token_num_t cmd_gro_show_pid = + TOKEN_NUM_INITIALIZER(struct cmd_gro_show_result, + cmd_pid, UINT8); +cmdline_parse_token_string_t cmd_gro_show_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result, + cmd_keyword, "gro"); - if (!strcmp(res->mode, "set")) { - if (res->flow_num == 0) - printf("Invalid flow number. Revert to default value:" - " %u.\n", GRO_DEFAULT_FLOW_NUM); - else - gro_ports[res->port_id].param.max_flow_num = - res->flow_num; +cmdline_parse_inst_t cmd_gro_show = { + .f = cmd_gro_show_parsed, + .data = NULL, + .help_str = "show port gro", + .tokens = { + (void *)&cmd_gro_show_show, + (void *)&cmd_gro_show_port, + (void *)&cmd_gro_show_pid, + (void *)&cmd_gro_show_keyword, + NULL, + }, +}; - if (res->item_num_per_flow == 0) - printf("Invalid item number per-flow. Revert" - " to default value:%u.\n", - GRO_DEFAULT_ITEM_NUM_PER_FLOW); - else - gro_ports[res->port_id].param.max_item_per_flow = - res->item_num_per_flow; - } +/* *** SET FLUSH CYCLES FOR GRO *** */ +struct cmd_gro_flush_result { + cmdline_fixed_string_t cmd_set; + cmdline_fixed_string_t cmd_keyword; + cmdline_fixed_string_t cmd_flush; + uint8_t cmd_cycles; +}; + +static void +cmd_gro_flush_parsed(void *parsed_result, + __attribute__((unused)) struct cmdline *cl, + __attribute__((unused)) void *data) +{ + struct cmd_gro_flush_result *res; + + res = parsed_result; + if ((!strcmp(res->cmd_keyword, "gro")) && + (!strcmp(res->cmd_flush, "flush"))) + setup_gro_flush_cycles(res->cmd_cycles); } -cmdline_parse_token_string_t cmd_gro_set_gro = - TOKEN_STRING_INITIALIZER(struct cmd_gro_set_result, - gro, "gro"); -cmdline_parse_token_string_t cmd_gro_set_mode = - TOKEN_STRING_INITIALIZER(struct cmd_gro_set_result, - mode, "set"); -cmdline_parse_token_num_t cmd_gro_set_flow_num = - TOKEN_NUM_INITIALIZER(struct cmd_gro_set_result, - flow_num, UINT16); -cmdline_parse_token_num_t cmd_gro_set_item_num_per_flow = - TOKEN_NUM_INITIALIZER(struct cmd_gro_set_result, - item_num_per_flow, UINT16); -cmdline_parse_token_num_t cmd_gro_set_portid = - TOKEN_NUM_INITIALIZER(struct cmd_gro_set_result, - port_id, UINT8); +cmdline_parse_token_string_t cmd_gro_flush_set = + TOKEN_STRING_INITIALIZER(struct cmd_gro_flush_result, + cmd_set, "set"); +cmdline_parse_token_string_t cmd_gro_flush_keyword = + TOKEN_STRING_INITIALIZER(struct cmd_gro_flush_result, + cmd_keyword, "gro"); +cmdline_parse_token_string_t cmd_gro_flush_flush = + TOKEN_STRING_INITIALIZER(struct cmd_gro_flush_result, + cmd_flush, "flush"); +cmdline_parse_token_num_t cmd_gro_flush_cycles = + TOKEN_NUM_INITIALIZER(struct cmd_gro_flush_result, + cmd_cycles, UINT8); -cmdline_parse_inst_t cmd_gro_set = { - .f = cmd_gro_set_parsed, +cmdline_parse_inst_t cmd_gro_flush = { + .f = cmd_gro_flush_parsed, .data = NULL, - .help_str = "gro set " - ": set max flow number and max packet number per-flow " - "for GRO", + .help_str = "set gro flush ", .tokens = { - (void *)&cmd_gro_set_gro, - (void *)&cmd_gro_set_mode, - (void *)&cmd_gro_set_flow_num, - (void *)&cmd_gro_set_item_num_per_flow, - (void *)&cmd_gro_set_portid, + (void *)&cmd_gro_flush_set, + (void *)&cmd_gro_flush_keyword, + (void *)&cmd_gro_flush_flush, + (void *)&cmd_gro_flush_cycles, NULL, }, }; @@ -14249,8 +14282,9 @@ cmdline_parse_ctx_t main_ctx[] = { (cmdline_parse_inst_t *)&cmd_tso_show, (cmdline_parse_inst_t *)&cmd_tunnel_tso_set, (cmdline_parse_inst_t *)&cmd_tunnel_tso_show, - (cmdline_parse_inst_t *)&cmd_enable_gro, - (cmdline_parse_inst_t *)&cmd_gro_set, + (cmdline_parse_inst_t *)&cmd_gro_enable, + (cmdline_parse_inst_t *)&cmd_gro_flush, + (cmdline_parse_inst_t *)&cmd_gro_show, (cmdline_parse_inst_t *)&cmd_link_flow_control_set, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_rx, (cmdline_parse_inst_t *)&cmd_link_flow_control_set_tx, diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c index 3ae3e1c..d97d291 100644 --- a/app/test-pmd/config.c +++ b/app/test-pmd/config.c @@ -2420,7 +2420,7 @@ set_tx_pkt_segments(unsigned *seg_lengths, unsigned nb_segs) } void -setup_gro(const char *mode, uint8_t port_id) +setup_gro(const char *onoff, uint8_t port_id) { if (!rte_eth_dev_is_valid_port(port_id)) { printf("invalid port id %u\n", port_id); @@ -2431,29 +2431,76 @@ setup_gro(const char *mode, uint8_t port_id) " please stop forwarding first\n"); return; } - if (strcmp(mode, "on") == 0) { - if (gro_ports[port_id].enable) { - printf("port %u has enabled GRO\n", port_id); + if (strcmp(onoff, "on") == 0) { + if (gro_ports[port_id].enable != 0) { + printf("Port %u has enabled GRO. Please" + " disable GRO first\n", port_id); return; } - gro_ports[port_id].enable = 1; - gro_ports[port_id].param.gro_types = RTE_GRO_TCP_IPV4; - - if (gro_ports[port_id].param.max_flow_num == 0) + if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) { + gro_ports[port_id].param.gro_types = RTE_GRO_TCP_IPV4; gro_ports[port_id].param.max_flow_num = GRO_DEFAULT_FLOW_NUM; - if (gro_ports[port_id].param.max_item_per_flow == 0) gro_ports[port_id].param.max_item_per_flow = GRO_DEFAULT_ITEM_NUM_PER_FLOW; + } + gro_ports[port_id].enable = 1; } else { if (gro_ports[port_id].enable == 0) { - printf("port %u has disabled GRO\n", port_id); + printf("Port %u has disabled GRO\n", port_id); return; } gro_ports[port_id].enable = 0; } } +void +setup_gro_flush_cycles(uint8_t cycles) +{ + if (test_done == 0) { + printf("Before change flush interval for GRO," + " please stop forwarding first\n"); + return; + } + + if (cycles > GRO_MAX_FLUSH_CYCLES) { + printf("The flushing cycle be in the range" + " of 1 to %u. Revert to the default" + " value %u\n", + GRO_MAX_FLUSH_CYCLES, + GRO_DEFAULT_FLUSH_CYCLES); + cycles = GRO_DEFAULT_FLUSH_CYCLES; + } + + gro_flush_cycles = cycles; +} + +void +show_gro(uint8_t port_id) +{ + struct rte_gro_param *param; + uint32_t max_pkts_num; + + param = &gro_ports[port_id].param; + + if (!rte_eth_dev_is_valid_port(port_id)) { + printf("Invalid port id %u\n", port_id); + return; + } + if (gro_ports[port_id].enable) { + printf("GRO type: TCP/IPv4\n"); + if (gro_flush_cycles > 0) + max_pkts_num = MAX_PKT_BURST * GRO_MAX_FLUSH_CYCLES; + else { + max_pkts_num = param->max_flow_num * + param->max_item_per_flow; + } + printf("Max packet number to GRO: %u\n", max_pkts_num); + printf("Flushing cycles: %u\n", gro_flush_cycles); + } else + printf("Port %u doesn't enable GRO\n", port_id); +} + char* list_pkt_forwarding_modes(void) { diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c index 90c8119..ca50ab7 100644 --- a/app/test-pmd/csumonly.c +++ b/app/test-pmd/csumonly.c @@ -631,6 +631,9 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) struct rte_mbuf *m, *p; struct ether_hdr *eth_hdr; void *l3_hdr = NULL, *outer_l3_hdr = NULL; /* can be IPv4 or IPv6 */ + void **gro_ctx; + uint16_t gro_pkts_num; + uint8_t gro_enable; uint16_t nb_rx; uint16_t nb_tx; uint16_t nb_prep; @@ -657,17 +660,13 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) nb_pkt_per_burst); if (unlikely(nb_rx == 0)) return; - if (unlikely(gro_ports[fs->rx_port].enable)) - nb_rx = rte_gro_reassemble_burst(pkts_burst, - nb_rx, - &(gro_ports[fs->rx_port].param)); - #ifdef RTE_TEST_PMD_RECORD_BURST_STATS fs->rx_burst_stats.pkt_burst_spread[nb_rx]++; #endif fs->rx_packets += nb_rx; rx_bad_ip_csum = 0; rx_bad_l4_csum = 0; + gro_enable = gro_ports[fs->rx_port].enable; txp = &ports[fs->tx_port]; testpmd_ol_flags = txp->tx_ol_flags; @@ -851,6 +850,28 @@ pkt_burst_checksum_forward(struct fwd_stream *fs) } } + if (unlikely(gro_enable)) { + if (gro_flush_cycles == GRO_DEFAULT_FLUSH_CYCLES) { + nb_rx = rte_gro_reassemble_burst(pkts_burst, nb_rx, + &(gro_ports[fs->rx_port].param)); + } else { + gro_ctx = current_fwd_lcore()->gro_ctx; + nb_rx = rte_gro_reassemble(pkts_burst, nb_rx, gro_ctx); + + if (++fs->gro_times >= gro_flush_cycles) { + gro_pkts_num = rte_gro_get_pkt_count(gro_ctx); + if (gro_pkts_num > MAX_PKT_BURST - nb_rx) + gro_pkts_num = MAX_PKT_BURST - nb_rx; + + nb_rx += rte_gro_timeout_flush(gro_ctx, 0, + RTE_GRO_TCP_IPV4, + &pkts_burst[nb_rx], + gro_pkts_num); + fs->gro_times = 0; + } + } + } + nb_prep = rte_eth_tx_prepare(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx); if (nb_prep != nb_rx) diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c index 7d40139..c1423d5 100644 --- a/app/test-pmd/testpmd.c +++ b/app/test-pmd/testpmd.c @@ -90,7 +90,6 @@ #ifdef RTE_LIBRTE_LATENCY_STATS #include #endif -#include #include "testpmd.h" @@ -386,6 +385,7 @@ uint8_t bitrate_enabled; #endif struct gro_status gro_ports[RTE_MAX_ETHPORTS]; +uint8_t gro_flush_cycles = GRO_DEFAULT_FLUSH_CYCLES; /* Forward function declarations */ static void map_port_queue_stats_mapping_registers(uint8_t pi, struct rte_port *port); @@ -570,6 +570,7 @@ init_config(void) unsigned int nb_mbuf_per_pool; lcoreid_t lc_id; uint8_t port_per_socket[RTE_MAX_NUMA_NODES]; + struct rte_gro_param gro_param; memset(port_per_socket,0,RTE_MAX_NUMA_NODES); @@ -671,6 +672,20 @@ init_config(void) rte_exit(EXIT_FAILURE, "FAIL from init_fwd_streams()\n"); fwd_config_setup(); + + /* create a gro context for each lcore */ + gro_param.gro_types = RTE_GRO_TCP_IPV4; + gro_param.max_flow_num = GRO_MAX_FLUSH_CYCLES; + gro_param.max_item_per_flow = MAX_PKT_BURST; + for (lc_id = 0; lc_id < nb_lcores; lc_id++) { + gro_param.socket_id = rte_lcore_to_socket_id( + fwd_lcores_cpuids[lc_id]); + fwd_lcores[lc_id]->gro_ctx = rte_gro_ctx_create(&gro_param); + if (fwd_lcores[lc_id]->gro_ctx == NULL) { + rte_exit(EXIT_FAILURE, + "rte_gro_ctx_create() failed\n"); + } + } } @@ -1165,6 +1180,7 @@ start_packet_forwarding(int with_tx_first) fwd_streams[sm_id]->fwd_dropped = 0; fwd_streams[sm_id]->rx_bad_ip_csum = 0; fwd_streams[sm_id]->rx_bad_l4_csum = 0; + fwd_streams[sm_id]->gro_times = 0; #ifdef RTE_TEST_PMD_RECORD_BURST_STATS memset(&fwd_streams[sm_id]->rx_burst_stats, 0, diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h index c9d7739..e878bcb 100644 --- a/app/test-pmd/testpmd.h +++ b/app/test-pmd/testpmd.h @@ -120,6 +120,7 @@ struct fwd_stream { unsigned int fwd_dropped; /**< received packets not forwarded */ unsigned int rx_bad_ip_csum ; /**< received packets has bad ip checksum */ unsigned int rx_bad_l4_csum ; /**< received packets has bad l4 checksum */ + unsigned int gro_times; /**< GRO operation times */ #ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES uint64_t core_cycles; /**< used for RX and TX processing */ #endif @@ -206,6 +207,7 @@ struct rte_port { */ struct fwd_lcore { struct rte_mempool *mbp; /**< The mbuf pool to use by this core */ + void *gro_ctx; /**< GRO context */ streamid_t stream_idx; /**< index of 1st stream in "fwd_streams" */ streamid_t stream_nb; /**< number of streams in "fwd_streams" */ lcoreid_t cpuid_idx; /**< index of logical core in CPU id table */ @@ -434,13 +436,19 @@ extern struct ether_addr peer_eth_addrs[RTE_MAX_ETHPORTS]; extern uint32_t burst_tx_delay_time; /**< Burst tx delay time(us) for mac-retry. */ extern uint32_t burst_tx_retry_num; /**< Burst tx retry number for mac-retry. */ -#define GRO_DEFAULT_FLOW_NUM 4 -#define GRO_DEFAULT_ITEM_NUM_PER_FLOW DEF_PKT_BURST +#define GRO_DEFAULT_ITEM_NUM_PER_FLOW 32 +#define GRO_DEFAULT_FLOW_NUM (RTE_GRO_MAX_BURST_ITEM_NUM / \ + GRO_DEFAULT_ITEM_NUM_PER_FLOW) + +#define GRO_DEFAULT_FLUSH_CYCLES 1 +#define GRO_MAX_FLUSH_CYCLES 4 + struct gro_status { struct rte_gro_param param; uint8_t enable; }; extern struct gro_status gro_ports[RTE_MAX_ETHPORTS]; +extern uint8_t gro_flush_cycles; static inline unsigned int lcore_num(void) @@ -640,7 +648,9 @@ void get_2tuple_filter(uint8_t port_id, uint16_t index); void get_5tuple_filter(uint8_t port_id, uint16_t index); int rx_queue_id_is_invalid(queueid_t rxq_id); int tx_queue_id_is_invalid(queueid_t txq_id); -void setup_gro(const char *mode, uint8_t port_id); +void setup_gro(const char *onoff, uint8_t port_id); +void setup_gro_flush_cycles(uint8_t cycles); +void show_gro(uint8_t port_id); /* Functions to manage the set of filtered Multicast MAC addresses */ void mcast_addr_add(uint8_t port_id, struct ether_addr *mc_addr); diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst index 2ed62f5..7f21b7d 100644 --- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst +++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst @@ -898,12 +898,12 @@ Display the status of TCP Segmentation Offload:: testpmd> tso show (port_id) -gro -~~~ +set port - gro +~~~~~~~~~~~~~~ Enable or disable GRO in ``csum`` forwarding engine:: - testpmd> gro (on|off) (port_id) + testpmd> set port gro on|off If enabled, the csum forwarding engine will perform GRO on the TCP/IPv4 packets received from the given port. @@ -914,23 +914,38 @@ GRO. By default, GRO is disabled for all ports. .. note:: When enable GRO for a port, TCP/IPv4 packets received from the port - will be performed GRO. After GRO, the merged packets are multi-segments. - But csum forwarding engine doesn't support to calculate TCP checksum - for multi-segment packets in SW. So please select TCP HW checksum - calculation for the port which GROed packets are transmitted to. + will be performed GRO. After GRO, all merged packets have bad + checksums, since the GRO library doesn't re-calculate checksums for + the merged packets. Therefore, if users want the merged packets to + have correct checksums, please select IP and TCP HW checksum calculation + for the port which the merged packets are transmitted to. -gro set -~~~~~~~ +show port - gro +~~~~~~~~~~~~~~~ + +Display GRO configuration for a given port:: + + testpmd> show port gro + +set gro flush +~~~~~~~~~~~~~ + +Set the cycle to flush the GROed packets from reassembly tables:: -Set max flow number and max packet number per-flow for GRO:: + testpmd> set gro flush - testpmd> gro set (max_flow_num) (max_item_num_per_flow) (port_id) +When enable GRO, the csum forwarding engine performs GRO on received +packets, and the GROed packets are stored in reassembly tables. Users +can use this command to determine when the GROed packets are flushed +from the reassembly tables. -The product of ``max_flow_num`` and ``max_item_num_per_flow`` is the max -number of packets a GRO table can store. +The ``cycles`` is measured in GRO operation times. The csum forwarding +engine flushes the GROed packets from the tables every ``cycles`` GRO +operations. -If current packet number is greater than or equal to the max value, GRO -will stop processing incoming packets. +By default, the value of ``cycles`` is 1, which means flush GROed packets +from the reassembly tables as soon as one GRO operation finishes. The value +of ``cycles`` should be in the range of 1 to ``GRO_MAX_FLUSH_CYCLES``. mac_addr add ~~~~~~~~~~~~