From patchwork Sat Sep 4 07:46:28 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Shijith Thotton X-Patchwork-Id: 97978 X-Patchwork-Delegate: jerinj@marvell.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 5391CA0C45; Sat, 4 Sep 2021 09:46:46 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id CC2FF40E3C; Sat, 4 Sep 2021 09:46:45 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id BBBE640DDD for ; Sat, 4 Sep 2021 09:46:43 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.16.1.2/8.16.1.2) with SMTP id 183KZxkg012098 for ; Sat, 4 Sep 2021 00:46:42 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h=from : to : cc : subject : date : message-id : mime-version : content-transfer-encoding : content-type; s=pfpt0220; bh=OLjKNbXqbOgqgbjK+t3rvfi3CEpxbkx9ws+N+Xks6s0=; b=hQC+Nc7mqmxqVWS/3H+yJO3Q7SkHLIEr4L8ifyBFaCs7bBa8N7diDewFZz/IgbdeoL0U A0JPjXejWseC+C8krbGVl47PeK5S3UbBtZnvGA3rq9Gysv3vH+HJzhkmSnAhCYFjeh99 K8GCFdHcPClOSq+mR4rP3lum9bIP3P+FEq2rP1+D7Ub4IyCVhtn5t5vbYcxCHKjQ2igO lEPkAuY2Tz999zxUxEfkqw9osUmgoLrwFVb9F4wOaEOgngZ/kgBdpTmFA6c1KMyDmkzN efaUm9IZ1MAv+SBHTr0qCOGh1UudjEQ5HGAkJP5th7i3gitylEoJ6bcY8MVQNAWj8sm2 hg== Received: from dc5-exch01.marvell.com ([199.233.59.181]) by mx0b-0016f401.pphosted.com with ESMTP id 3aufr8bxtp-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT) for ; Sat, 04 Sep 2021 00:46:42 -0700 Received: from DC5-EXCH02.marvell.com (10.69.176.39) by DC5-EXCH01.marvell.com (10.69.176.38) with Microsoft SMTP Server (TLS) id 15.0.1497.18; Sat, 4 Sep 2021 00:46:40 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH02.marvell.com (10.69.176.39) with Microsoft SMTP Server id 15.0.1497.18 via Frontend Transport; Sat, 4 Sep 2021 00:46:40 -0700 Received: from localhost.localdomain (unknown [10.28.34.29]) by maili.marvell.com (Postfix) with ESMTP id 3B41D3F7052; Sat, 4 Sep 2021 00:46:37 -0700 (PDT) From: Shijith Thotton To: CC: Shijith Thotton , , , , , Sunil Kumar Kori Date: Sat, 4 Sep 2021 13:16:28 +0530 Message-ID: <87a3db1b522b66efc58f23e2d8e80ed1af4a860b.1630740275.git.sthotton@marvell.com> X-Mailer: git-send-email 2.25.1 MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: 9q0jhKO9WlcJFave5kgbKB8EEJw7uPhf X-Proofpoint-GUID: 9q0jhKO9WlcJFave5kgbKB8EEJw7uPhf X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.182.1,Aquarius:18.0.790,Hydra:6.0.391,FMLib:17.0.607.475 definitions=2021-09-04_02,2021-09-03_01,2020-04-07_01 Subject: [dpdk-dev] [PATCH] examples/l2fwd-event: changes to use event vector X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 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" Added changes to receive packets as event vector. By default this is disabled and can be enabled using the option --enable-vector. Vector size and timeout to form the vector can be configured using options --vector-size and --vector-tmo-ns. Example: dpdk-l2fwd-event -l 0-3 -n 4 -- -p 0x03 --mode=eventdev \ --eventq-sched=ordered --enable-vector --vector-size 16 Signed-off-by: Shijith Thotton --- Depends-on: series=18322 (eventdev: simplify Rx adapter event vector config) doc/guides/sample_app_ug/l2_forward_event.rst | 13 +- examples/l2fwd-event/l2fwd_common.h | 12 ++ examples/l2fwd-event/l2fwd_event.c | 204 ++++++++++++++++-- examples/l2fwd-event/l2fwd_event_generic.c | 21 ++ .../l2fwd-event/l2fwd_event_internal_port.c | 22 ++ examples/l2fwd-event/main.c | 48 +++++ 6 files changed, 306 insertions(+), 14 deletions(-) diff --git a/doc/guides/sample_app_ug/l2_forward_event.rst b/doc/guides/sample_app_ug/l2_forward_event.rst index 540ca015db..1308f7e6d0 100644 --- a/doc/guides/sample_app_ug/l2_forward_event.rst +++ b/doc/guides/sample_app_ug/l2_forward_event.rst @@ -52,7 +52,12 @@ The application requires a number of command line options: .. code-block:: console - .//examples/dpdk-l2fwd-event [EAL options] -- -p PORTMASK [-q NQ] --[no-]mac-updating --mode=MODE --eventq-sched=SCHED_MODE + .//examples/dpdk-l2fwd-event [EAL options] -- -p PORTMASK + [-q NQ] + [--[no-]mac-updating] + [--mode=MODE] + [--eventq-sched=SCHED_MODE] + [--enable-vector [--vector-size SIZE] [--vector-tmo-ns NS]] where, @@ -68,6 +73,12 @@ where, * --config: Configure forwarding port pair mapping. Alternate port pairs by default. +* --enable-vector: Enable event vectorization. Only valid if --mode=eventdev. + +* --vector-size: Max vector size if event vectorization is enabled. + +* --vector-tmo-ns: Max timeout to form vector in nanoseconds if event vectorization is enabled. + Sample usage commands are given below to run the application into different mode: Poll mode with 4 lcores, 16 ports and 8 RX queues per lcore and MAC address updating enabled, diff --git a/examples/l2fwd-event/l2fwd_common.h b/examples/l2fwd-event/l2fwd_common.h index 939221d45a..5e380ded16 100644 --- a/examples/l2fwd-event/l2fwd_common.h +++ b/examples/l2fwd-event/l2fwd_common.h @@ -56,6 +56,9 @@ #define DEFAULT_TIMER_PERIOD 10 /* default period is 10 seconds */ #define MAX_TIMER_PERIOD 86400 /* 1 day max */ +#define VECTOR_SIZE_DEFAULT MAX_PKT_BURST +#define VECTOR_TMO_NS_DEFAULT 1E6 /* 1ms */ + /* Per-port statistics struct */ struct l2fwd_port_statistics { uint64_t dropped; @@ -63,6 +66,13 @@ struct l2fwd_port_statistics { uint64_t rx; } __rte_cache_aligned; +/* Event vector attributes */ +struct l2fwd_event_vector_params { + uint8_t enabled; + uint16_t size; + uint64_t timeout_ns; +}; + struct l2fwd_resources { volatile uint8_t force_quit; uint8_t event_mode; @@ -75,9 +85,11 @@ struct l2fwd_resources { uint32_t enabled_port_mask; uint64_t timer_period; struct rte_mempool *pktmbuf_pool; + struct rte_mempool *evt_vec_pool; uint32_t dst_ports[RTE_MAX_ETHPORTS]; struct rte_ether_addr eth_addr[RTE_MAX_ETHPORTS]; struct l2fwd_port_statistics port_stats[RTE_MAX_ETHPORTS]; + struct l2fwd_event_vector_params evt_vec; void *evt_rsrc; void *poll_rsrc; } __rte_cache_aligned; diff --git a/examples/l2fwd-event/l2fwd_event.c b/examples/l2fwd-event/l2fwd_event.c index 7ba5311d66..09080fa666 100644 --- a/examples/l2fwd-event/l2fwd_event.c +++ b/examples/l2fwd-event/l2fwd_event.c @@ -346,19 +346,198 @@ l2fwd_event_main_loop_tx_q_brst_mac(struct l2fwd_resources *rsrc) L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_BURST); } +static __rte_always_inline void +l2fwd_event_vector_fwd(struct l2fwd_resources *rsrc, + struct rte_event_vector *vec, + const uint64_t timer_period, const uint32_t flags) +{ + struct rte_mbuf **mbufs = vec->mbufs; + uint16_t i, j; + + rte_prefetch0(rte_pktmbuf_mtod(mbufs[0], void *)); + + /* If vector attribute is valid, mbufs will be from same port/queue */ + if (vec->attr_valid) { + vec->port = rsrc->dst_ports[mbufs[0]->port]; + if (flags & L2FWD_EVENT_TX_DIRECT) + vec->queue = 0; + + if (timer_period > 0) + __atomic_fetch_add(&rsrc->port_stats[mbufs[0]->port].rx, + vec->nb_elem, __ATOMIC_RELAXED); + + for (i = 0, j = 1; i < vec->nb_elem; i++, j++) { + if (j < vec->nb_elem) + rte_prefetch0( + rte_pktmbuf_mtod(mbufs[j], void *)); + + if (flags & L2FWD_EVENT_UPDT_MAC) + l2fwd_mac_updating( + mbufs[i], vec->port, + &rsrc->eth_addr[vec->port]); + } + + if (timer_period > 0) + __atomic_fetch_add(&rsrc->port_stats[vec->port].tx, + vec->nb_elem, __ATOMIC_RELAXED); + } else { + for (i = 0, j = 1; i < vec->nb_elem; i++, j++) { + if (timer_period > 0) + __atomic_fetch_add( + &rsrc->port_stats[mbufs[i]->port].rx, 1, + __ATOMIC_RELAXED); + + if (j < vec->nb_elem) + rte_prefetch0( + rte_pktmbuf_mtod(mbufs[j], void *)); + + mbufs[i]->port = rsrc->dst_ports[mbufs[i]->port]; + + if (flags & L2FWD_EVENT_UPDT_MAC) + l2fwd_mac_updating( + mbufs[i], mbufs[i]->port, + &rsrc->eth_addr[mbufs[i]->port]); + + if (flags & L2FWD_EVENT_TX_DIRECT) + rte_event_eth_tx_adapter_txq_set(mbufs[i], 0); + + if (timer_period > 0) + __atomic_fetch_add( + &rsrc->port_stats[mbufs[i]->port].tx, 1, + __ATOMIC_RELAXED); + } + } +} + +static __rte_always_inline void +l2fwd_event_loop_vector(struct l2fwd_resources *rsrc, const uint32_t flags) +{ + struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc; + const int port_id = l2fwd_get_free_event_port(evt_rsrc); + const uint8_t tx_q_id = + evt_rsrc->evq.event_q_id[evt_rsrc->evq.nb_queues - 1]; + const uint64_t timer_period = rsrc->timer_period; + const uint8_t event_d_id = evt_rsrc->event_d_id; + const uint8_t deq_len = evt_rsrc->deq_depth; + struct rte_event ev[MAX_PKT_BURST]; + uint16_t nb_rx, nb_tx; + uint8_t i; + + if (port_id < 0) + return; + + printf("%s(): entering eventdev main loop on lcore %u\n", __func__, + rte_lcore_id()); + + while (!rsrc->force_quit) { + nb_rx = rte_event_dequeue_burst(event_d_id, port_id, ev, + deq_len, 0); + if (nb_rx == 0) + continue; + + for (i = 0; i < nb_rx; i++) { + if (flags & L2FWD_EVENT_TX_ENQ) { + ev[i].queue_id = tx_q_id; + ev[i].op = RTE_EVENT_OP_FORWARD; + } + + l2fwd_event_vector_fwd(rsrc, ev[i].vec, timer_period, + flags); + } + + if (flags & L2FWD_EVENT_TX_ENQ) { + nb_tx = rte_event_enqueue_burst(event_d_id, port_id, ev, + nb_rx); + while (nb_tx < nb_rx && !rsrc->force_quit) + nb_tx += rte_event_enqueue_burst( + event_d_id, port_id, ev + nb_tx, + nb_rx - nb_tx); + } + + if (flags & L2FWD_EVENT_TX_DIRECT) { + nb_tx = rte_event_eth_tx_adapter_enqueue( + event_d_id, port_id, ev, nb_rx, 0); + while (nb_tx < nb_rx && !rsrc->force_quit) + nb_tx += rte_event_eth_tx_adapter_enqueue( + event_d_id, port_id, ev + nb_tx, + nb_rx - nb_tx, 0); + } + } +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_d_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_DIRECT); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_d_brst_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_DIRECT); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_q_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_ENQ); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_q_brst_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_ENQ); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_d_mac_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, + L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_DIRECT); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_d_brst_mac_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, + L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_DIRECT); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_q_mac_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, + L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_ENQ); +} + +static void __rte_noinline +l2fwd_event_main_loop_tx_q_brst_mac_vec(struct l2fwd_resources *rsrc) +{ + l2fwd_event_loop_vector(rsrc, + L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_ENQ); +} + void l2fwd_event_resource_setup(struct l2fwd_resources *rsrc) { /* [MAC_UPDT][TX_MODE][BURST] */ - const event_loop_cb event_loop[2][2][2] = { - [0][0][0] = l2fwd_event_main_loop_tx_d, - [0][0][1] = l2fwd_event_main_loop_tx_d_brst, - [0][1][0] = l2fwd_event_main_loop_tx_q, - [0][1][1] = l2fwd_event_main_loop_tx_q_brst, - [1][0][0] = l2fwd_event_main_loop_tx_d_mac, - [1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac, - [1][1][0] = l2fwd_event_main_loop_tx_q_mac, - [1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac, + const event_loop_cb event_loop[2][2][2][2] = { + [0][0][0][0] = l2fwd_event_main_loop_tx_d, + [0][0][0][1] = l2fwd_event_main_loop_tx_d_brst, + [0][0][1][0] = l2fwd_event_main_loop_tx_q, + [0][0][1][1] = l2fwd_event_main_loop_tx_q_brst, + [0][1][0][0] = l2fwd_event_main_loop_tx_d_mac, + [0][1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac, + [0][1][1][0] = l2fwd_event_main_loop_tx_q_mac, + [0][1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac, + [1][0][0][0] = l2fwd_event_main_loop_tx_d_vec, + [1][0][0][1] = l2fwd_event_main_loop_tx_d_brst_vec, + [1][0][1][0] = l2fwd_event_main_loop_tx_q_vec, + [1][0][1][1] = l2fwd_event_main_loop_tx_q_brst_vec, + [1][1][0][0] = l2fwd_event_main_loop_tx_d_mac_vec, + [1][1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac_vec, + [1][1][1][0] = l2fwd_event_main_loop_tx_q_mac_vec, + [1][1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac_vec, }; struct l2fwd_event_resources *evt_rsrc; uint32_t event_queue_cfg; @@ -394,8 +573,7 @@ l2fwd_event_resource_setup(struct l2fwd_resources *rsrc) if (ret < 0) rte_panic("Error in starting eventdev\n"); - evt_rsrc->ops.l2fwd_event_loop = event_loop - [rsrc->mac_updating] - [evt_rsrc->tx_mode_q] - [evt_rsrc->has_burst]; + evt_rsrc->ops.l2fwd_event_loop = + event_loop[rsrc->evt_vec.enabled][rsrc->mac_updating] + [evt_rsrc->tx_mode_q][evt_rsrc->has_burst]; } diff --git a/examples/l2fwd-event/l2fwd_event_generic.c b/examples/l2fwd-event/l2fwd_event_generic.c index c19b6f1411..203509dad0 100644 --- a/examples/l2fwd-event/l2fwd_event_generic.c +++ b/examples/l2fwd-event/l2fwd_event_generic.c @@ -245,6 +245,27 @@ l2fwd_rx_tx_adapter_setup_generic(struct l2fwd_resources *rsrc) if ((rsrc->enabled_port_mask & (1 << port_id)) == 0) continue; eth_q_conf.ev.queue_id = evt_rsrc->evq.event_q_id[i]; + if (rsrc->evt_vec.enabled) { + uint32_t cap; + + if (rte_event_eth_rx_adapter_caps_get(event_d_id, + port_id, &cap)) + rte_panic( + "Failed to get event rx adapter capability"); + + if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR) { + eth_q_conf.vector_sz = rsrc->evt_vec.size; + eth_q_conf.vector_timeout_ns = + rsrc->evt_vec.timeout_ns; + eth_q_conf.vector_mp = rsrc->evt_vec_pool; + eth_q_conf.rx_queue_flags |= + RTE_EVENT_ETH_RX_ADAPTER_QUEUE_EVENT_VECTOR; + } else { + rte_panic( + "Rx adapter doesn't support event vector"); + } + } + ret = rte_event_eth_rx_adapter_queue_add(rx_adptr_id, port_id, -1, ð_q_conf); if (ret) diff --git a/examples/l2fwd-event/l2fwd_event_internal_port.c b/examples/l2fwd-event/l2fwd_event_internal_port.c index 16a52d67c9..5efd44f950 100644 --- a/examples/l2fwd-event/l2fwd_event_internal_port.c +++ b/examples/l2fwd-event/l2fwd_event_internal_port.c @@ -230,6 +230,28 @@ l2fwd_rx_tx_adapter_setup_internal_port(struct l2fwd_resources *rsrc) RTE_ETH_FOREACH_DEV(port_id) { if ((rsrc->enabled_port_mask & (1 << port_id)) == 0) continue; + + if (rsrc->evt_vec.enabled) { + uint32_t cap; + + if (rte_event_eth_rx_adapter_caps_get(event_d_id, + port_id, &cap)) + rte_panic( + "Failed to get event rx adapter capability"); + + if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR) { + eth_q_conf.vector_sz = rsrc->evt_vec.size; + eth_q_conf.vector_timeout_ns = + rsrc->evt_vec.timeout_ns; + eth_q_conf.vector_mp = rsrc->evt_vec_pool; + eth_q_conf.rx_queue_flags |= + RTE_EVENT_ETH_RX_ADAPTER_QUEUE_EVENT_VECTOR; + } else { + rte_panic( + "Rx adapter doesn't support event vector"); + } + } + ret = rte_event_eth_rx_adapter_create(adapter_id, event_d_id, &evt_rsrc->def_p_conf); if (ret) diff --git a/examples/l2fwd-event/main.c b/examples/l2fwd-event/main.c index 1db89f2bd1..8d8267131d 100644 --- a/examples/l2fwd-event/main.c +++ b/examples/l2fwd-event/main.c @@ -25,6 +25,9 @@ l2fwd_event_usage(const char *prgname) " --eventq-sched: Event queue schedule type, ordered, atomic or parallel.\n" " Default: atomic\n" " Valid only if --mode=eventdev\n" + " --enable-vector: Enable event vectorization.\n" + " --vector-size: Max vector size if event vectorization is enabled.\n" + " --vector-tmo-ns: Max timeout to form vector in nanoseconds if event vectorization is enabled\n" " --config: Configure forwarding port pair mapping\n" " Default: alternate port pairs\n\n", prgname); @@ -175,6 +178,9 @@ static const char short_options[] = #define CMD_LINE_OPT_MODE "mode" #define CMD_LINE_OPT_EVENTQ_SCHED "eventq-sched" #define CMD_LINE_OPT_PORT_PAIR_CONF "config" +#define CMD_LINE_OPT_ENABLE_VECTOR "enable-vector" +#define CMD_LINE_OPT_VECTOR_SIZE "vector-size" +#define CMD_LINE_OPT_VECTOR_TMO_NS "vector-tmo-ns" enum { /* long options mapped to a short option */ @@ -186,6 +192,9 @@ enum { CMD_LINE_OPT_MODE_NUM, CMD_LINE_OPT_EVENTQ_SCHED_NUM, CMD_LINE_OPT_PORT_PAIR_CONF_NUM, + CMD_LINE_OPT_ENABLE_VECTOR_NUM, + CMD_LINE_OPT_VECTOR_SIZE_NUM, + CMD_LINE_OPT_VECTOR_TMO_NS_NUM }; /* Parse the argument given in the command line of the application */ @@ -202,6 +211,12 @@ l2fwd_event_parse_args(int argc, char **argv, struct l2fwd_resources *rsrc) CMD_LINE_OPT_EVENTQ_SCHED_NUM}, { CMD_LINE_OPT_PORT_PAIR_CONF, required_argument, NULL, CMD_LINE_OPT_PORT_PAIR_CONF_NUM}, + {CMD_LINE_OPT_ENABLE_VECTOR, no_argument, NULL, + CMD_LINE_OPT_ENABLE_VECTOR_NUM}, + {CMD_LINE_OPT_VECTOR_SIZE, required_argument, NULL, + CMD_LINE_OPT_VECTOR_SIZE_NUM}, + {CMD_LINE_OPT_VECTOR_TMO_NS, required_argument, NULL, + CMD_LINE_OPT_VECTOR_TMO_NS_NUM}, {NULL, 0, 0, 0} }; int opt, ret, timer_secs; @@ -270,6 +285,16 @@ l2fwd_event_parse_args(int argc, char **argv, struct l2fwd_resources *rsrc) return -1; } break; + case CMD_LINE_OPT_ENABLE_VECTOR_NUM: + printf("event vectorization is enabled\n"); + rsrc->evt_vec.enabled = 1; + break; + case CMD_LINE_OPT_VECTOR_SIZE_NUM: + rsrc->evt_vec.size = strtol(optarg, NULL, 10); + break; + case CMD_LINE_OPT_VECTOR_TMO_NS_NUM: + rsrc->evt_vec.timeout_ns = strtoull(optarg, NULL, 10); + break; /* long options */ case 0: @@ -283,6 +308,18 @@ l2fwd_event_parse_args(int argc, char **argv, struct l2fwd_resources *rsrc) rsrc->mac_updating = mac_updating; + if (rsrc->evt_vec.enabled && !rsrc->evt_vec.size) { + rsrc->evt_vec.size = VECTOR_SIZE_DEFAULT; + printf("vector size set to default (%" PRIu16 ")\n", + rsrc->evt_vec.size); + } + + if (rsrc->evt_vec.enabled && !rsrc->evt_vec.timeout_ns) { + rsrc->evt_vec.timeout_ns = VECTOR_TMO_NS_DEFAULT; + printf("vector timeout set to default (%" PRIu64 " ns)\n", + rsrc->evt_vec.timeout_ns); + } + if (optind >= 0) argv[optind-1] = prgname; @@ -636,6 +673,17 @@ main(int argc, char **argv) rte_panic("Cannot init mbuf pool\n"); /* >8 End of creation of mbuf pool. */ + if (rsrc->evt_vec.enabled) { + unsigned int nb_vec, vec_size; + + vec_size = rsrc->evt_vec.size; + nb_vec = (nb_mbufs + vec_size - 1) / vec_size; + rsrc->evt_vec_pool = rte_event_vector_pool_create( + "vector_pool", nb_vec, 0, vec_size, rte_socket_id()); + if (rsrc->evt_vec_pool == NULL) + rte_panic("Cannot init event vector pool\n"); + } + nb_ports_available = l2fwd_event_init_ports(rsrc); if (!nb_ports_available) rte_panic("All available ports are disabled. Please set portmask.\n");