From patchwork Fri Feb 10 04:58:14 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Naga Harish K, S V" X-Patchwork-Id: 123652 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 6C09641C5A; Fri, 10 Feb 2023 05:58:23 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 4B4C840EE6; Fri, 10 Feb 2023 05:58:23 +0100 (CET) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by mails.dpdk.org (Postfix) with ESMTP id DFCA240EE3 for ; Fri, 10 Feb 2023 05:58:20 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1676005101; x=1707541101; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=jfTLaeU+Nz+6SLZRclsOf2Tbzkq2cVRv9GC9AIJi9A4=; b=OazGCUHzIGZkVrLbh6SZ3PRIa2gsHwYJJDjVsCePYziJb5+xyu/rd5iG D90d38pdL7Del+P0SUSy1dxjsWgmw+RKozfqAOQU2sAdRt1pq1kIbA/RG dqvD2E8XH5d8m+AJW/3t+VzMoZMsobmjAGG5+vq15WCZ8g79MWIDpic5K +j2HbA7m/00K8flu939GfHf/KnaJ497Cd2YBSrqiNem6abH8afuLwWWxc Kej+FvJVXaddpZlNFSKrxqvYfWw7EBARHLjIo4N1sl/qJ+cDfrawGHJdG lKuknjd41KDR8LuQY7s0SiVQ2MGqIK02l2h4mnXd7otN6xhT15AnIRmr2 Q==; X-IronPort-AV: E=McAfee;i="6500,9779,10616"; a="318354268" X-IronPort-AV: E=Sophos;i="5.97,285,1669104000"; d="scan'208";a="318354268" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Feb 2023 20:58:20 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6500,9779,10616"; a="841912864" X-IronPort-AV: E=Sophos;i="5.97,285,1669104000"; d="scan'208";a="841912864" Received: from txandevlnx322.an.intel.com ([10.123.117.44]) by orsmga005.jf.intel.com with ESMTP; 09 Feb 2023 20:58:19 -0800 From: Naga Harish K S V To: jerinj@marvell.com, erik.g.carrillo@intel.com, abhinandan.gujjar@intel.com Cc: dev@dpdk.org, jay.jayatheerthan@intel.com Subject: [PATCH v4 1/3] eventdev/eth_rx: add params set/get APIs Date: Thu, 9 Feb 2023 22:58:14 -0600 Message-Id: <20230210045816.3039312-1-s.v.naga.harish.k@intel.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20230123180458.486189-1-s.v.naga.harish.k@intel.com> References: <20230123180458.486189-1-s.v.naga.harish.k@intel.com> MIME-Version: 1.0 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 The adapter configuration parameters defined in the ``struct rte_event_eth_rx_adapter_runtime_params`` can be configured and retrieved using ``rte_event_eth_rx_adapter_runtime_params_set`` and ``rte_event_eth_tx_adapter_runtime_params_get`` respectively. Signed-off-by: Naga Harish K S V --- app/test/test_event_eth_rx_adapter.c | 113 ++++++++++++++++++ .../prog_guide/event_ethernet_rx_adapter.rst | 11 ++ lib/eventdev/rte_event_eth_rx_adapter.c | 86 ++++++++++++- lib/eventdev/rte_event_eth_rx_adapter.h | 101 +++++++++++++++- lib/eventdev/version.map | 2 + 5 files changed, 311 insertions(+), 2 deletions(-) diff --git a/app/test/test_event_eth_rx_adapter.c b/app/test/test_event_eth_rx_adapter.c index 1da7782560..cfe6052d7e 100644 --- a/app/test/test_event_eth_rx_adapter.c +++ b/app/test/test_event_eth_rx_adapter.c @@ -1198,6 +1198,117 @@ adapter_intrq_instance_get(void) return TEST_SUCCESS; } +static int +adapter_get_set_params(void) +{ + int err; + struct rte_event_eth_rx_adapter_runtime_params in_params; + struct rte_event_eth_rx_adapter_runtime_params out_params; + struct rte_event_eth_rx_adapter_queue_conf queue_config = {0}; + struct rte_event ev; + + ev.queue_id = 0; + ev.sched_type = RTE_SCHED_TYPE_ATOMIC; + ev.priority = 0; + ev.flow_id = 1; + + queue_config.rx_queue_flags = + RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID; + queue_config.ev = ev; + queue_config.servicing_weight = 1; + + err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, + TEST_ETHDEV_ID, 0, + &queue_config); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_rx_adapter_runtime_params_init(&in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + err = rte_event_eth_rx_adapter_runtime_params_init(&out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + /* Case 1: Get the default value of mbufs processed by Rx adapter */ + err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + /* Case 2: Set max_nb_rx = 32 (=BATCH_SEIZE) */ + in_params.max_nb_rx = 32; + + err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx, + "Expected %u got %u", + in_params.max_nb_rx, out_params.max_nb_rx); + + /* Case 3: Set max_nb_rx = 192 */ + in_params.max_nb_rx = 192; + + err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx, + "Expected %u got %u", + in_params.max_nb_rx, out_params.max_nb_rx); + + /* Case 4: Set max_nb_rx = 256 */ + in_params.max_nb_rx = 256; + + err = rte_event_eth_rx_adapter_runtime_params_set(TEST_INST_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_rx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb_rx == out_params.max_nb_rx, + "Expected %u got %u", + in_params.max_nb_rx, out_params.max_nb_rx); + + /* Case 5: Set max_nb_rx = 30(event_port_id = port_id; - conf->max_nb_rx = 128; + conf->max_nb_rx = RXA_NB_RX_WORK_DEFAULT; if (started) ret = rte_event_dev_start(dev_id); rx_adapter->default_cb_arg = 1; @@ -3461,6 +3461,90 @@ rte_event_eth_rx_adapter_instance_get(uint16_t eth_dev_id, return -EINVAL; } +static int +rxa_caps_check(struct event_eth_rx_adapter *rxa) +{ + uint16_t eth_dev_id; + uint32_t caps = 0; + int ret; + + if (!rxa->nb_queues) + return -EINVAL; + + /* The eth_dev used is always of same type. + * Hence eth_dev_id is taken from first entry of poll array. + */ + eth_dev_id = rxa->eth_rx_poll[0].eth_dev_id; + ret = rte_event_eth_rx_adapter_caps_get(rxa->eventdev_id, + eth_dev_id, + &caps); + if (ret) { + RTE_EDEV_LOG_ERR("Failed to get adapter caps edev %" PRIu8 + "eth port %" PRIu16, rxa->eventdev_id, eth_dev_id); + return ret; + } + + if (caps & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT) + return -ENOTSUP; + + return 0; +} + +int +rte_event_eth_rx_adapter_runtime_params_set(uint8_t id, + struct rte_event_eth_rx_adapter_runtime_params *params) +{ + struct event_eth_rx_adapter *rxa; + int ret; + + if (params == NULL) + return -EINVAL; + + if (rxa_memzone_lookup()) + return -ENOMEM; + + rxa = rxa_id_to_adapter(id); + if (rxa == NULL) + return -EINVAL; + + ret = rxa_caps_check(rxa); + if (ret) + return ret; + + rte_spinlock_lock(&rxa->rx_lock); + rxa->max_nb_rx = params->max_nb_rx; + rte_spinlock_unlock(&rxa->rx_lock); + + return 0; +} + +int +rte_event_eth_rx_adapter_runtime_params_get(uint8_t id, + struct rte_event_eth_rx_adapter_runtime_params *params) +{ + struct event_eth_rx_adapter *rxa; + int ret; + + if (params == NULL) + return -EINVAL; + + if (rxa_memzone_lookup()) + return -ENOMEM; + + rxa = rxa_id_to_adapter(id); + if (rxa == NULL) + return -EINVAL; + + ret = rxa_caps_check(rxa); + if (ret) + return ret; + + params->max_nb_rx = rxa->max_nb_rx; + + return 0; +} + +/* RX-adapter telemetry callbacks */ #define RXA_ADD_DICT(stats, s) rte_tel_data_add_dict_uint(d, #s, stats.s) static int diff --git a/lib/eventdev/rte_event_eth_rx_adapter.h b/lib/eventdev/rte_event_eth_rx_adapter.h index f4652f40e8..9f781a5f69 100644 --- a/lib/eventdev/rte_event_eth_rx_adapter.h +++ b/lib/eventdev/rte_event_eth_rx_adapter.h @@ -39,10 +39,21 @@ * - rte_event_eth_rx_adapter_queue_stats_reset() * - rte_event_eth_rx_adapter_event_port_get() * - rte_event_eth_rx_adapter_instance_get() + * - rte_event_eth_rx_adapter_runtime_params_get() + * - rte_event_eth_rx_adapter_runtime_params_set() * * The application creates an ethernet to event adapter using * rte_event_eth_rx_adapter_create_ext() or rte_event_eth_rx_adapter_create() * or rte_event_eth_rx_adapter_create_with_params() functions. + * + * rte_event_eth_rx_adapter_create() or rte_event_eth_adapter_create_with_params() + * configures the adapter with default value of maximum packets processed per + * iteration to RXA_NB_RX_WORK_DEFAULT(128). + * rte_event_eth_rx_adapter_runtime_params_set() allows to re-configure maximum + * packets processed per iteration. This is alternative to using + * rte_event_eth_rx_adapter_create_ext() with parameter + * rte_event_eth_rx_adapter_conf::max_nb_rx + * * The adapter needs to know which ethernet rx queues to poll for mbufs as well * as event device parameters such as the event queue identifier, event * priority and scheduling type that the adapter should use when constructing @@ -121,6 +132,11 @@ struct rte_event_eth_rx_adapter_conf { */ }; +#define RXA_NB_RX_WORK_DEFAULT 128 +/**< The default value for maximum number of packets processed by service + * based adapter per each call. + */ + /** * Function type used for adapter configuration callback. The callback is * used to fill in members of the struct rte_event_eth_rx_adapter_conf, this @@ -299,6 +315,19 @@ struct rte_event_eth_rx_adapter_params { /**< flag to indicate that event buffer is separate for each queue */ }; +/** + * Adapter configuration parameters + */ +struct rte_event_eth_rx_adapter_runtime_params { + uint32_t max_nb_rx; + /**< The adapter can return early if it has processed at least + * max_nb_rx mbufs. This isn't treated as a requirement; batching may + * cause the adapter to process more than max_nb_rx mbufs. + */ + uint32_t rsvd[15]; + /**< Reserved fields for future use */ +}; + /** * * Callback function invoked by the SW adapter before it continues @@ -377,7 +406,7 @@ int rte_event_eth_rx_adapter_create_ext(uint8_t id, uint8_t dev_id, * Create a new ethernet Rx event adapter with the specified identifier. * This function uses an internal configuration function that creates an event * port. This default function reconfigures the event device with an - * additional event port and setups up the event port using the port_config + * additional event port and setup the event port using the port_config * parameter passed into this function. In case the application needs more * control in configuration of the service, it should use the * rte_event_eth_rx_adapter_create_ext() version. @@ -743,6 +772,76 @@ rte_event_eth_rx_adapter_instance_get(uint16_t eth_dev_id, uint16_t rx_queue_id, uint8_t *rxa_inst_id); +/** + * Initialize the adapter runtime configuration parameters with default values + * + * @param params + * A pointer to structure of type struct rte_event_eth_rx_adapter_runtime_params + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +static inline int +rte_event_eth_rx_adapter_runtime_params_init( + struct rte_event_eth_rx_adapter_runtime_params *params) +{ + if (params == NULL) + return -EINVAL; + + memset(params, 0, sizeof(struct rte_event_eth_rx_adapter_runtime_params)); + params->max_nb_rx = RXA_NB_RX_WORK_DEFAULT; + + return 0; +} + +/** + * Set the adapter runtime configuration parameters + * + * This API is to be used after adding at least one queue to the adapter + * and is supported only for service based adapter. + * + * @param id + * Adapter identifier + * + * @param params + * A pointer to structure of type struct rte_event_eth_rx_adapter_runtime_params + * with configuration parameter values. This structure can be initialized using + * rte_event_eth_rx_adapter_runtime_params_init() to default values or + * application may reset this structure and update the required fields. + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +int +rte_event_eth_rx_adapter_runtime_params_set(uint8_t id, + struct rte_event_eth_rx_adapter_runtime_params *params); + +/** + * Get the adapter runtime configuration parameters + * + * This API is to be used after adding at least one queue to the adapter + * and is supported only for service based adapter. + * + * @param id + * Adapter identifier + * + * @param[out] params + * A pointer to structure of type struct rte_event_eth_rx_adapter_runtime_params + * containing valid adapter parameters when return value is 0. + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +int +rte_event_eth_rx_adapter_runtime_params_get(uint8_t id, + struct rte_event_eth_rx_adapter_runtime_params *params); + #ifdef __cplusplus } #endif diff --git a/lib/eventdev/version.map b/lib/eventdev/version.map index 3add5e3088..da97db794f 100644 --- a/lib/eventdev/version.map +++ b/lib/eventdev/version.map @@ -121,6 +121,8 @@ EXPERIMENTAL { rte_event_eth_tx_adapter_queue_stop; # added in 23.03 + rte_event_eth_rx_adapter_runtime_params_get; + rte_event_eth_rx_adapter_runtime_params_set; rte_event_timer_remaining_ticks_get; }; From patchwork Fri Feb 10 04:58:15 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Naga Harish K, S V" X-Patchwork-Id: 123653 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 8D51741C5A; Fri, 10 Feb 2023 05:58:28 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 5E032427F2; Fri, 10 Feb 2023 05:58:25 +0100 (CET) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by mails.dpdk.org (Postfix) with ESMTP id 54F20410D0 for ; Fri, 10 Feb 2023 05:58:23 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1676005103; x=1707541103; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=tQTGHyUooVh6Q41L6wdDm1xnMKZ/XqSeoKvZIO2KPt8=; b=eyu2XO8yEJohiMDV61KYiRHI7x9aEgu5CRl8jZNkty6zuSmyxfTC+2ub SSY7rvVh6rI1M6qJbAkZ9IF8F2g38Pa6hC73wfgu7on8Xrvt1tsBbarDZ bzkJZmfOoLkGY+CaWK0Kj6ist+LRELDPbld58sQPtMk7AL9IxZ3ZEYUbc IE++ipF4Nkc1Xxkl/ZctELvnb0FFRD/+/9o4E2/OI5OPWdKSU0WidCIWH WXeKkvij9XwAGgNJCki7AJBBIlfih+yI7Cb3YidIr+NthKZAtEL/yO8VI kscEwBd0wju8gBod1NMpMwM0wblDi6BSaHJKY6Jl1QgVIU8+3Y9KtGvnf A==; X-IronPort-AV: E=McAfee;i="6500,9779,10616"; a="318354278" X-IronPort-AV: E=Sophos;i="5.97,285,1669104000"; d="scan'208";a="318354278" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Feb 2023 20:58:22 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6500,9779,10616"; a="841912878" X-IronPort-AV: E=Sophos;i="5.97,285,1669104000"; d="scan'208";a="841912878" Received: from txandevlnx322.an.intel.com ([10.123.117.44]) by orsmga005.jf.intel.com with ESMTP; 09 Feb 2023 20:58:22 -0800 From: Naga Harish K S V To: jerinj@marvell.com, erik.g.carrillo@intel.com, abhinandan.gujjar@intel.com Cc: dev@dpdk.org, jay.jayatheerthan@intel.com Subject: [PATCH v4 2/3] eventdev/eth_tx: add params set/get APIs Date: Thu, 9 Feb 2023 22:58:15 -0600 Message-Id: <20230210045816.3039312-2-s.v.naga.harish.k@intel.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20230210045816.3039312-1-s.v.naga.harish.k@intel.com> References: <20230123180458.486189-1-s.v.naga.harish.k@intel.com> <20230210045816.3039312-1-s.v.naga.harish.k@intel.com> MIME-Version: 1.0 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 The adapter configuration parameters defined in the ``struct rte_event_eth_tx_adapter_runtime_params`` can be configured and retrieved using ``rte_event_eth_tx_adapter_runtime_params_set`` and ``rte_event_eth_tx_adapter_runtime_params_get`` respectively. Signed-off-by: Naga Harish K S V --- app/test/test_event_eth_tx_adapter.c | 130 ++++++++++++++++++ .../prog_guide/event_ethernet_tx_adapter.rst | 15 ++ lib/eventdev/rte_event_eth_tx_adapter.c | 103 +++++++++++++- lib/eventdev/rte_event_eth_tx_adapter.h | 103 ++++++++++++++ lib/eventdev/version.map | 2 + 5 files changed, 350 insertions(+), 3 deletions(-) diff --git a/app/test/test_event_eth_tx_adapter.c b/app/test/test_event_eth_tx_adapter.c index c19a87a86a..a093ee0efc 100644 --- a/app/test/test_event_eth_tx_adapter.c +++ b/app/test/test_event_eth_tx_adapter.c @@ -795,6 +795,134 @@ tx_adapter_queue_start_stop(void) return TEST_SUCCESS; } +static int +tx_adapter_set_get_params(void) +{ + int err; + struct rte_event_eth_tx_adapter_runtime_params in_params; + struct rte_event_eth_tx_adapter_runtime_params out_params; + + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, + TEST_ETHDEV_ID, + 0); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_runtime_params_init(&in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + err = rte_event_eth_tx_adapter_runtime_params_init(&out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + /* Case 1: Get the default values of adapter */ + err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(out_params.flush_threshold == TXA_FLUSH_THRESHOLD, + "Expected %u got %u", + TXA_FLUSH_THRESHOLD, out_params.flush_threshold); + TEST_ASSERT(out_params.max_nb_tx == TXA_MAX_NB_TX, + "Expected %u got %u", + TXA_MAX_NB_TX, out_params.max_nb_tx); + + /* Case 2: Set max_nb_tx = 32 (=TXA_BATCH_SEIZE) */ + in_params.max_nb_tx = 32; + in_params.flush_threshold = TXA_FLUSH_THRESHOLD; + + err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, + "Expected %u got %u", + in_params.max_nb_tx, out_params.max_nb_tx); + TEST_ASSERT(in_params.flush_threshold == out_params.flush_threshold, + "Expected %u got %u", + in_params.flush_threshold, out_params.flush_threshold); + + /* Case 3: Set max_nb_tx = 192 */ + in_params.max_nb_tx = 192; + + err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, + "Expected %u got %u", + in_params.max_nb_tx, out_params.max_nb_tx); + + /* Case 4: Set max_nb_tx = 256 */ + in_params.max_nb_tx = 256; + + err = rte_event_eth_tx_adapter_runtime_params_set(TEST_INST_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_runtime_params_get(TEST_INST_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb_tx == out_params.max_nb_tx, + "Expected %u got %u", + in_params.max_nb_tx, out_params.max_nb_tx); + + /* Case 5: Set max_nb_tx = 30(loop_cnt++ & (TXA_FLUSH_THRESHOLD - 1)) == 0) { + if (txa->loop_cnt++ == txa->flush_threshold) { struct txa_service_ethdev *tdi; struct txa_service_queue_info *tqi; struct rte_eth_dev *dev; uint16_t i; + txa->loop_cnt = 0; tdi = txa->txa_ethdev; nb_tx = 0; @@ -769,6 +770,7 @@ txa_service_adapter_create_ext(uint8_t id, struct rte_eventdev *dev, txa->service_id = TXA_INVALID_SERVICE_ID; rte_spinlock_init(&txa->tx_lock); txa_service_data_array[id] = txa; + txa->flush_threshold = TXA_FLUSH_THRESHOLD; return 0; } @@ -1291,6 +1293,101 @@ rte_event_eth_tx_adapter_stats_reset(uint8_t id) return ret; } +static int +txa_caps_check(uint8_t id, struct txa_service_data *txa) +{ + uint32_t caps = 0; + struct rte_eth_dev *eth_dev = NULL; + struct txa_service_ethdev *tdi; + int i; + + if (!txa->dev_count) + return -EINVAL; + + /* The eth_dev used is always the same type. + * Hence first valid eth_dev is taken. + */ + for (i = 0; i < txa->dev_count; i++) { + tdi = &txa->txa_ethdev[i]; + if (tdi->nb_queues) { + eth_dev = tdi->dev; + break; + } + } + if (eth_dev == NULL) + return -EINVAL; + + if (txa_dev_caps_get(id)) + txa_dev_caps_get(id)(txa_evdev(id), eth_dev, &caps); + + if (caps & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT) + return -ENOTSUP; + + return 0; +} + +int +rte_event_eth_tx_adapter_runtime_params_set(uint8_t id, + struct rte_event_eth_tx_adapter_runtime_params *txa_params) +{ + struct txa_service_data *txa; + int ret; + + if (txa_lookup()) + return -ENOMEM; + + TXA_CHECK_OR_ERR_RET(id); + + if (txa_params == NULL) + return -EINVAL; + + txa = txa_service_id_to_data(id); + if (txa == NULL) + return -EINVAL; + + ret = txa_caps_check(id, txa); + if (ret) + return ret; + + rte_spinlock_lock(&txa->tx_lock); + txa->flush_threshold = txa_params->flush_threshold; + txa->max_nb_tx = txa_params->max_nb_tx; + rte_spinlock_unlock(&txa->tx_lock); + + return 0; +} + +int +rte_event_eth_tx_adapter_runtime_params_get(uint8_t id, + struct rte_event_eth_tx_adapter_runtime_params *txa_params) +{ + struct txa_service_data *txa; + int ret; + + if (txa_lookup()) + return -ENOMEM; + + TXA_CHECK_OR_ERR_RET(id); + + if (txa_params == NULL) + return -EINVAL; + + txa = txa_service_id_to_data(id); + if (txa == NULL) + return -EINVAL; + + ret = txa_caps_check(id, txa); + if (ret) + return ret; + + rte_spinlock_lock(&txa->tx_lock); + txa_params->flush_threshold = txa->flush_threshold; + txa_params->max_nb_tx = txa->max_nb_tx; + rte_spinlock_unlock(&txa->tx_lock); + + return 0; +} + int rte_event_eth_tx_adapter_stop(uint8_t id) { diff --git a/lib/eventdev/rte_event_eth_tx_adapter.h b/lib/eventdev/rte_event_eth_tx_adapter.h index cd539af7ef..e0332910eb 100644 --- a/lib/eventdev/rte_event_eth_tx_adapter.h +++ b/lib/eventdev/rte_event_eth_tx_adapter.h @@ -37,6 +37,8 @@ * - rte_event_eth_tx_adapter_instance_get() * - rte_event_eth_tx_adapter_queue_start() * - rte_event_eth_tx_adapter_queue_stop() + * - rte_event_eth_tx_adapter_runtime_params_get() + * - rte_event_eth_tx_adapter_runtime_params_set() * * The application creates the adapter using * rte_event_eth_tx_adapter_create() or rte_event_eth_tx_adapter_create_ext(). @@ -103,6 +105,33 @@ struct rte_event_eth_tx_adapter_conf { */ }; +#define TXA_FLUSH_THRESHOLD 1024 +/**< The default value of flush threshold for service + * based adapter. + */ + +#define TXA_MAX_NB_TX 128 +/**< The default value for maximum number of packets processed by service + * based adapter per each call. + */ + +/** + * Adapter runtime configuration parameters + */ +struct rte_event_eth_tx_adapter_runtime_params { + uint32_t max_nb_tx; + /**< The adapter can return early if it has processed at least + * max_nb_tx mbufs. This isn't treated as a requirement; batching may + * cause the adapter to process more than max_nb_tx mbufs. + */ + uint16_t flush_threshold; + /**< the number of service function iteration count to + * flush buffered packets. + */ + uint16_t rsvd[29]; + /**< Reserved fields for future expansion */ +}; + /** * Function type used for adapter configuration callback. The callback is * used to fill in members of the struct rte_event_eth_tx_adapter_conf, this @@ -516,6 +545,80 @@ __rte_experimental int rte_event_eth_tx_adapter_queue_stop(uint16_t eth_dev_id, uint16_t tx_queue_id); +/** + * Initialize the adapter runtime configuration parameters with default values + * + * @param txa_params + * A pointer to structure of type struct rte_event_eth_tx_adapter_runtime_params + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +static inline int +rte_event_eth_tx_adapter_runtime_params_init( + struct rte_event_eth_tx_adapter_runtime_params *txa_params) +{ + if (txa_params == NULL) + return -EINVAL; + + memset(txa_params, 0, sizeof(*txa_params)); + txa_params->max_nb_tx = TXA_MAX_NB_TX; + txa_params->flush_threshold = TXA_FLUSH_THRESHOLD; + + return 0; +} + +/** + * Set the runtime configuration parameters for adapter. + * + * In case not all fields are to be updated, the suggested way to use this + * api is read the current values using rte_event_eth_tx_adapter_get_params(), + * modify the required parameters and then call + * rte_event_eth_tx_adapter_runtime_params_set(). + * + * This API is to be used after adding at least one queue to the adapter + * and is supported only for service based adapter. + * + * @param id + * Adapter identifier + * @param params + * A pointer to structure of type struct rte_event_eth_tx_adapter_runtime_params + * with configuration parameter values. This structure can be initialized using + * rte_event_eth_tx_adapter_runtime_params_init() API to default values or + * application may reset this structure and update required fields. + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +int +rte_event_eth_tx_adapter_runtime_params_set(uint8_t id, + struct rte_event_eth_tx_adapter_runtime_params *params); + +/** + * Get the runtime configuration parameters of adapter. + * + * This API is to be used after adding at least one queue to the adapter + * and is supported only for service based adapter. + * + * @param id + * Adapter identifier + * @param[out] params + * A pointer to structure of type struct rte_event_eth_tx_adapter_runtime_params + * containing valid Tx adapter parameters when return value is 0. + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +int +rte_event_eth_tx_adapter_runtime_params_get(uint8_t id, + struct rte_event_eth_tx_adapter_runtime_params *params); + #ifdef __cplusplus } #endif diff --git a/lib/eventdev/version.map b/lib/eventdev/version.map index da97db794f..38dfbb1f41 100644 --- a/lib/eventdev/version.map +++ b/lib/eventdev/version.map @@ -123,6 +123,8 @@ EXPERIMENTAL { # added in 23.03 rte_event_eth_rx_adapter_runtime_params_get; rte_event_eth_rx_adapter_runtime_params_set; + rte_event_eth_tx_adapter_runtime_params_get; + rte_event_eth_tx_adapter_runtime_params_set; rte_event_timer_remaining_ticks_get; }; From patchwork Fri Feb 10 04:58:16 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Naga Harish K, S V" X-Patchwork-Id: 123654 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 759F941C5A; Fri, 10 Feb 2023 05:58:36 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id B87BA410D0; Fri, 10 Feb 2023 05:58:28 +0100 (CET) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by mails.dpdk.org (Postfix) with ESMTP id 870B342D0B for ; Fri, 10 Feb 2023 05:58:26 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1676005106; x=1707541106; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=jES3YDya+3gVvNmldP1iaAga2uiktuX8JhFIz03KR80=; b=HCypXpP8/AVGzpkcCkPMKhncxtf8GKOTrLDMqUNV2gPg0oqrhkvYdw+n 80W3Zs7gvLWi6pRFR3jMiIYOy3xDn3iXWIDl9M5qXPi7Xut3xLQyHX2or GZAdYIMJW40SCuAI5zms98Lr+p8lV0EsEnCbloLmMCQfwVUyw6ye/e95+ i6JH9tmxNR2+5BePRpTLXZZh0nGmg+YnIq/aX+ZiSSoTSY3aP+cJo/Ch8 w8OxZKyCcDu3zvbJ9Amd0gAC+dPPXDmF+caJwl5bi/iakGU1sSPshcO/f Llsrl7B/HJwg0U6XQpymZGxauSRGkYZTU6RQSuy6tNeHAKyW/tIueCY1O Q==; X-IronPort-AV: E=McAfee;i="6500,9779,10616"; a="318354297" X-IronPort-AV: E=Sophos;i="5.97,285,1669104000"; d="scan'208";a="318354297" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Feb 2023 20:58:26 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6500,9779,10616"; a="841912888" X-IronPort-AV: E=Sophos;i="5.97,285,1669104000"; d="scan'208";a="841912888" Received: from txandevlnx322.an.intel.com ([10.123.117.44]) by orsmga005.jf.intel.com with ESMTP; 09 Feb 2023 20:58:25 -0800 From: Naga Harish K S V To: jerinj@marvell.com, erik.g.carrillo@intel.com, abhinandan.gujjar@intel.com Cc: dev@dpdk.org, jay.jayatheerthan@intel.com Subject: [PATCH v4 3/3] eventdev/crypto: add params set/get APIs Date: Thu, 9 Feb 2023 22:58:16 -0600 Message-Id: <20230210045816.3039312-3-s.v.naga.harish.k@intel.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20230210045816.3039312-1-s.v.naga.harish.k@intel.com> References: <20230123180458.486189-1-s.v.naga.harish.k@intel.com> <20230210045816.3039312-1-s.v.naga.harish.k@intel.com> MIME-Version: 1.0 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 The adapter runtime configuration parameters defined in the ``struct rte_event_crypto_adapter_runtime_params`` can be configured and retrieved using ``rte_event_crypto_adapter_runtime_params_set`` and ``rte_event_eth_rx_adapter_runtime_params_get`` respectively. Signed-off-by: Naga Harish K S V --- app/test/test_event_crypto_adapter.c | 109 ++++++++++++++++++ .../prog_guide/event_crypto_adapter.rst | 11 ++ lib/eventdev/rte_event_crypto_adapter.c | 89 +++++++++++++- lib/eventdev/rte_event_crypto_adapter.h | 90 +++++++++++++++ lib/eventdev/version.map | 2 + 5 files changed, 300 insertions(+), 1 deletion(-) diff --git a/app/test/test_event_crypto_adapter.c b/app/test/test_event_crypto_adapter.c index a38e389abd..264d6f731e 100644 --- a/app/test/test_event_crypto_adapter.c +++ b/app/test/test_event_crypto_adapter.c @@ -272,6 +272,111 @@ test_crypto_adapter_stats(void) return TEST_SUCCESS; } +static int +test_crypto_adapter_params(void) +{ + int err; + struct rte_event_crypto_adapter_runtime_params in_params; + struct rte_event_crypto_adapter_runtime_params out_params; + uint32_t cap; + struct rte_event_crypto_adapter_queue_conf queue_conf = { + .ev = response_info, + }; + + err = rte_event_crypto_adapter_caps_get(evdev, TEST_CDEV_ID, &cap); + TEST_ASSERT_SUCCESS(err, "Failed to get adapter capabilities\n"); + + if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) { + err = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, + TEST_CDEV_ID, TEST_CDEV_QP_ID, &queue_conf); + } else + err = rte_event_crypto_adapter_queue_pair_add(TEST_ADAPTER_ID, + TEST_CDEV_ID, TEST_CDEV_QP_ID, NULL); + + TEST_ASSERT_SUCCESS(err, "Failed to add queue pair\n"); + + err = rte_event_crypto_adapter_runtime_params_init(&in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + err = rte_event_crypto_adapter_runtime_params_init(&out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + /* Case 1: Get the default value of mbufs processed by adapter */ + err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + /* Case 2: Set max_nb = 32 (=BATCH_SEIZE) */ + in_params.max_nb = 32; + + err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", + in_params.max_nb, out_params.max_nb); + + /* Case 3: Set max_nb = 192 */ + in_params.max_nb = 192; + + err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", + in_params.max_nb, out_params.max_nb); + + /* Case 4: Set max_nb = 256 */ + in_params.max_nb = 256; + + err = rte_event_crypto_adapter_runtime_params_set(TEST_ADAPTER_ID, + &in_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_crypto_adapter_runtime_params_get(TEST_ADAPTER_ID, + &out_params); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT(in_params.max_nb == out_params.max_nb, "Expected %u got %u", + in_params.max_nb, out_params.max_nb); + + /* Case 5: Set max_nb = 30(nb_qps) + return -EINVAL; + ret = rte_event_crypto_adapter_caps_get(adapter->eventdev_id, + adapter->next_cdev_id, + &caps); + if (ret) { + RTE_EDEV_LOG_ERR("Failed to get adapter caps dev %" PRIu8 + " cdev %" PRIu8, adapter->eventdev_id, + adapter->next_cdev_id); + return ret; + } + + if ((caps & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) || + (caps & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) + return -ENOTSUP; + + return 0; +} + +int +rte_event_crypto_adapter_runtime_params_set(uint8_t id, + struct rte_event_crypto_adapter_runtime_params *params) +{ + struct event_crypto_adapter *adapter; + int ret; + + if (eca_memzone_lookup()) + return -ENOMEM; + + EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL); + + if (params == NULL) { + RTE_EDEV_LOG_ERR("params pointer is NULL\n"); + return -EINVAL; + } + + adapter = eca_id_to_adapter(id); + if (adapter == NULL) + return -EINVAL; + + ret = crypto_adapter_cap_check(adapter); + if (ret) + return ret; + + rte_spinlock_lock(&adapter->lock); + adapter->max_nb = params->max_nb; + rte_spinlock_unlock(&adapter->lock); + + return 0; +} + +int +rte_event_crypto_adapter_runtime_params_get(uint8_t id, + struct rte_event_crypto_adapter_runtime_params *params) +{ + struct event_crypto_adapter *adapter; + int ret; + + if (eca_memzone_lookup()) + return -ENOMEM; + + + EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL); + + if (params == NULL) { + RTE_EDEV_LOG_ERR("params pointer is NULL\n"); + return -EINVAL; + } + + adapter = eca_id_to_adapter(id); + if (adapter == NULL) + return -EINVAL; + + ret = crypto_adapter_cap_check(adapter); + if (ret) + return ret; + + params->max_nb = adapter->max_nb; + + return 0; +} + int rte_event_crypto_adapter_service_id_get(uint8_t id, uint32_t *service_id) { diff --git a/lib/eventdev/rte_event_crypto_adapter.h b/lib/eventdev/rte_event_crypto_adapter.h index fad4543506..106e83102f 100644 --- a/lib/eventdev/rte_event_crypto_adapter.h +++ b/lib/eventdev/rte_event_crypto_adapter.h @@ -138,6 +138,8 @@ * - rte_event_crypto_adapter_stop() * - rte_event_crypto_adapter_stats_get() * - rte_event_crypto_adapter_stats_reset() + * - rte_event_crypto_adapter_runtime_params_get() + * - rte_event_crypto_adapter_runtime_params_set() * The application creates an instance using rte_event_crypto_adapter_create() * or rte_event_crypto_adapter_create_ext(). @@ -253,6 +255,24 @@ struct rte_event_crypto_adapter_conf { */ }; +#define DEFAULT_MAX_NB 128 +/**< The default value for maximum number of packets processed by service + * based adapter per each call. + */ + +/** + * Adapter runtime configuration parameters + */ +struct rte_event_crypto_adapter_runtime_params { + uint32_t max_nb; + /**< The adapter can return early if it has processed at least + * max_nb crypto ops. This isn't treated as a requirement; batching + * may cause the adapter to process more than max_nb crypto ops. + */ + uint32_t rsvd[15]; + /**< Reserved fields for future expansion */ +}; + #define RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR 0x1 /**< This flag indicates that crypto operations processed on the crypto * adapter need to be vectorized @@ -608,6 +628,76 @@ rte_event_crypto_adapter_service_id_get(uint8_t id, uint32_t *service_id); int rte_event_crypto_adapter_event_port_get(uint8_t id, uint8_t *event_port_id); +/** + * Initialize the adapter runtime configuration parameters + * + * @param params + * A pointer to structure of type struct rte_event_crypto_adapter_runtime_params + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +static inline int +rte_event_crypto_adapter_runtime_params_init( + struct rte_event_crypto_adapter_runtime_params *params) +{ + if (params == NULL) + return -EINVAL; + + memset(params, 0, sizeof(*params)); + params->max_nb = DEFAULT_MAX_NB; + + return 0; +} + +/** + * Set the adapter runtime configuration parameters + * + * This API needs to be called after adding at least one qp to the adapter + * and is supported only for the service-based adapter. + * + * @param id + * Adapter identifier + * + * @param params + * A pointer to structure of type struct rte_event_crypto_adapter_runtime_params + * with configuration parameter values. This struct can be initialized using + * rte_event_crypto_adapter_runtime_params_init() API to default values or + * application may reset this struct and update required fields. + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +int +rte_event_crypto_adapter_runtime_params_set(uint8_t id, + struct rte_event_crypto_adapter_runtime_params *params); + +/** + * Get the adapter runtime configuration parameters + * + * This API needs to be called after adding at least one qp to the adapter + * and is supported only for the service-based adapter. + * + * @param id + * Adapter identifier + * + * @param[out] params + * A pointer to structure of type struct rte_event_crypto_adapter_runtime_params + * containing valid adapter parameters when return value is 0. + * + * @return + * - 0: Success + * - <0: Error code on failure + */ +__rte_experimental +int +rte_event_crypto_adapter_runtime_params_get(uint8_t id, + struct rte_event_crypto_adapter_runtime_params *params); + /** * @warning * @b EXPERIMENTAL: this API may change without prior notice diff --git a/lib/eventdev/version.map b/lib/eventdev/version.map index 38dfbb1f41..60e5e3a593 100644 --- a/lib/eventdev/version.map +++ b/lib/eventdev/version.map @@ -121,6 +121,8 @@ EXPERIMENTAL { rte_event_eth_tx_adapter_queue_stop; # added in 23.03 + rte_event_crypto_adapter_runtime_params_get; + rte_event_crypto_adapter_runtime_params_set; rte_event_eth_rx_adapter_runtime_params_get; rte_event_eth_rx_adapter_runtime_params_set; rte_event_eth_tx_adapter_runtime_params_get;