Hi Jay,
Patch is split into 7 patch sets in V5 as suggested.
Thanks,
Ganapati
> -----Original Message-----
> From: Jayatheerthan, Jay <jay.jayatheert...@intel.com>
> Sent: 07 June 2022 18:49
> To: Kundapura, Ganapati <ganapati.kundap...@intel.com>;
> jerinjac...@gmail.com; dev@dpdk.org
> Subject: RE: [PATCH v3] eventdev: add adapter instance get API
>
> Hi Ganapati,
> This patch could be split into multiple patches in a patchset to make it
> easier
> to review.
>
> One way to split:
> 1. Rx adapter API
> 2. Telemetry changes for Rx adapter
> 3. Test changes for Rx adapter API
> 4. Tx adapter API
> 5. Telemetry changes for Tx adapter ?
> 6. Test changes for Tx adapter API
> 7. Document update.
>
> -Jay
>
>
> > -----Original Message-----
> > From: Kundapura, Ganapati <ganapati.kundap...@intel.com>
> > Sent: Tuesday, June 7, 2022 1:51 PM
> > To: jerinjac...@gmail.com; dev@dpdk.org; Jayatheerthan, Jay
> > <jay.jayatheert...@intel.com>
> > Subject: [PATCH v3] eventdev: add adapter instance get API
> >
> > Added rte_event_eth_rx_adapter_instance_get() and
> > rte_event_eth_tx_adapter_instance_get() api's to get the adapter
> > instance id for a specified event port and queue index.
> >
> > Signed-off-by: Ganapati Kundapura <ganapati.kundap...@intel.com>
> > ---
> > v3:
> > * Fixed checkpatch error
> >
> > v2:
> > * Fixed build issues
> > * Added telemetry support for rte_event_eth_rx_adapter_instance_get
> > * arranged functions in alphabetical order in version.map
> >
> > diff --git a/app/test/test_event_eth_rx_adapter.c
> > b/app/test/test_event_eth_rx_adapter.c
> > index e358a70..878004b 100644
> > --- a/app/test/test_event_eth_rx_adapter.c
> > +++ b/app/test/test_event_eth_rx_adapter.c
> > @@ -39,6 +39,7 @@ test_event_eth_rx_intr_adapter_common(void)
> > #define TEST_INST_ID 0
> > #define TEST_DEV_ID 0
> > #define TEST_ETHDEV_ID 0
> > +#define TEST_ETH_QUEUE_ID 0
> >
> > struct event_eth_rx_adapter_test_params {
> > struct rte_mempool *mp;
> > @@ -1001,6 +1002,87 @@ adapter_queue_conf(void)
> > return TEST_SUCCESS;
> > }
> >
> > +static int
> > +adapter_instance_get(void)
> > +{
> > + int err;
> > + uint8_t inst_id;
> > + uint16_t eth_dev_id;
> > + struct rte_eth_dev_info dev_info;
> > + struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
> > +
> > + /* Case 1: Test without configuring eth */
> > + err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Case 2: Test with wrong eth port */
> > + eth_dev_id = rte_eth_dev_count_total() + 1;
> > + err = rte_event_eth_rx_adapter_instance_get(eth_dev_id,
> > + TEST_ETH_QUEUE_ID,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Case 3: Test with wrong rx queue */
> > + err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
> > + dev_info.max_rx_queues +
> 1,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Case 4: Test with right instance, port & rxq */
> > + /* Add queue to Rx adapter */
> > + queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID;
> > + queue_conf.ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
> > + queue_conf.ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
> > +
> > + err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID,
> > + &queue_conf);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID,
> > + &inst_id);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + /* Add another queue */
> > + queue_conf.ev.queue_id = TEST_ETH_QUEUE_ID + 1;
> > + err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 1,
> > + &queue_conf);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 1,
> > + &inst_id);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + /* Case 5: Test with right instance, port & wrong rxq */
> > + err = rte_event_eth_rx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 2,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Delete queues from the Rx adapter */
> > + err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 1);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + return TEST_SUCCESS;
> > +}
> > +
> > static struct unit_test_suite event_eth_rx_tests = {
> > .suite_name = "rx event eth adapter test suite",
> > .setup = testsuite_setup,
> > @@ -1019,6 +1101,8 @@ static struct unit_test_suite event_eth_rx_tests =
> {
> > adapter_queue_event_buf_test),
> > TEST_CASE_ST(adapter_create_with_params, adapter_free,
> > adapter_queue_stats_test),
> > + TEST_CASE_ST(adapter_create, adapter_free,
> > + adapter_instance_get),
> > TEST_CASES_END() /**< NULL terminate unit test array */
> > }
> > };
> > diff --git a/app/test/test_event_eth_tx_adapter.c
> > b/app/test/test_event_eth_tx_adapter.c
> > index 2900532..ebbc622 100644
> > --- a/app/test/test_event_eth_tx_adapter.c
> > +++ b/app/test/test_event_eth_tx_adapter.c
> > @@ -29,6 +29,7 @@ test_event_eth_tx_adapter_common(void)
> > #define MAX_NUM_QUEUE RTE_PMD_RING_MAX_RX_RINGS
> > #define TEST_INST_ID 0
> > #define TEST_DEV_ID 0
> > +#define TEST_ETH_QUEUE_ID 0
> > #define SOCKET0 0
> > #define RING_SIZE 256
> > #define ETH_NAME_LEN 32
> > @@ -639,6 +640,79 @@ tx_adapter_service(void) }
> >
> > static int
> > +tx_adapter_instance_get(void)
> > +{
> > + int err;
> > + uint8_t inst_id;
> > + uint16_t eth_dev_id;
> > + struct rte_eth_dev_info dev_info;
> > +
> > + /* Case 1: Test without configuring eth */
> > + err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Case 2: Test with wrong eth port */
> > + eth_dev_id = rte_eth_dev_count_total() + 1;
> > + err = rte_event_eth_tx_adapter_instance_get(eth_dev_id,
> > + TEST_ETH_QUEUE_ID,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Case 3: Test with wrong tx queue */
> > + err = rte_eth_dev_info_get(TEST_ETHDEV_ID, &dev_info);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
> > + dev_info.max_tx_queues +
> 1,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Case 4: Test with right instance, port & rxq */
> > + /* Add queue to tx adapter */
> > + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID,
> > + &inst_id);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + /* Add another queue to tx adapter */
> > + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 1);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 1,
> > + &inst_id);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + /* Case 5: Test with right instance, port & wrong rxq */
> > + err = rte_event_eth_tx_adapter_instance_get(TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 2,
> > + &inst_id);
> > + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
> > +
> > + /* Delete queues from the Tx adapter */
> > + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID,
> > + TEST_ETHDEV_ID,
> > + TEST_ETH_QUEUE_ID + 1);
> > + TEST_ASSERT(err == 0, "Expected 0 got %d", err);
> > +
> > + return TEST_SUCCESS;
> > +}
> > +
> > +static int
> > tx_adapter_dynamic_device(void)
> > {
> > uint16_t port_id = rte_eth_dev_count_avail(); @@ -695,6 +769,8
> @@
> > static struct unit_test_suite event_eth_tx_tests = {
> > tx_adapter_start_stop),
> > TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
> > tx_adapter_service),
> > + TEST_CASE_ST(tx_adapter_create, tx_adapter_free,
> > + tx_adapter_instance_get),
> > TEST_CASE_ST(NULL, NULL, tx_adapter_dynamic_device),
> > TEST_CASES_END() /**< NULL terminate unit test array */
> > }
> > diff --git a/doc/guides/prog_guide/event_ethernet_rx_adapter.rst
> > b/doc/guides/prog_guide/event_ethernet_rx_adapter.rst
> > index 3b4ef50..a6d8987 100644
> > --- a/doc/guides/prog_guide/event_ethernet_rx_adapter.rst
> > +++ b/doc/guides/prog_guide/event_ethernet_rx_adapter.rst
> > @@ -177,6 +177,12 @@ used otherwise it returns -EINVAL.
> > The ``rte_event_eth_rx_adapter_queue_stats_reset`` function can be
> > used to reset queue level stats when queue level event buffer is in use.
> >
> > +Getting Adapter instance id
> > +~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > +
> > +The ``rte_event_eth_rx_adapter_instance_get()`` function reports rx
> > +adapter instance id for a specified event port and rx queue index.
> > +
> > Interrupt Based Rx Queues
> > ~~~~~~~~~~~~~~~~~~~~~~~~~~
> >
> > diff --git a/doc/guides/prog_guide/event_ethernet_tx_adapter.rst
> > b/doc/guides/prog_guide/event_ethernet_tx_adapter.rst
> > index f80d226..b14131d 100644
> > --- a/doc/guides/prog_guide/event_ethernet_tx_adapter.rst
> > +++ b/doc/guides/prog_guide/event_ethernet_tx_adapter.rst
> > @@ -165,6 +165,12 @@ in struct ``rte_event_eth_tx_adapter_stats``. The
> > counter values are the sum of the counts from the eventdev PMD
> > callback if the callback is supported, and the counts maintained by the
> service function, if one exists.
> >
> > +Getting Adapter instance id
> > +~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > +
> > +The ``rte_event_eth_tx_adapter_instanceget()`` function reports tx
> > +adapter instance id for a specified event port and tx queue index.
> > +
> > Tx event vectorization
> > ~~~~~~~~~~~~~~~~~~~~~~
> >
> > diff --git a/lib/eventdev/rte_event_eth_rx_adapter.c
> > b/lib/eventdev/rte_event_eth_rx_adapter.c
> > index bf8741d..3095647 100644
> > --- a/lib/eventdev/rte_event_eth_rx_adapter.c
> > +++ b/lib/eventdev/rte_event_eth_rx_adapter.c
> > @@ -6,6 +6,7 @@
> > #include <sys/epoll.h>
> > #endif
> > #include <unistd.h>
> > +#include <limits.h>
> >
> > #include <rte_cycles.h>
> > #include <rte_common.h>
> > @@ -42,7 +43,10 @@
> > /* Sentinel value to detect initialized file handle */
> > #define INIT_FD -1
> >
> > -#define RXA_ADAPTER_ARRAY "rte_event_eth_rx_adapter_array"
> > +#define RX_ADAPTER_DATA_ARRAY "rx_adapter_data_array"
> > +#define RX_ADAPTER_INSTANCE_ARRAY "rx_adapter_instance_array"
> > +
> > +#define INVALID_INSTANCE_ID UINT8_MAX
> >
> > /*
> > * Used to store port and queue ID of interrupting Rx queue @@ -251,7
> > +255,12 @@ struct eth_rx_queue_info {
> > struct rte_event_eth_rx_adapter_stats *stats; };
> >
> > +struct event_eth_rxa_inst_info {
> > + uint8_t rxa_inst_id;
> > +};
> > +
> > static struct event_eth_rx_adapter **event_eth_rx_adapter;
> > +static struct event_eth_rxa_inst_info **event_eth_rxa_inst_info;
> >
> > /* Enable dynamic timestamp field in mbuf */ static uint64_t
> > event_eth_rx_timestamp_dynflag; @@ -1415,15 +1424,13 @@
> > rxa_service_func(void *args)
> > return 0;
> > }
> >
> > -static int
> > -rte_event_eth_rx_adapter_init(void)
> > +static void *
> > +rxa_memzone_array_get(const char *name, unsigned int elt_size, int
> > +nb_elems)
> > {
> > - const char *name = RXA_ADAPTER_ARRAY;
> > const struct rte_memzone *mz;
> > unsigned int sz;
> >
> > - sz = sizeof(*event_eth_rx_adapter) *
> > - RTE_EVENT_ETH_RX_ADAPTER_MAX_INSTANCE;
> > + sz = elt_size * nb_elems;
> > sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
> >
> > mz = rte_memzone_lookup(name);
> > @@ -1431,13 +1438,46 @@ rte_event_eth_rx_adapter_init(void)
> > mz = rte_memzone_reserve_aligned(name, sz,
> rte_socket_id(), 0,
> > RTE_CACHE_LINE_SIZE);
> > if (mz == NULL) {
> > - RTE_EDEV_LOG_ERR("failed to reserve memzone err
> = %"
> > - PRId32, rte_errno);
> > - return -rte_errno;
> > + RTE_EDEV_LOG_ERR("failed to reserve memzone"
> > + " name = %s, err = %"
> > + PRId32, name, rte_errno);
> > + return NULL;
> > }
> > }
> >
> > - event_eth_rx_adapter = mz->addr;
> > + return mz->addr;
> > +}
> > +
> > +static int
> > +rte_event_eth_rx_adapter_init(void)
> > +{
> > + uint8_t i;
> > +
> > + if (event_eth_rx_adapter == NULL) {
> > + event_eth_rx_adapter =
> > +
> rxa_memzone_array_get(RX_ADAPTER_DATA_ARRAY,
> > + sizeof(*event_eth_rx_adapter),
> > +
> RTE_EVENT_ETH_RX_ADAPTER_MAX_INSTANCE);
> > + if (event_eth_rx_adapter == NULL)
> > + return -ENOMEM;
> > +
> > + for (i = 0; i <
> RTE_EVENT_ETH_RX_ADAPTER_MAX_INSTANCE; i++)
> > + event_eth_rx_adapter[i] = NULL;
> > +
> > + }
> > +
> > + if (event_eth_rxa_inst_info == NULL) {
> > + event_eth_rxa_inst_info =
> > +
> rxa_memzone_array_get(RX_ADAPTER_INSTANCE_ARRAY,
> > + sizeof(*event_eth_rxa_inst_info),
> > + RTE_MAX_ETHPORTS);
> > + if (event_eth_rxa_inst_info == NULL)
> > + return -ENOMEM;
> > +
> > + for (i = 0; i < RTE_MAX_ETHPORTS; i++)
> > + event_eth_rxa_inst_info[i] = NULL;
> > + }
> > +
> > return 0;
> > }
> >
> > @@ -1447,12 +1487,21 @@ rxa_memzone_lookup(void)
> > const struct rte_memzone *mz;
> >
> > if (event_eth_rx_adapter == NULL) {
> > - mz = rte_memzone_lookup(RXA_ADAPTER_ARRAY);
> > + mz = rte_memzone_lookup(RX_ADAPTER_DATA_ARRAY);
> > if (mz == NULL)
> > return -ENOMEM;
> > +
> > event_eth_rx_adapter = mz->addr;
> > }
> >
> > + if (event_eth_rxa_inst_info == NULL) {
> > + mz =
> rte_memzone_lookup(RX_ADAPTER_INSTANCE_ARRAY);
> > + if (mz == NULL)
> > + return -ENOMEM;
> > +
> > + event_eth_rxa_inst_info = mz->addr;
> > + }
> > +
> > return 0;
> > }
> >
> > @@ -1950,6 +1999,7 @@ rxa_sw_del(struct event_eth_rx_adapter
> *rx_adapter,
> > int pollq;
> > int intrq;
> > int sintrq;
> > + uint16_t eth_dev_id = dev_info->dev->data->port_id;
> >
> >
> > if (rx_adapter->nb_queues == 0)
> > @@ -1993,6 +2043,11 @@ rxa_sw_del(struct event_eth_rx_adapter
> *rx_adapter,
> > dev_info->rx_queue[rx_queue_id].event_buf = NULL;
> > dev_info->rx_queue[rx_queue_id].stats = NULL;
> > }
> > +
> > + /* unset rxa_inst_id for rx_queue_id */
> > + if (event_eth_rxa_inst_info[eth_dev_id])
> > +
> event_eth_rxa_inst_info[eth_dev_id][rx_queue_id].rxa_inst_id =
> > +
> INVALID_INSTANCE_ID;
> > }
> >
> > static int
> > @@ -2085,6 +2140,33 @@ rxa_add_queue(struct event_eth_rx_adapter
> *rx_adapter,
> > }
> > }
> >
> > + /* Allocate storage to store rxa_inst_id for rxq */
> > + if (event_eth_rxa_inst_info[eth_dev_id] == NULL) {
> > + uint16_t n, i;
> > + struct event_eth_rxa_inst_info *i_info;
> > +
> > + n = rte_eth_devices[eth_dev_id].data->nb_rx_queues;
> > +
> > + i_info = rte_zmalloc_socket("event_eth_rxa_inst_info",
> > + n * sizeof(struct event_eth_rxa_inst_info),
> > + 0,
> > + rx_adapter->socket_id);
> > + if (i_info == NULL) {
> > + RTE_EDEV_LOG_ERR("Failed to allocate storage for "
> > + "event_eth_rxa_inst_info");
> > + return -ENOMEM;
> > + }
> > +
> > + for (i = 0; i < n; i++)
> > + i_info[i].rxa_inst_id = INVALID_INSTANCE_ID;
> > +
> > + event_eth_rxa_inst_info[eth_dev_id] = i_info;
> > + }
> > +
> > + /* store rxa id for rx_queue_id in event_eth_rxa_inst_info */
> > + event_eth_rxa_inst_info[eth_dev_id][rx_queue_id].rxa_inst_id =
> > + rx_adapter-
> >id;
> > +
> > if (!rx_adapter->use_queue_event_buf)
> > return 0;
> >
> > @@ -2523,6 +2605,10 @@ int
> > rte_event_eth_rx_adapter_free(uint8_t id) {
> > struct event_eth_rx_adapter *rx_adapter;
> > + uint16_t eth_dev_id;
> > +
> > + if (rxa_memzone_lookup())
> > + return -ENOMEM;
> >
> > RTE_EVENT_ETH_RX_ADAPTER_ID_VALID_OR_ERR_RET(id, -
> EINVAL);
> >
> > @@ -2544,6 +2630,13 @@ rte_event_eth_rx_adapter_free(uint8_t id)
> > rte_free(rx_adapter);
> > event_eth_rx_adapter[id] = NULL;
> >
> > + for (eth_dev_id = 0; eth_dev_id < RTE_MAX_ETHPORTS;
> eth_dev_id++) {
> > + if (event_eth_rxa_inst_info[eth_dev_id]) {
> > + rte_free(event_eth_rxa_inst_info[eth_dev_id]);
> > + event_eth_rxa_inst_info[eth_dev_id] = NULL;
> > + }
> > + }
> > +
> > rte_eventdev_trace_eth_rx_adapter_free(id);
> > return 0;
> > }
> > @@ -2561,6 +2654,9 @@ rte_event_eth_rx_adapter_queue_add(uint8_t
> id,
> > struct eth_device_info *dev_info;
> > struct rte_event_eth_rx_adapter_vector_limits limits;
> >
> > + if (rxa_memzone_lookup())
> > + return -ENOMEM;
> > +
> > RTE_EVENT_ETH_RX_ADAPTER_ID_VALID_OR_ERR_RET(id, -
> EINVAL);
> > RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_dev_id, -EINVAL);
> >
> > @@ -2726,6 +2822,9 @@ rte_event_eth_rx_adapter_queue_del(uint8_t
> id, uint16_t eth_dev_id,
> > uint32_t *rx_wrr = NULL;
> > int num_intr_vec;
> >
> > + if (rxa_memzone_lookup())
> > + return -ENOMEM;
> > +
> > RTE_EVENT_ETH_RX_ADAPTER_ID_VALID_OR_ERR_RET(id, -
> EINVAL);
> > RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_dev_id, -EINVAL);
> >
> > @@ -2832,6 +2931,7 @@ rte_event_eth_rx_adapter_queue_del(uint8_t
> id,
> > uint16_t eth_dev_id,
> >
> > rte_eventdev_trace_eth_rx_adapter_queue_del(id, eth_dev_id,
> > rx_queue_id, ret);
> > +
> > return ret;
> > }
> >
> > @@ -3286,6 +3386,49 @@
> rte_event_eth_rx_adapter_queue_conf_get(uint8_t id,
> > return 0;
> > }
> >
> > +int
> > +rte_event_eth_rx_adapter_instance_get(uint16_t eth_dev_id,
> > + uint16_t rx_queue_id,
> > + uint8_t *rxa_inst_id)
> > +{
> > + uint8_t inst_id;
> > +
> > + if (rxa_memzone_lookup())
> > + return -ENOMEM;
> > +
> > + if (eth_dev_id >= rte_eth_dev_count_avail()) {
> > + RTE_EDEV_LOG_ERR("Invalid ethernet port id %u",
> eth_dev_id);
> > + return -EINVAL;
> > + }
> > +
> > + if (rx_queue_id >= rte_eth_devices[eth_dev_id].data-
> >nb_rx_queues) {
> > + RTE_EDEV_LOG_ERR("Invalid Rx queue %u", rx_queue_id);
> > + return -EINVAL;
> > + }
> > +
> > + if (rxa_inst_id == NULL) {
> > + RTE_EDEV_LOG_ERR("rxa_inst_id cannot be NULL");
> > + return -EINVAL;
> > + }
> > +
> > + if (event_eth_rxa_inst_info[eth_dev_id] == NULL) {
> > + RTE_EDEV_LOG_ERR("No valid rxa instance for eth_dev_id
> %u",
> > + eth_dev_id);
> > + return -EINVAL;
> > + }
> > +
> > + inst_id =
> event_eth_rxa_inst_info[eth_dev_id][rx_queue_id].rxa_inst_id;
> > + if (inst_id == INVALID_INSTANCE_ID) {
> > + RTE_EDEV_LOG_ERR("Invalid rxa instance for eth_dev_id
> %u, "
> > + "rx_queue_id %u", eth_dev_id,
> rx_queue_id);
> > + return -EINVAL;
> > + }
> > +
> > + *rxa_inst_id = inst_id;
> > +
> > + return 0;
> > +}
> > +
> > #define RXA_ADD_DICT(stats, s) rte_tel_data_add_dict_u64(d, #s,
> > stats.s)
> >
> > static int
> > @@ -3554,6 +3697,68 @@ handle_rxa_queue_stats_reset(const char
> *cmd __rte_unused,
> > return ret;
> > }
> >
> > +static int
> > +handle_rxa_instance_get(const char *cmd __rte_unused,
> > + const char *params,
> > + struct rte_tel_data *d)
> > +{
> > + uint8_t instance_id;
> > + uint16_t rx_queue_id;
> > + int eth_dev_id, ret = -1;
> > + char *token, *l_params;
> > +
> > + if (params == NULL || strlen(params) == 0 || !isdigit(*params))
> > + return -1;
> > +
> > + l_params = strdup(params);
> > + if (l_params == NULL)
> > + return -ENOMEM;
> > + token = strtok(l_params, ",");
> > +
> RTE_EVENT_ETH_RX_ADAPTER_TOKEN_VALID_OR_GOTO_ERR_RET(
> token, -1);
> > +
> > + /* Get device ID from parameter string */
> > + eth_dev_id = strtoul(token, NULL, 10);
> > + RTE_ETH_VALID_PORTID_OR_GOTO_ERR_RET(eth_dev_id, -
> EINVAL);
> > +
> > + token = strtok(NULL, ",");
> > +
> RTE_EVENT_ETH_RX_ADAPTER_TOKEN_VALID_OR_GOTO_ERR_RET(
> token, -1);
> > +
> > + /* Get Rx queue ID from parameter string */
> > + rx_queue_id = strtoul(token, NULL, 10);
> > + if (rx_queue_id >= rte_eth_devices[eth_dev_id].data-
> >nb_rx_queues) {
> > + RTE_EDEV_LOG_ERR("Invalid rx queue_id %u",
> rx_queue_id);
> > + ret = -EINVAL;
> > + goto error;
> > + }
> > +
> > + token = strtok(NULL, "\0");
> > + if (token != NULL)
> > + RTE_EDEV_LOG_ERR("Extra parameters passed to eventdev"
> > + " telemetry command, ignoring");
> > +
> > + /* Parsing parameter finished */
> > + free(l_params);
> > +
> > + if (rte_event_eth_rx_adapter_instance_get(eth_dev_id,
> > + rx_queue_id,
> > + &instance_id)) {
> > + RTE_EDEV_LOG_ERR("Failed to get RX adapter instance ID "
> > + " for rx_queue_id = %d", rx_queue_id);
> > + return -1;
> > + }
> > +
> > + rte_tel_data_start_dict(d);
> > + rte_tel_data_add_dict_u64(d, "eth_dev_id", eth_dev_id);
> > + rte_tel_data_add_dict_u64(d, "rx_queue_id", rx_queue_id);
> > + rte_tel_data_add_dict_u64(d, "rxa_instance_id", instance_id);
> > +
> > + return 0;
> > +
> > +error:
> > + free(l_params);
> > + return ret;
> > +}
> > +
> > RTE_INIT(rxa_init_telemetry)
> > {
> > rte_telemetry_register_cmd("/eventdev/rxa_stats",
> > @@ -3575,4 +3780,8 @@ RTE_INIT(rxa_init_telemetry)
> > rte_telemetry_register_cmd("/eventdev/rxa_queue_stats_reset",
> > handle_rxa_queue_stats_reset,
> > "Reset Rx queue stats. Parameter: rxa_id, dev_id,
> queue_id");
> > +
> > + rte_telemetry_register_cmd("/eventdev/rxa_rxq_instance_get",
> > + handle_rxa_instance_get,
> > + "Returns Rx adapter instance id. Parameter: dev_id,
> queue_id");
> > }
> > diff --git a/lib/eventdev/rte_event_eth_rx_adapter.h
> > b/lib/eventdev/rte_event_eth_rx_adapter.h
> > index 3608a7b..f56938d 100644
> > --- a/lib/eventdev/rte_event_eth_rx_adapter.h
> > +++ b/lib/eventdev/rte_event_eth_rx_adapter.h
> > @@ -38,6 +38,7 @@
> > * - rte_event_eth_rx_adapter_queue_stats_get()
> > * - rte_event_eth_rx_adapter_queue_stats_reset()
> > * - rte_event_eth_rx_adapter_event_port_get()
> > + * - rte_event_eth_rx_adapter_instance_get()
> > *
> > * The application creates an ethernet to event adapter using
> > * rte_event_eth_rx_adapter_create_ext() or
> > rte_event_eth_rx_adapter_create() @@ -704,6 +705,28 @@
> > __rte_experimental int
> > rte_event_eth_rx_adapter_event_port_get(uint8_t id, uint8_t
> > *event_port_id);
> >
> > +/**
> > + * Get RX adapter instance ID for a RX queue
> > + *
> > + * @param eth_dev_id
> > + * Port identifier of Ethernet device.
> > + *
> > + * @param rx_queue_id
> > + * Ethernet device receive queue index
> > + *
> > + * @param[out] rxa_inst_id
> > + * RX adapter instance identifier.
> > + *
> > + * @return
> > + * - 0: Success
> > + * - <0: Error code on failure
> > + */
> > +__rte_experimental
> > +int
> > +rte_event_eth_rx_adapter_instance_get(uint16_t eth_dev_id,
> > + uint16_t rx_queue_id,
> > + uint8_t *rxa_inst_id);
> > +
> > #ifdef __cplusplus
> > }
> > #endif
> > diff --git a/lib/eventdev/rte_event_eth_tx_adapter.c
> > b/lib/eventdev/rte_event_eth_tx_adapter.c
> > index 1b304f0..1c9f9fc 100644
> > --- a/lib/eventdev/rte_event_eth_tx_adapter.c
> > +++ b/lib/eventdev/rte_event_eth_tx_adapter.c
> > @@ -1,6 +1,8 @@
> > /* SPDX-License-Identifier: BSD-3-Clause
> > * Copyright(c) 2018 Intel Corporation.
> > */
> > +#include <limits.h>
> > +
> > #include <rte_spinlock.h>
> > #include <rte_service_component.h>
> > #include <ethdev_driver.h>
> > @@ -17,6 +19,11 @@
> > #define TXA_MAX_NB_TX 128
> > #define TXA_INVALID_DEV_ID INT32_C(-1)
> > #define TXA_INVALID_SERVICE_ID INT64_C(-1)
> > +#define INVALID_INSTANCE_ID UINT8_MAX
> > +
> > +#define TXA_ADAPTER_ARRAY "txa_adapter_array"
> > +#define TXA_SERVICE_DATA_ARRAY "txa_service_data_array"
> > +#define TXA_ADAPTER_INSTANCE_ARRAY "txa_adapter_instance_array"
> >
> > #define txa_evdev(id) (&rte_eventdevs[txa_dev_id_array[(id)]])
> >
> > @@ -140,6 +147,10 @@ struct txa_service_ethdev {
> > void *queues;
> > };
> >
> > +struct event_eth_txa_inst_info {
> > + uint8_t txa_inst_id;
> > +};
> > +
> > /* Array of adapter instances, initialized with event device id
> > * when adapter is created
> > */
> > @@ -148,6 +159,9 @@ static int *txa_dev_id_array;
> > /* Array of pointers to service implementation data */ static struct
> > txa_service_data **txa_service_data_array;
> >
> > +/* array of adapter instances to store tx queue specific instance */
> > +static struct event_eth_txa_inst_info **event_eth_txa_inst_info;
> > +
> > static int32_t txa_service_func(void *args); static int
> > txa_service_adapter_create_ext(uint8_t id,
> > struct rte_eventdev *dev,
> > @@ -194,12 +208,42 @@ txa_memzone_array_get(const char *name,
> unsigned
> > int elt_size, int nb_elems) }
> >
> > static int
> > +txa_memzone_lookup(void)
> > +{
> > + const struct rte_memzone *mz;
> > +
> > + if (txa_dev_id_array == NULL) {
> > + mz = rte_memzone_lookup(TXA_ADAPTER_ARRAY);
> > + if (mz == NULL)
> > + return -ENOMEM;
> > + txa_dev_id_array = mz->addr;
> > + }
> > +
> > + if (txa_service_data_array == NULL) {
> > + mz = rte_memzone_lookup(TXA_SERVICE_DATA_ARRAY);
> > + if (mz == NULL)
> > + return -ENOMEM;
> > + txa_service_data_array = mz->addr;
> > + }
> > +
> > + if (event_eth_txa_inst_info == NULL) {
> > + mz =
> rte_memzone_lookup(TXA_ADAPTER_INSTANCE_ARRAY);
> > + if (mz == NULL)
> > + return -ENOMEM;
> > + event_eth_txa_inst_info = mz->addr;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +
> > +static int
> > txa_dev_id_array_init(void)
> > {
> > if (txa_dev_id_array == NULL) {
> > int i;
> >
> > - txa_dev_id_array =
> txa_memzone_array_get("txa_adapter_array",
> > + txa_dev_id_array =
> txa_memzone_array_get(TXA_ADAPTER_ARRAY,
> > sizeof(int),
> >
> RTE_EVENT_ETH_TX_ADAPTER_MAX_INSTANCE);
> > if (txa_dev_id_array == NULL)
> > @@ -221,15 +265,30 @@ txa_init(void)
> > static int
> > txa_service_data_init(void)
> > {
> > + uint8_t i;
> > +
> > if (txa_service_data_array == NULL) {
> > txa_service_data_array =
> > -
> txa_memzone_array_get("txa_service_data_array",
> > +
> txa_memzone_array_get(TXA_SERVICE_DATA_ARRAY,
> > sizeof(int),
> >
> RTE_EVENT_ETH_TX_ADAPTER_MAX_INSTANCE);
> > if (txa_service_data_array == NULL)
> > return -ENOMEM;
> > }
> >
> > + if (event_eth_txa_inst_info == NULL) {
> > + event_eth_txa_inst_info =
> > +
> txa_memzone_array_get(TXA_ADAPTER_INSTANCE_ARRAY,
> > + sizeof(*event_eth_txa_inst_info),
> > + RTE_MAX_ETHPORTS);
> > + if (event_eth_txa_inst_info == NULL)
> > + return -ENOMEM;
> > + }
> > +
> > + /* Reset the txa instance pointers */
> > + for (i = 0; i < RTE_MAX_ETHPORTS; i++)
> > + event_eth_txa_inst_info[i] = NULL;
> > +
> > return 0;
> > }
> >
> > @@ -763,6 +822,7 @@ txa_service_queue_add(uint8_t id,
> > struct rte_eth_dev_tx_buffer *tb;
> > struct txa_retry *txa_retry;
> > int ret = 0;
> > + uint16_t eth_dev_id = eth_dev->data->port_id;
> >
> > txa = txa_service_id_to_data(id);
> >
> > @@ -836,6 +896,31 @@ txa_service_queue_add(uint8_t id,
> > tdi->nb_queues++;
> > txa->nb_queues++;
> >
> > + /* Allocate storage to store txa_inst_id for txq */
> > + if (event_eth_txa_inst_info[eth_dev_id] == NULL) {
> > + uint16_t n, i;
> > + struct event_eth_txa_inst_info *i_info;
> > +
> > + n = eth_dev->data->nb_tx_queues;
> > +
> > + i_info = rte_zmalloc_socket("event_eth_txa_inst_info",
> > + n * sizeof(event_eth_txa_inst_info),
> > + 0,
> > + txa->socket_id);
> > + if (i_info == NULL) {
> > + RTE_EDEV_LOG_ERR("Failed to allocate storage for "
> > + "event_eth_txa_inst_info");
> > + goto err_unlock;
> > + }
> > +
> > + for (i = 0; i < n; i++)
> > + i_info[i].txa_inst_id = INVALID_INSTANCE_ID;
> > +
> > + event_eth_txa_inst_info[eth_dev_id] = i_info;
> > + }
> > +
> > + event_eth_txa_inst_info[eth_dev_id][tx_queue_id].txa_inst_id =
> id;
> > +
> > ret_unlock:
> > rte_spinlock_unlock(&txa->tx_lock);
> > return 0;
> > @@ -902,6 +987,12 @@ txa_service_queue_del(uint8_t id,
> > txa->nb_queues--;
> > txa->txa_ethdev[port_id].nb_queues--;
> >
> > + /* unset txa_inst_id for tx_queue_id */
> > + if (event_eth_txa_inst_info[port_id])
> > + event_eth_txa_inst_info[port_id][tx_queue_id].txa_inst_id
> =
> > +
> INVALID_INSTANCE_ID;
> > +
> > +
> > txa_service_queue_array_free(txa, port_id);
> > return 0;
> > }
> > @@ -1056,6 +1147,10 @@ int
> > rte_event_eth_tx_adapter_free(uint8_t id) {
> > int ret;
> > + uint16_t eth_dev_id;
> > +
> > + if (txa_memzone_lookup())
> > + return -ENOMEM;
> >
> > TXA_CHECK_OR_ERR_RET(id);
> >
> > @@ -1067,6 +1162,13 @@ rte_event_eth_tx_adapter_free(uint8_t id)
> > ret = txa_service_adapter_free(id);
> > txa_dev_id_array[id] = TXA_INVALID_DEV_ID;
> >
> > + for (eth_dev_id = 0; eth_dev_id < RTE_MAX_ETHPORTS;
> eth_dev_id++) {
> > + if (event_eth_txa_inst_info[eth_dev_id]) {
> > + rte_free(event_eth_txa_inst_info[eth_dev_id]);
> > + event_eth_txa_inst_info[eth_dev_id] = NULL;
> > + }
> > + }
> > +
> > rte_eventdev_trace_eth_tx_adapter_free(id, ret);
> > return ret;
> > }
> > @@ -1080,6 +1182,9 @@ rte_event_eth_tx_adapter_queue_add(uint8_t
> id,
> > int ret;
> > uint32_t caps;
> >
> > + if (txa_memzone_lookup())
> > + return -ENOMEM;
> > +
> > RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_dev_id, -EINVAL);
> > TXA_CHECK_OR_ERR_RET(id);
> >
> > @@ -1113,6 +1218,9 @@ rte_event_eth_tx_adapter_queue_del(uint8_t
> id,
> > int ret;
> > uint32_t caps;
> >
> > + if (txa_memzone_lookup())
> > + return -ENOMEM;
> > +
> > RTE_ETH_VALID_PORTID_OR_ERR_RET(eth_dev_id, -EINVAL);
> > TXA_CHECK_OR_ERR_RET(id);
> >
> > @@ -1218,3 +1326,46 @@ rte_event_eth_tx_adapter_stop(uint8_t id)
> > rte_eventdev_trace_eth_tx_adapter_stop(id, ret);
> > return ret;
> > }
> > +
> > +int
> > +rte_event_eth_tx_adapter_instance_get(uint16_t eth_dev_id,
> > + uint16_t tx_queue_id,
> > + uint8_t *txa_inst_id)
> > +{
> > + uint8_t inst_id;
> > +
> > + if (txa_memzone_lookup())
> > + return -ENOMEM;
> > +
> > + if (eth_dev_id >= rte_eth_dev_count_avail()) {
> > + RTE_EDEV_LOG_ERR("Invalid ethernet port id %u",
> eth_dev_id);
> > + return -EINVAL;
> > + }
> > +
> > + if (tx_queue_id >= rte_eth_devices[eth_dev_id].data-
> >nb_tx_queues) {
> > + RTE_EDEV_LOG_ERR("Invalid tx queue id %u", tx_queue_id);
> > + return -EINVAL;
> > + }
> > +
> > + if (txa_inst_id == NULL) {
> > + RTE_EDEV_LOG_ERR("txa_instance_id cannot be NULL");
> > + return -EINVAL;
> > + }
> > +
> > + if (event_eth_txa_inst_info[eth_dev_id] == NULL) {
> > + RTE_EDEV_LOG_ERR("No valid txa instance for eth_dev_id
> %d",
> > + eth_dev_id);
> > + return -EINVAL;
> > + }
> > +
> > + inst_id =
> event_eth_txa_inst_info[eth_dev_id][tx_queue_id].txa_inst_id;
> > + if (inst_id == INVALID_INSTANCE_ID) {
> > + RTE_EDEV_LOG_ERR("Invalid txa instance for eth_dev_id
> %u, "
> > + "tx_queue_id %u", eth_dev_id,
> tx_queue_id);
> > + return -EINVAL;
> > + }
> > +
> > + *txa_inst_id = inst_id;
> > +
> > + return 0;
> > +}
> > diff --git a/lib/eventdev/rte_event_eth_tx_adapter.h
> > b/lib/eventdev/rte_event_eth_tx_adapter.h
> > index 3908c2d..28f4fa9 100644
> > --- a/lib/eventdev/rte_event_eth_tx_adapter.h
> > +++ b/lib/eventdev/rte_event_eth_tx_adapter.h
> > @@ -34,6 +34,7 @@
> > * - rte_event_eth_tx_adapter_enqueue()
> > * - rte_event_eth_tx_adapter_event_port_get()
> > * - rte_event_eth_tx_adapter_service_id_get()
> > + * - rte_event_eth_tx_adapter_instance_get()
> > *
> > * The application creates the adapter using
> > * rte_event_eth_tx_adapter_create() or
> rte_event_eth_tx_adapter_create_ext().
> > @@ -423,6 +424,24 @@ rte_event_eth_tx_adapter_stats_reset(uint8_t
> id);
> > int rte_event_eth_tx_adapter_service_id_get(uint8_t id, uint32_t
> > *service_id);
> >
> > +/**
> > + * Get TX adapter instance id for TX queue
> > + *
> > + * @param eth_dev_id
> > + * Port identifier of Ethernet device
> > + *
> > + * @param tx_queue_id
> > + * Etherdev device TX queue index
> > + *
> > + * @param[out] txa_inst_id
> > + * Pointer to TX adapter instance identifier */ __rte_experimental
> > +int rte_event_eth_tx_adapter_instance_get(uint16_t eth_dev_id,
> > + uint16_t tx_queue_id,
> > + uint8_t *txa_inst_id);
> > +
> > #ifdef __cplusplus
> > }
> > #endif
> > diff --git a/lib/eventdev/version.map b/lib/eventdev/version.map index
> > 886e2ec..1c99d52 100644
> > --- a/lib/eventdev/version.map
> > +++ b/lib/eventdev/version.map
> > @@ -102,9 +102,11 @@ EXPERIMENTAL {
> >
> > # added in 21.11
> > rte_event_eth_rx_adapter_create_with_params;
> > + rte_event_eth_rx_adapter_instance_get;
> > rte_event_eth_rx_adapter_queue_conf_get;
> > rte_event_eth_rx_adapter_queue_stats_get;
> > rte_event_eth_rx_adapter_queue_stats_reset;
> > + rte_event_eth_tx_adapter_instance_get;
> >
> > # added in 22.03
> > rte_event_eth_rx_adapter_event_port_get;
> > --
> > 2.6.4
