From: Chengwen Feng <[email protected]>

Rename the exported function rte_event_dev_socket_id() to
rte_event_dev_numa_id(), keeping the old name as a functional
alias to be deprecated once the in-tree migration completes.

Rename the numa_id fields of the timer and vector adapter
configuration structures (were socket_id), keeping socket_id as
a deprecated union alias, and the eventdev data field to
numa_id, and update in-tree users accordingly.

Also rename socket_id parameters, trace points, internal
variables, log messages and comments to the NUMA node
terminology, and switch internal calls to rte_zmalloc_numa(),
rte_numa_id() and RTE_NUMA_ID_ANY.

Signed-off-by: Chengwen Feng <[email protected]>
---
 app/test-eventdev/test_perf_common.c       |  4 +-
 drivers/event/dlb2/pf/dlb2_pf.c            |  2 +-
 drivers/event/dsw/dsw_evdev.c              |  4 +-
 drivers/event/octeontx/ssovf_evdev.c       |  2 +-
 drivers/event/skeleton/skeleton_eventdev.c |  4 +-
 drivers/event/sw/sw_evdev.c                |  8 +--
 drivers/event/sw/sw_evdev_xstats.c         |  2 +-
 lib/eventdev/event_timer_adapter_pmd.h     |  4 +-
 lib/eventdev/event_vector_adapter_pmd.h    |  4 +-
 lib/eventdev/eventdev_pmd.h                | 10 ++--
 lib/eventdev/eventdev_pmd_pci.h            |  4 +-
 lib/eventdev/eventdev_pmd_vdev.h           | 12 ++--
 lib/eventdev/eventdev_trace.h              | 14 ++---
 lib/eventdev/eventdev_trace_points.c       |  4 +-
 lib/eventdev/rte_event_crypto_adapter.c    | 30 +++++-----
 lib/eventdev/rte_event_dma_adapter.c       | 38 ++++++------
 lib/eventdev/rte_event_eth_rx_adapter.c    | 68 +++++++++++-----------
 lib/eventdev/rte_event_eth_tx_adapter.c    | 30 +++++-----
 lib/eventdev/rte_event_ring.c              |  6 +-
 lib/eventdev/rte_event_ring.h              |  8 +--
 lib/eventdev/rte_event_timer_adapter.c     | 16 ++---
 lib/eventdev/rte_event_timer_adapter.h     | 11 +++-
 lib/eventdev/rte_event_vector_adapter.c    | 12 ++--
 lib/eventdev/rte_event_vector_adapter.h    | 11 +++-
 lib/eventdev/rte_eventdev.c                | 31 ++++++----
 lib/eventdev/rte_eventdev.h                | 24 ++++++--
 26 files changed, 200 insertions(+), 163 deletions(-)

diff --git a/app/test-eventdev/test_perf_common.c 
b/app/test-eventdev/test_perf_common.c
index a7858854eb..cb69ed7f1b 100644
--- a/app/test-eventdev/test_perf_common.c
+++ b/app/test-eventdev/test_perf_common.c
@@ -1649,7 +1649,7 @@ perf_event_dev_port_setup(struct evt_test *test, struct 
evt_options *opt,
                conf.event_dev_id = opt->dev_id;
                conf.vector_sz = opt->vector_size;
                conf.vector_timeout_ns = opt->vector_tmo_nsec;
-               conf.socket_id = opt->socket_id;
+               conf.numa_id = opt->socket_id;
                conf.vector_mp = t->pool;
 
                conf.ev.sched_type = opt->sched_type_list[0];
@@ -2082,7 +2082,7 @@ perf_cryptodev_setup(struct evt_test *test, struct 
evt_options *opt)
                }
 
                conf.nb_queue_pairs = nb_qps;
-               conf.socket_id = SOCKET_ID_ANY;
+               conf.numa_id = RTE_NUMA_ID_ANY;
                conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 
                ret = rte_cryptodev_configure(cdev_id, &conf);
diff --git a/drivers/event/dlb2/pf/dlb2_pf.c b/drivers/event/dlb2/pf/dlb2_pf.c
index c78783e59d..aaa55bbe00 100644
--- a/drivers/event/dlb2/pf/dlb2_pf.c
+++ b/drivers/event/dlb2/pf/dlb2_pf.c
@@ -777,7 +777,7 @@ dlb2_eventdev_pci_init(struct rte_eventdev *eventdev)
        const void *probe_args = NULL;
 
        DLB2_LOG_LINE_DBG("Enter with dev_id=%d socket_id=%d",
-                    eventdev->data->dev_id, eventdev->data->socket_id);
+                    eventdev->data->dev_id, eventdev->data->numa_id);
 
        for (q = 0; q < DLB2_MAX_NUM_PORTS_ALL; q++)
                dlb2_args.port_cos.cos_id[q] = DLB2_COS_DEFAULT;
diff --git a/drivers/event/dsw/dsw_evdev.c b/drivers/event/dsw/dsw_evdev.c
index e819412639..55e3a2045c 100644
--- a/drivers/event/dsw/dsw_evdev.c
+++ b/drivers/event/dsw/dsw_evdev.c
@@ -43,7 +43,7 @@ dsw_port_setup(struct rte_eventdev *dev, uint8_t port_id,
                 port_id);
 
        in_ring = rte_event_ring_create(ring_name, DSW_IN_RING_SIZE,
-                                       dev->data->socket_id,
+                                       dev->data->numa_id,
                                        RING_F_SC_DEQ|RING_F_EXACT_SZ);
 
        if (in_ring == NULL)
@@ -55,7 +55,7 @@ dsw_port_setup(struct rte_eventdev *dev, uint8_t port_id,
        ctl_in_ring = rte_ring_create_elem(ring_name,
                                           sizeof(struct dsw_ctl_msg),
                                           DSW_CTL_IN_RING_SIZE,
-                                          dev->data->socket_id,
+                                          dev->data->numa_id,
                                           RING_F_SC_DEQ|RING_F_EXACT_SZ);
 
        if (ctl_in_ring == NULL) {
diff --git a/drivers/event/octeontx/ssovf_evdev.c 
b/drivers/event/octeontx/ssovf_evdev.c
index 957fcab04e..1e5818569b 100644
--- a/drivers/event/octeontx/ssovf_evdev.c
+++ b/drivers/event/octeontx/ssovf_evdev.c
@@ -256,7 +256,7 @@ ssovf_port_setup(struct rte_eventdev *dev, uint8_t port_id,
        /* Allocate event port memory */
        ws = rte_zmalloc_socket("eventdev ssows",
                        sizeof(struct ssows), RTE_CACHE_LINE_SIZE,
-                       dev->data->socket_id);
+                       dev->data->numa_id);
        if (ws == NULL) {
                ssovf_log_err("Failed to alloc memory for port=%d", port_id);
                return -ENOMEM;
diff --git a/drivers/event/skeleton/skeleton_eventdev.c 
b/drivers/event/skeleton/skeleton_eventdev.c
index c0e06e4aa0..9eccf61cad 100644
--- a/drivers/event/skeleton/skeleton_eventdev.c
+++ b/drivers/event/skeleton/skeleton_eventdev.c
@@ -222,7 +222,7 @@ skeleton_eventdev_port_setup(struct rte_eventdev *dev, 
uint8_t port_id,
        /* Allocate event port memory */
        sp = rte_zmalloc_socket("eventdev port",
                        sizeof(struct skeleton_port), RTE_CACHE_LINE_SIZE,
-                       dev->data->socket_id);
+                       dev->data->numa_id);
        if (sp == NULL) {
                PMD_DRV_ERR("Failed to allocate sp port_id=%d", port_id);
                return -ENOMEM;
@@ -352,7 +352,7 @@ skeleton_eventdev_init(struct rte_eventdev *eventdev)
                        pci_dev->addr.devid, pci_dev->addr.function);
 
        PMD_DRV_LOG(INFO, "dev_id=%d socket_id=%d (%x:%x)",
-               eventdev->data->dev_id, eventdev->data->socket_id,
+               eventdev->data->dev_id, eventdev->data->numa_id,
                skel->vendor_id, skel->device_id);
 
 fail:
diff --git a/drivers/event/sw/sw_evdev.c b/drivers/event/sw/sw_evdev.c
index adff02bf3e..d6bc23a220 100644
--- a/drivers/event/sw/sw_evdev.c
+++ b/drivers/event/sw/sw_evdev.c
@@ -178,7 +178,7 @@ sw_port_setup(struct rte_eventdev *dev, uint8_t port_id,
        rte_event_ring_free(existing_ring);
 
        p->rx_worker_ring = rte_event_ring_create(buf, MAX_SW_PROD_Q_DEPTH,
-                       dev->data->socket_id,
+                       dev->data->numa_id,
                        RING_F_SP_ENQ | RING_F_SC_DEQ | RING_F_EXACT_SZ);
        if (p->rx_worker_ring == NULL) {
                SW_LOG_ERR("Error creating RX worker ring for port %d",
@@ -197,7 +197,7 @@ sw_port_setup(struct rte_eventdev *dev, uint8_t port_id,
        rte_event_ring_free(existing_ring);
 
        p->cq_worker_ring = rte_event_ring_create(buf, conf->dequeue_depth,
-                       dev->data->socket_id,
+                       dev->data->numa_id,
                        RING_F_SP_ENQ | RING_F_SC_DEQ | RING_F_EXACT_SZ);
        if (p->cq_worker_ring == NULL) {
                rte_event_ring_free(p->rx_worker_ring);
@@ -237,7 +237,7 @@ qid_init(struct sw_evdev *sw, unsigned int idx, int type,
                const struct rte_event_queue_conf *queue_conf)
 {
        unsigned int i;
-       int socket_id = sw->data->socket_id;
+       int socket_id = sw->data->numa_id;
        struct sw_qid *qid = &sw->qids[idx];
 
        /* Initialize the FID structures to no pinning (-1), and zero packets */
@@ -537,7 +537,7 @@ sw_dev_configure(const struct rte_eventdev *dev)
                                       sizeof(struct sw_queue_chunk) *
                                       num_chunks,
                                       0,
-                                      sw->data->socket_id);
+                                      sw->data->numa_id);
        if (!sw->chunks)
                return -ENOMEM;
 
diff --git a/drivers/event/sw/sw_evdev_xstats.c 
b/drivers/event/sw/sw_evdev_xstats.c
index 076b982ab8..611a7ce94a 100644
--- a/drivers/event/sw/sw_evdev_xstats.c
+++ b/drivers/event/sw/sw_evdev_xstats.c
@@ -262,7 +262,7 @@ sw_xstats_init(struct sw_evdev *sw)
        unsigned int i, port, qid, iq, bkt, stat = 0;
 
        sw->xstats = rte_zmalloc_socket(NULL, sizeof(sw->xstats[0]) * count, 0,
-                       sw->data->socket_id);
+                       sw->data->numa_id);
        if (sw->xstats == NULL)
                return -ENOMEM;
 
diff --git a/lib/eventdev/event_timer_adapter_pmd.h 
b/lib/eventdev/event_timer_adapter_pmd.h
index f06e85dc0b..6b75ee304b 100644
--- a/lib/eventdev/event_timer_adapter_pmd.h
+++ b/lib/eventdev/event_timer_adapter_pmd.h
@@ -87,8 +87,8 @@ struct __rte_cache_aligned rte_event_timer_adapter_data {
        /**< Event timer adapter ID */
        uint8_t event_dev_id;
        /**< Event device ID */
-       uint32_t socket_id;
-       /**< Socket ID where memory is allocated */
+       uint32_t numa_id;
+       /**< NUMA node ID where memory is allocated */
        uint8_t event_port_id;
        /**< Optional: event port ID used when the inbuilt port is absent */
        const struct rte_memzone *mz;
diff --git a/lib/eventdev/event_vector_adapter_pmd.h 
b/lib/eventdev/event_vector_adapter_pmd.h
index 7fe2c53639..614833d691 100644
--- a/lib/eventdev/event_vector_adapter_pmd.h
+++ b/lib/eventdev/event_vector_adapter_pmd.h
@@ -56,8 +56,8 @@ struct __rte_cache_aligned rte_event_vector_adapter_data {
        /**< Event vector adapter ID */
        uint8_t event_dev_id;
        /**< Event device ID */
-       uint32_t socket_id;
-       /**< Socket ID where memory is allocated */
+       uint32_t numa_id;
+       /**< NUMA node ID where memory is allocated */
        uint8_t event_port_id;
        /**< Optional: event port ID used when the inbuilt port is absent */
        const struct rte_memzone *mz;
diff --git a/lib/eventdev/eventdev_pmd.h b/lib/eventdev/eventdev_pmd.h
index 9309dce5e1..2d40e4ff0c 100644
--- a/lib/eventdev/eventdev_pmd.h
+++ b/lib/eventdev/eventdev_pmd.h
@@ -110,8 +110,8 @@ struct rte_eventdev_global {
  * different processes in a multi-process configuration.
  */
 struct __rte_cache_aligned rte_eventdev_data {
-       int socket_id;
-       /**< Socket ID where memory is allocated */
+       int numa_id;
+       /**< NUMA node ID where memory is allocated */
        uint8_t dev_id;
        /**< Device ID for this instance */
        uint8_t nb_queues;
@@ -1744,14 +1744,14 @@ struct eventdev_ops {
  *
  * @param name
  *   Unique identifier name for each device
- * @param socket_id
- *   Socket to allocate resources on.
+ * @param numa_id
+ *   NUMA node to allocate resources on.
  * @return
  *   - Slot in the rte_dev_devices array for a new device;
  */
 __rte_internal
 struct rte_eventdev *
-rte_event_pmd_allocate(const char *name, int socket_id);
+rte_event_pmd_allocate(const char *name, int numa_id);
 
 /**
  * Release the specified eventdev device.
diff --git a/lib/eventdev/eventdev_pmd_pci.h b/lib/eventdev/eventdev_pmd_pci.h
index ebc7d12b1d..3994c3b42e 100644
--- a/lib/eventdev/eventdev_pmd_pci.h
+++ b/lib/eventdev/eventdev_pmd_pci.h
@@ -57,11 +57,11 @@ rte_event_pmd_pci_probe_named(struct rte_pci_driver 
*pci_drv,
 
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
                eventdev->data->dev_private =
-                               rte_zmalloc_socket(
+                               rte_zmalloc_numa(
                                                "eventdev private structure",
                                                private_data_size,
                                                RTE_CACHE_LINE_SIZE,
-                                               rte_socket_id());
+                                               rte_numa_id());
 
                if (eventdev->data->dev_private == NULL)
                        rte_panic("Cannot allocate memzone for private "
diff --git a/lib/eventdev/eventdev_pmd_vdev.h b/lib/eventdev/eventdev_pmd_vdev.h
index ae1c950bed..da0b3acd99 100644
--- a/lib/eventdev/eventdev_pmd_vdev.h
+++ b/lib/eventdev/eventdev_pmd_vdev.h
@@ -35,8 +35,8 @@ extern "C" {
  *   PMD type name
  * @param dev_private_size
  *   Size of event PMDs private data
- * @param socket_id
- *   Socket to allocate resources on.
+ * @param numa_id
+ *   NUMA node to allocate resources on.
  *
  * @return
  *   - Eventdev pointer if device is successfully created.
@@ -45,23 +45,23 @@ extern "C" {
 __rte_internal
 static inline struct rte_eventdev *
 rte_event_pmd_vdev_init(const char *name, size_t dev_private_size,
-               int socket_id, struct rte_vdev_device *vdev)
+               int numa_id, struct rte_vdev_device *vdev)
 {
 
        struct rte_eventdev *eventdev;
 
        /* Allocate device structure */
-       eventdev = rte_event_pmd_allocate(name, socket_id);
+       eventdev = rte_event_pmd_allocate(name, numa_id);
        if (eventdev == NULL)
                return NULL;
 
        /* Allocate private device structure */
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
                eventdev->data->dev_private =
-                               rte_zmalloc_socket("eventdev device private",
+                               rte_zmalloc_numa("eventdev device private",
                                                dev_private_size,
                                                RTE_CACHE_LINE_SIZE,
-                                               socket_id);
+                                               numa_id);
 
                if (eventdev->data->dev_private == NULL)
                        rte_panic("Cannot allocate memzone for private device"
diff --git a/lib/eventdev/eventdev_trace.h b/lib/eventdev/eventdev_trace.h
index 6b334d8bd1..45d53bb853 100644
--- a/lib/eventdev/eventdev_trace.h
+++ b/lib/eventdev/eventdev_trace.h
@@ -388,11 +388,11 @@ RTE_TRACE_POINT(
 )
 
 RTE_TRACE_POINT(
-       rte_eventdev_trace_socket_id,
-       RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, int socket_id),
+       rte_eventdev_trace_numa_id,
+       RTE_TRACE_POINT_ARGS(uint8_t dev_id, const void *dev, int numa_id),
        rte_trace_point_emit_u8(dev_id);
        rte_trace_point_emit_ptr(dev);
-       rte_trace_point_emit_int(socket_id);
+       rte_trace_point_emit_int(numa_id);
 )
 
 RTE_TRACE_POINT(
@@ -569,10 +569,10 @@ RTE_TRACE_POINT(
 RTE_TRACE_POINT(
        rte_eventdev_trace_ring_create,
        RTE_TRACE_POINT_ARGS(const char *name, unsigned int count,
-               int socket_id, unsigned int flags),
+               int numa_id, unsigned int flags),
        rte_trace_point_emit_string(name);
        rte_trace_point_emit_u32(count);
-       rte_trace_point_emit_int(socket_id);
+       rte_trace_point_emit_int(numa_id);
        rte_trace_point_emit_u32(flags);
 )
 
@@ -633,11 +633,11 @@ RTE_TRACE_POINT(
 
 RTE_TRACE_POINT(
        rte_eventdev_trace_vector_pool_create,
-       RTE_TRACE_POINT_ARGS(const void *mp, const char *name, int socket_id,
+       RTE_TRACE_POINT_ARGS(const void *mp, const char *name, int numa_id,
                uint32_t size, uint32_t cache_size, uint32_t elt_size),
        rte_trace_point_emit_ptr(mp);
        rte_trace_point_emit_string(name);
-       rte_trace_point_emit_int(socket_id);
+       rte_trace_point_emit_int(numa_id);
        rte_trace_point_emit_u32(size);
        rte_trace_point_emit_u32(cache_size);
        rte_trace_point_emit_u32(elt_size);
diff --git a/lib/eventdev/eventdev_trace_points.c 
b/lib/eventdev/eventdev_trace_points.c
index ade6723b7b..f5f6be3a7b 100644
--- a/lib/eventdev/eventdev_trace_points.c
+++ b/lib/eventdev/eventdev_trace_points.c
@@ -176,8 +176,8 @@ RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_info_get,
 RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_service_id_get,
        lib.eventdev.service_id_get)
 
-RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_socket_id,
-       lib.eventdev.socket.id)
+RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_numa_id,
+       lib.eventdev.numa_id)
 
 RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_stop_flush_callback_register,
        lib.eventdev.stop.flush.callback.register)
diff --git a/lib/eventdev/rte_event_crypto_adapter.c 
b/lib/eventdev/rte_event_crypto_adapter.c
index 6ac64cafb1..a8e29f2b32 100644
--- a/lib/eventdev/rte_event_crypto_adapter.c
+++ b/lib/eventdev/rte_event_crypto_adapter.c
@@ -91,8 +91,8 @@ struct __rte_cache_aligned event_crypto_adapter {
        uint8_t service_inited;
        /* Memory allocation name */
        char mem_name[CRYPTO_ADAPTER_MEM_NAME_LEN];
-       /* Socket identifier cached from eventdev */
-       int socket_id;
+       /* NUMA node identifier cached from eventdev */
+       int numa_id;
        /* Per adapter EAL service */
        uint32_t service_id;
        /* No. of queue pairs configured */
@@ -180,7 +180,7 @@ eca_init(void)
        mz = rte_memzone_lookup(ECA_ADAPTER_ARRAY);
        if (mz == NULL) {
                mz = rte_memzone_reserve_aligned(ECA_ADAPTER_ARRAY, sz,
-                                                rte_socket_id(), 0,
+                                                rte_numa_id(), 0,
                                                 RTE_CACHE_LINE_SIZE);
                if (mz == NULL) {
                        RTE_EDEV_LOG_ERR("failed to reserve memzone err = %"
@@ -372,7 +372,7 @@ rte_event_crypto_adapter_create_ext(uint8_t id, uint8_t 
dev_id,
 {
        struct event_crypto_adapter *adapter;
        char mem_name[CRYPTO_ADAPTER_NAME_LEN];
-       int socket_id;
+       int numa_id;
        uint8_t i;
        int ret;
 
@@ -393,12 +393,12 @@ rte_event_crypto_adapter_create_ext(uint8_t id, uint8_t 
dev_id,
                return -EEXIST;
        }
 
-       socket_id = rte_event_dev_socket_id(dev_id);
+       numa_id = rte_event_dev_numa_id(dev_id);
        snprintf(mem_name, CRYPTO_ADAPTER_MEM_NAME_LEN,
                 "rte_event_crypto_adapter_%d", id);
 
-       adapter = rte_zmalloc_socket(mem_name, sizeof(*adapter),
-                       RTE_CACHE_LINE_SIZE, socket_id);
+       adapter = rte_zmalloc_numa(mem_name, sizeof(*adapter),
+                       RTE_CACHE_LINE_SIZE, numa_id);
        if (adapter == NULL) {
                RTE_EDEV_LOG_ERR("Failed to get mem for event crypto adapter!");
                return -ENOMEM;
@@ -413,15 +413,15 @@ rte_event_crypto_adapter_create_ext(uint8_t id, uint8_t 
dev_id,
        }
 
        adapter->eventdev_id = dev_id;
-       adapter->socket_id = socket_id;
+       adapter->numa_id = numa_id;
        adapter->conf_cb = conf_cb;
        adapter->conf_arg = conf_arg;
        adapter->mode = mode;
        strcpy(adapter->mem_name, mem_name);
-       adapter->cdevs = rte_zmalloc_socket(adapter->mem_name,
+       adapter->cdevs = rte_zmalloc_numa(adapter->mem_name,
                                        rte_cryptodev_count() *
                                        sizeof(struct crypto_device_info), 0,
-                                       socket_id);
+                                       numa_id);
        if (adapter->cdevs == NULL) {
                RTE_EDEV_LOG_ERR("Failed to get mem for crypto devices");
                eca_circular_buffer_free(&adapter->ebuf);
@@ -920,7 +920,7 @@ eca_init_service(struct event_crypto_adapter *adapter, 
uint8_t id)
        memset(&service, 0, sizeof(service));
        snprintf(service.name, CRYPTO_ADAPTER_NAME_LEN,
                "rte_event_crypto_adapter_%d", id);
-       service.socket_id = adapter->socket_id;
+       service.socket_id = adapter->numa_id;
        service.callback = eca_service_func;
        service.callback_userdata = adapter;
        /* Service function handles locking for queue add/del updates */
@@ -1011,10 +1011,10 @@ eca_add_queue_pair(struct event_crypto_adapter 
*adapter, uint8_t cdev_id,
 
        if (dev_info->qpairs == NULL) {
                dev_info->qpairs =
-                   rte_zmalloc_socket(adapter->mem_name,
+                   rte_zmalloc_numa(adapter->mem_name,
                                        dev_info->dev->data->nb_queue_pairs *
                                        sizeof(struct crypto_queue_pair_info),
-                                       0, adapter->socket_id);
+                                       0, adapter->numa_id);
                if (dev_info->qpairs == NULL)
                        return -ENOMEM;
 
@@ -1141,10 +1141,10 @@ rte_event_crypto_adapter_queue_pair_add(uint8_t id,
                        return -ENOTSUP;
                if (dev_info->qpairs == NULL) {
                        dev_info->qpairs =
-                           rte_zmalloc_socket(adapter->mem_name,
+                           rte_zmalloc_numa(adapter->mem_name,
                                        dev_info->dev->data->nb_queue_pairs *
                                        sizeof(struct crypto_queue_pair_info),
-                                       0, adapter->socket_id);
+                                       0, adapter->numa_id);
                        if (dev_info->qpairs == NULL)
                                return -ENOMEM;
                }
diff --git a/lib/eventdev/rte_event_dma_adapter.c 
b/lib/eventdev/rte_event_dma_adapter.c
index da785483c2..1dc752141d 100644
--- a/lib/eventdev/rte_event_dma_adapter.c
+++ b/lib/eventdev/rte_event_dma_adapter.c
@@ -97,8 +97,8 @@ struct __rte_cache_aligned event_dma_adapter {
        /* Memory allocation name */
        char mem_name[DMA_ADAPTER_NAME_LEN];
 
-       /* Socket identifier cached from eventdev */
-       int socket_id;
+       /* NUMA node identifier cached from eventdev */
+       int numa_id;
 
        /* Lock to serialize config updates with service function */
        rte_spinlock_t lock;
@@ -173,7 +173,7 @@ edma_array_init(void)
                sz = sizeof(struct event_dma_adapter *) * 
RTE_EVENT_DMA_ADAPTER_MAX_INSTANCE;
                sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
 
-               mz = rte_memzone_reserve_aligned(DMA_ADAPTER_ARRAY, sz, 
rte_socket_id(), 0,
+               mz = rte_memzone_reserve_aligned(DMA_ADAPTER_ARRAY, sz, 
rte_numa_id(), 0,
                                                 RTE_CACHE_LINE_SIZE);
                if (mz == NULL) {
                        RTE_EDEV_LOG_ERR("Failed to reserve memzone : %s, err = 
%d",
@@ -352,7 +352,7 @@ rte_event_dma_adapter_create_ext(uint8_t id, uint8_t 
evdev_id,
        char name[DMA_ADAPTER_NAME_LEN];
        struct rte_dma_info info;
        uint16_t num_dma_dev;
-       int socket_id;
+       int numa_id;
        uint8_t i;
        int ret;
 
@@ -374,10 +374,10 @@ rte_event_dma_adapter_create_ext(uint8_t id, uint8_t 
evdev_id,
                return -EEXIST;
        }
 
-       socket_id = rte_event_dev_socket_id(evdev_id);
+       numa_id = rte_event_dev_numa_id(evdev_id);
        snprintf(name, DMA_ADAPTER_NAME_LEN, "rte_event_dma_adapter_%d", id);
-       adapter = rte_zmalloc_socket(name, sizeof(struct event_dma_adapter), 
RTE_CACHE_LINE_SIZE,
-                                    socket_id);
+       adapter = rte_zmalloc_numa(name, sizeof(struct event_dma_adapter), 
RTE_CACHE_LINE_SIZE,
+                                    numa_id);
        if (adapter == NULL) {
                RTE_EDEV_LOG_ERR("Failed to get mem for event ML adapter!");
                return -ENOMEM;
@@ -404,12 +404,12 @@ rte_event_dma_adapter_create_ext(uint8_t id, uint8_t 
evdev_id,
        adapter->eventdev_id = evdev_id;
        adapter->mode = mode;
        rte_strscpy(adapter->mem_name, name, DMA_ADAPTER_NAME_LEN);
-       adapter->socket_id = socket_id;
+       adapter->numa_id = numa_id;
        adapter->conf_cb = conf_cb;
        adapter->conf_arg = conf_arg;
-       adapter->dma_devs = rte_zmalloc_socket(adapter->mem_name,
+       adapter->dma_devs = rte_zmalloc_numa(adapter->mem_name,
                                               num_dma_dev * sizeof(struct 
dma_device_info), 0,
-                                              socket_id);
+                                              numa_id);
        if (adapter->dma_devs == NULL) {
                RTE_EDEV_LOG_ERR("Failed to get memory for DMA devices");
                edma_circular_buffer_free(&adapter->ebuf);
@@ -867,7 +867,7 @@ edma_init_service(struct event_dma_adapter *adapter, 
uint8_t id)
 
        memset(&service, 0, sizeof(service));
        snprintf(service.name, DMA_ADAPTER_NAME_LEN, 
"rte_event_dma_adapter_%d", id);
-       service.socket_id = adapter->socket_id;
+       service.socket_id = adapter->numa_id;
        service.callback = edma_service_func;
        service.callback_userdata = adapter;
 
@@ -946,15 +946,15 @@ edma_add_vchan(struct event_dma_adapter *adapter, int16_t 
dma_dev_id, uint16_t v
        if (dev_info->vchanq == NULL) {
                nb_vchans = dev_info->num_dma_dev_vchan;
 
-               dev_info->vchanq = rte_zmalloc_socket(adapter->mem_name,
+               dev_info->vchanq = rte_zmalloc_numa(adapter->mem_name,
                                nb_vchans * sizeof(struct dma_vchan_info),
-                               0, adapter->socket_id);
+                               0, adapter->numa_id);
                if (dev_info->vchanq == NULL)
                        return -ENOMEM;
 
-               dev_info->tqmap = rte_zmalloc_socket(adapter->mem_name,
+               dev_info->tqmap = rte_zmalloc_numa(adapter->mem_name,
                                nb_vchans * sizeof(struct dma_vchan_info),
-                               0, adapter->socket_id);
+                               0, adapter->numa_id);
                if (dev_info->tqmap == NULL)
                        return -ENOMEM;
 
@@ -1039,10 +1039,10 @@ rte_event_dma_adapter_vchan_add(uint8_t id, int16_t 
dma_dev_id, uint16_t vchan,
                if (dev->dev_ops->dma_adapter_vchan_add == NULL)
                        return -ENOTSUP;
                if (dev_info->vchanq == NULL) {
-                       dev_info->vchanq = rte_zmalloc_socket(adapter->mem_name,
+                       dev_info->vchanq = rte_zmalloc_numa(adapter->mem_name,
                                                        
dev_info->num_dma_dev_vchan *
                                                        sizeof(struct 
dma_vchan_info),
-                                                       0, adapter->socket_id);
+                                                       0, adapter->numa_id);
                        if (dev_info->vchanq == NULL) {
                                RTE_EDEV_LOG_ERR("Queue pair add not 
supported");
                                return -ENOMEM;
@@ -1050,10 +1050,10 @@ rte_event_dma_adapter_vchan_add(uint8_t id, int16_t 
dma_dev_id, uint16_t vchan,
                }
 
                if (dev_info->tqmap == NULL) {
-                       dev_info->tqmap = rte_zmalloc_socket(adapter->mem_name,
+                       dev_info->tqmap = rte_zmalloc_numa(adapter->mem_name,
                                                dev_info->num_dma_dev_vchan *
                                                sizeof(struct dma_vchan_info),
-                                               0, adapter->socket_id);
+                                               0, adapter->numa_id);
                        if (dev_info->tqmap == NULL) {
                                RTE_EDEV_LOG_ERR("tq pair add not supported");
                                return -ENOMEM;
diff --git a/lib/eventdev/rte_event_eth_rx_adapter.c 
b/lib/eventdev/rte_event_eth_rx_adapter.c
index 26c0a26db1..e87a6eca78 100644
--- a/lib/eventdev/rte_event_eth_rx_adapter.c
+++ b/lib/eventdev/rte_event_eth_rx_adapter.c
@@ -181,8 +181,8 @@ struct __rte_cache_aligned event_eth_rx_adapter {
        uint32_t nb_queues;
        /* Memory allocation name */
        char mem_name[ETH_RX_ADAPTER_MEM_NAME_LEN];
-       /* Socket identifier cached from eventdev */
-       int socket_id;
+       /* NUMA node identifier cached from eventdev */
+       int numa_id;
        /* Per adapter EAL service */
        uint32_t service_id;
        /* Adapter started flag */
@@ -586,10 +586,10 @@ rxa_alloc_poll(struct event_eth_rx_adapter *rx_adapter, 
uint32_t num_rx_polled)
 
        len  = RTE_ALIGN(num_rx_polled * sizeof(*rx_adapter->eth_rx_poll),
                                                        RTE_CACHE_LINE_SIZE);
-       return  rte_zmalloc_socket(rx_adapter->mem_name,
+       return  rte_zmalloc_numa(rx_adapter->mem_name,
                                len,
                                RTE_CACHE_LINE_SIZE,
-                               rx_adapter->socket_id);
+                               rx_adapter->numa_id);
 }
 
 /*
@@ -602,10 +602,10 @@ rxa_alloc_wrr(struct event_eth_rx_adapter *rx_adapter, 
int nb_wrr)
 
        len = RTE_ALIGN(nb_wrr * sizeof(*rx_adapter->wrr_sched),
                        RTE_CACHE_LINE_SIZE);
-       return  rte_zmalloc_socket(rx_adapter->mem_name,
+       return  rte_zmalloc_numa(rx_adapter->mem_name,
                                len,
                                RTE_CACHE_LINE_SIZE,
-                               rx_adapter->socket_id);
+                               rx_adapter->numa_id);
 }
 
 static int
@@ -1458,7 +1458,7 @@ rxa_memzone_array_get(const char *name, unsigned int 
elt_size, int nb_elems)
 
        mz = rte_memzone_lookup(name);
        if (mz == NULL) {
-               mz = rte_memzone_reserve_aligned(name, sz, rte_socket_id(), 0,
+               mz = rte_memzone_reserve_aligned(name, sz, rte_numa_id(), 0,
                                                 RTE_CACHE_LINE_SIZE);
                if (mz == NULL) {
                        RTE_EDEV_LOG_ERR("failed to reserve memzone"
@@ -1604,15 +1604,15 @@ rxa_create_intr_thread(struct event_eth_rx_adapter 
*rx_adapter)
 
        rx_adapter->intr_ring = rte_ring_create("intr_ring",
                                        RTE_EVENT_ETH_INTR_RING_SIZE,
-                                       rte_socket_id(), 0);
+                                       rte_numa_id(), 0);
        if (!rx_adapter->intr_ring)
                return -ENOMEM;
 
-       rx_adapter->epoll_events = rte_zmalloc_socket(rx_adapter->mem_name,
+       rx_adapter->epoll_events = rte_zmalloc_numa(rx_adapter->mem_name,
                                        RTE_EVENT_ETH_INTR_RING_SIZE *
                                        sizeof(struct rte_epoll_event),
                                        RTE_CACHE_LINE_SIZE,
-                                       rx_adapter->socket_id);
+                                       rx_adapter->numa_id);
        if (!rx_adapter->epoll_events) {
                err = -ENOMEM;
                goto error;
@@ -1782,11 +1782,11 @@ rxa_config_intr(struct event_eth_rx_adapter *rx_adapter,
                size_t len =
                        dev_info->dev->data->nb_rx_queues * sizeof(uint16_t);
                dev_info->intr_queue =
-                       rte_zmalloc_socket(
+                       rte_zmalloc_numa(
                                rx_adapter->mem_name,
                                len,
                                0,
-                               rx_adapter->socket_id);
+                               rx_adapter->numa_id);
                if (dev_info->intr_queue == NULL)
                        return -ENOMEM;
        }
@@ -1922,7 +1922,7 @@ rxa_init_service(struct event_eth_rx_adapter *rx_adapter, 
uint8_t id)
        memset(&service, 0, sizeof(service));
        snprintf(service.name, ETH_RX_ADAPTER_SERVICE_NAME_LEN,
                "rte_event_eth_rx_adapter_%d", id);
-       service.socket_id = rx_adapter->socket_id;
+       service.socket_id = rx_adapter->numa_id;
        service.callback = rxa_service_func;
        service.callback_userdata = rx_adapter;
        /* Service function handles locking for queue add/del updates */
@@ -2148,9 +2148,9 @@ rxa_add_queue(struct event_eth_rx_adapter *rx_adapter,
        if (!rx_adapter->use_queue_event_buf)
                return 0;
 
-       new_rx_buf = rte_zmalloc_socket("rx_buffer_meta",
+       new_rx_buf = rte_zmalloc_numa("rx_buffer_meta",
                                sizeof(*new_rx_buf), 0,
-                               rte_eth_dev_socket_id(eth_dev_id));
+                               rte_eth_dev_numa_id(eth_dev_id));
        if (new_rx_buf == NULL) {
                RTE_EDEV_LOG_ERR("Failed to allocate event buffer meta for "
                                 "dev_id: %d queue_id: %d",
@@ -2160,10 +2160,10 @@ rxa_add_queue(struct event_eth_rx_adapter *rx_adapter,
 
        new_rx_buf->events_size = RTE_ALIGN(conf->event_buf_size, BATCH_SIZE);
        new_rx_buf->events_size += (2 * BATCH_SIZE);
-       new_rx_buf->events = rte_zmalloc_socket("rx_buffer",
+       new_rx_buf->events = rte_zmalloc_numa("rx_buffer",
                                sizeof(struct rte_event) *
                                new_rx_buf->events_size, 0,
-                               rte_eth_dev_socket_id(eth_dev_id));
+                               rte_eth_dev_numa_id(eth_dev_id));
        if (new_rx_buf->events == NULL) {
                rte_free(new_rx_buf);
                RTE_EDEV_LOG_ERR("Failed to allocate event buffer for "
@@ -2175,9 +2175,9 @@ rxa_add_queue(struct event_eth_rx_adapter *rx_adapter,
        queue_info->event_buf = new_rx_buf;
 
        /* Allocate storage for adapter queue stats */
-       stats = rte_zmalloc_socket("rx_queue_stats",
+       stats = rte_zmalloc_numa("rx_queue_stats",
                                sizeof(*stats), 0,
-                               rte_eth_dev_socket_id(eth_dev_id));
+                               rte_eth_dev_numa_id(eth_dev_id));
        if (stats == NULL) {
                rte_free(new_rx_buf->events);
                rte_free(new_rx_buf);
@@ -2236,10 +2236,10 @@ rxa_sw_add(struct event_eth_rx_adapter *rx_adapter, 
uint16_t eth_dev_id,
 
        if (dev_info->rx_queue == NULL) {
                dev_info->rx_queue =
-                   rte_zmalloc_socket(rx_adapter->mem_name,
+                   rte_zmalloc_numa(rx_adapter->mem_name,
                                       nb_rx_queues *
                                       sizeof(struct eth_rx_queue_info), 0,
-                                      rx_adapter->socket_id);
+                                      rx_adapter->numa_id);
                if (dev_info->rx_queue == NULL)
                        return -ENOMEM;
        }
@@ -2386,7 +2386,7 @@ rxa_create(uint8_t id, uint8_t dev_id,
        struct eth_event_enqueue_buffer *buf;
        struct rte_event *events;
        int ret;
-       int socket_id;
+       int numa_id;
        uint16_t i;
        char mem_name[ETH_RX_ADAPTER_SERVICE_NAME_LEN];
        const uint8_t default_rss_key[] = {
@@ -2415,29 +2415,29 @@ rxa_create(uint8_t id, uint8_t dev_id,
                return -EEXIST;
        }
 
-       socket_id = rte_event_dev_socket_id(dev_id);
+       numa_id = rte_event_dev_numa_id(dev_id);
        snprintf(mem_name, ETH_RX_ADAPTER_MEM_NAME_LEN,
                "rte_event_eth_rx_adapter_%d",
                id);
 
-       rx_adapter = rte_zmalloc_socket(mem_name, sizeof(*rx_adapter),
-                       RTE_CACHE_LINE_SIZE, socket_id);
+       rx_adapter = rte_zmalloc_numa(mem_name, sizeof(*rx_adapter),
+                       RTE_CACHE_LINE_SIZE, numa_id);
        if (rx_adapter == NULL) {
                RTE_EDEV_LOG_ERR("failed to get mem for rx adapter");
                return -ENOMEM;
        }
 
        rx_adapter->eventdev_id = dev_id;
-       rx_adapter->socket_id = socket_id;
+       rx_adapter->numa_id = numa_id;
        rx_adapter->conf_cb = conf_cb;
        rx_adapter->conf_arg = conf_arg;
        rx_adapter->id = id;
        TAILQ_INIT(&rx_adapter->vector_list);
        strcpy(rx_adapter->mem_name, mem_name);
-       rx_adapter->eth_devices = rte_zmalloc_socket(rx_adapter->mem_name,
+       rx_adapter->eth_devices = rte_zmalloc_numa(rx_adapter->mem_name,
                                        RTE_MAX_ETHPORTS *
                                        sizeof(struct eth_device_info), 0,
-                                       socket_id);
+                                       numa_id);
        rte_convert_rss_key((const uint32_t *)default_rss_key,
                        (uint32_t *)rx_adapter->rss_key_be,
                            RTE_DIM(default_rss_key));
@@ -2460,9 +2460,9 @@ rxa_create(uint8_t id, uint8_t dev_id,
                buf = &rx_adapter->event_enqueue_buffer;
                buf->events_size = rxa_params->event_buf_size;
 
-               events = rte_zmalloc_socket(rx_adapter->mem_name,
+               events = rte_zmalloc_numa(rx_adapter->mem_name,
                                            buf->events_size * sizeof(*events),
-                                           0, socket_id);
+                                           0, numa_id);
                if (events == NULL) {
                        RTE_EDEV_LOG_ERR("Failed to allocate memory "
                                         "for adapter event buffer");
@@ -2757,10 +2757,10 @@ rte_event_eth_rx_adapter_queue_add(uint8_t id,
                        return -ENOTSUP;
                if (dev_info->rx_queue == NULL) {
                        dev_info->rx_queue =
-                           rte_zmalloc_socket(rx_adapter->mem_name,
+                           rte_zmalloc_numa(rx_adapter->mem_name,
                                        dev_info->dev->data->nb_rx_queues *
                                        sizeof(struct eth_rx_queue_info), 0,
-                                       rx_adapter->socket_id);
+                                       rx_adapter->numa_id);
                        if (dev_info->rx_queue == NULL)
                                return -ENOMEM;
                }
@@ -2913,10 +2913,10 @@ rte_event_eth_rx_adapter_queues_add(uint8_t id, 
uint16_t eth_dev_id, int32_t rx_
 
                if (dev_info->rx_queue == NULL) {
                        dev_info->rx_queue =
-                               rte_zmalloc_socket(rx_adapter->mem_name,
+                               rte_zmalloc_numa(rx_adapter->mem_name,
                                                   
dev_info->dev->data->nb_rx_queues *
                                                           sizeof(struct 
eth_rx_queue_info),
-                                                  0, rx_adapter->socket_id);
+                                                  0, rx_adapter->numa_id);
                        if (dev_info->rx_queue == NULL)
                                return -ENOMEM;
                }
diff --git a/lib/eventdev/rte_event_eth_tx_adapter.c 
b/lib/eventdev/rte_event_eth_tx_adapter.c
index b3edd9f6fb..c57d6b868c 100644
--- a/lib/eventdev/rte_event_eth_tx_adapter.c
+++ b/lib/eventdev/rte_event_eth_tx_adapter.c
@@ -139,8 +139,8 @@ struct __rte_cache_aligned txa_service_data {
        rte_event_eth_tx_adapter_conf_cb conf_cb;
        /* Configuration callback argument */
        void *conf_arg;
-       /* socket id */
-       int socket_id;
+       /* NUMA node id */
+       int numa_id;
        /* Per adapter EAL service */
        int64_t service_id;
        /* Memory allocation name */
@@ -197,7 +197,7 @@ txa_memzone_array_get(const char *name, unsigned int 
elt_size, int nb_elems)
 
        mz = rte_memzone_lookup(name);
        if (mz == NULL) {
-               mz = rte_memzone_reserve_aligned(name, sz, rte_socket_id(), 0,
+               mz = rte_memzone_reserve_aligned(name, sz, rte_numa_id(), 0,
                                                 RTE_CACHE_LINE_SIZE);
                if (mz == NULL) {
                        RTE_EDEV_LOG_ERR("failed to reserve memzone"
@@ -361,10 +361,10 @@ txa_service_ethdev_alloc(struct txa_service_data *txa)
        if (txa->txa_ethdev && dev_count == txa->dev_count)
                return 0;
 
-       txa_ethdev = rte_zmalloc_socket(txa->mem_name,
+       txa_ethdev = rte_zmalloc_numa(txa->mem_name,
                                        dev_count * sizeof(*txa_ethdev),
                                        0,
-                                       txa->socket_id);
+                                       txa->numa_id);
        if (txa_ethdev == NULL) {
                RTE_EDEV_LOG_ERR("Failed to alloc txa::txa_ethdev ");
                return -ENOMEM;
@@ -401,10 +401,10 @@ txa_service_queue_array_alloc(struct txa_service_data 
*txa,
                return 0;
 
        nb_queue = txa->txa_ethdev[port_id].dev->data->nb_tx_queues;
-       tqi = rte_zmalloc_socket(txa->mem_name,
+       tqi = rte_zmalloc_numa(txa->mem_name,
                                nb_queue *
                                sizeof(struct txa_service_queue_info), 0,
-                               txa->socket_id);
+                               txa->numa_id);
        if (tqi == NULL)
                return -ENOMEM;
        txa->txa_ethdev[port_id].queues = tqi;
@@ -456,7 +456,7 @@ txa_service_register(struct txa_service_data *txa)
 
        memset(&service, 0, sizeof(service));
        snprintf(service.name, TXA_SERVICE_NAME_LEN, "txa_%d", txa->id);
-       service.socket_id = txa->socket_id;
+       service.socket_id = txa->numa_id;
        service.callback = txa_service_func;
        service.callback_userdata = txa;
        service.capabilities = RTE_SERVICE_CAP_MT_SAFE;
@@ -488,10 +488,10 @@ txa_service_tx_buf_alloc(struct txa_service_data *txa,
        uint16_t port_id;
 
        port_id = dev->data->port_id;
-       tb = rte_zmalloc_socket(txa->mem_name,
+       tb = rte_zmalloc_numa(txa->mem_name,
                                RTE_ETH_TX_BUFFER_SIZE(TXA_BATCH_SIZE),
                                0,
-                               rte_eth_dev_socket_id(port_id));
+                               rte_eth_dev_numa_id(port_id));
        if (tb == NULL)
                RTE_EDEV_LOG_ERR("Failed to allocate memory for tx buffer");
        return tb;
@@ -740,14 +740,14 @@ txa_service_adapter_create_ext(uint8_t id, struct 
rte_eventdev *dev,
                        void *conf_arg)
 {
        struct txa_service_data *txa;
-       int socket_id;
+       int numa_id;
        char mem_name[TXA_SERVICE_NAME_LEN];
        int ret;
 
        if (conf_cb == NULL)
                return -EINVAL;
 
-       socket_id = dev->data->socket_id;
+       numa_id = dev->data->numa_id;
        snprintf(mem_name, sizeof(mem_name),
                "rte_event_eth_txa_%d",
                id);
@@ -756,9 +756,9 @@ txa_service_adapter_create_ext(uint8_t id, struct 
rte_eventdev *dev,
        if (ret != 0)
                return ret;
 
-       txa = rte_zmalloc_socket(mem_name,
+       txa = rte_zmalloc_numa(mem_name,
                                sizeof(*txa),
-                               RTE_CACHE_LINE_SIZE, socket_id);
+                               RTE_CACHE_LINE_SIZE, numa_id);
        if (txa == NULL) {
                RTE_EDEV_LOG_ERR("failed to get mem for tx adapter");
                return -ENOMEM;
@@ -766,7 +766,7 @@ txa_service_adapter_create_ext(uint8_t id, struct 
rte_eventdev *dev,
 
        txa->id = id;
        txa->eventdev_id = dev->data->dev_id;
-       txa->socket_id = socket_id;
+       txa->numa_id = numa_id;
        strlcpy(txa->mem_name, mem_name, sizeof(txa->mem_name));
        txa->conf_cb = conf_cb;
        txa->conf_arg = conf_arg;
diff --git a/lib/eventdev/rte_event_ring.c b/lib/eventdev/rte_event_ring.c
index 5718985486..2fc54e4948 100644
--- a/lib/eventdev/rte_event_ring.c
+++ b/lib/eventdev/rte_event_ring.c
@@ -26,14 +26,14 @@ rte_event_ring_init(struct rte_event_ring *r, const char 
*name,
 /* create the ring */
 RTE_EXPORT_SYMBOL(rte_event_ring_create)
 struct rte_event_ring *
-rte_event_ring_create(const char *name, unsigned int count, int socket_id,
+rte_event_ring_create(const char *name, unsigned int count, int numa_id,
                unsigned int flags)
 {
-       rte_eventdev_trace_ring_create(name, count, socket_id, flags);
+       rte_eventdev_trace_ring_create(name, count, numa_id, flags);
 
        return (struct rte_event_ring *)rte_ring_create_elem(name,
                                                sizeof(struct rte_event),
-                                               count, socket_id, flags);
+                                               count, numa_id, flags);
 }
 
 
diff --git a/lib/eventdev/rte_event_ring.h b/lib/eventdev/rte_event_ring.h
index 2196022798..52a7f34416 100644
--- a/lib/eventdev/rte_event_ring.h
+++ b/lib/eventdev/rte_event_ring.h
@@ -271,9 +271,9 @@ rte_event_ring_free(struct rte_event_ring *r);
  *   usable space in the ring will be ``count - 1`` entries. If the flag
  *   ``RING_F_EXACT_SZ`` is set, the this can be any value up to the ring size
  *   limit - 1, and the usable space will be exactly that requested.
- * @param socket_id
- *   The *socket_id* argument is the socket identifier in case of
- *   NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA
+ * @param numa_id
+ *   The *numa_id* argument is the NUMA node ID in case of
+ *   NUMA. The value can be *RTE_NUMA_ID_ANY* if there is no NUMA
  *   constraint for the reserved zone.
  * @param flags
  *   An OR of the following:
@@ -298,7 +298,7 @@ rte_event_ring_free(struct rte_event_ring *r);
  *    - ENOMEM - no appropriate memory area found in which to create memzone
  */
 struct rte_event_ring *
-rte_event_ring_create(const char *name, unsigned int count, int socket_id, 
unsigned int flags)
+rte_event_ring_create(const char *name, unsigned int count, int numa_id, 
unsigned int flags)
        __rte_malloc __rte_dealloc(rte_event_ring_free, 1);
 
 /**
diff --git a/lib/eventdev/rte_event_timer_adapter.c 
b/lib/eventdev/rte_event_timer_adapter.c
index a76d10f505..de33fd9f95 100644
--- a/lib/eventdev/rte_event_timer_adapter.c
+++ b/lib/eventdev/rte_event_timer_adapter.c
@@ -201,7 +201,7 @@ rte_event_timer_adapter_create_ext(
        }
        mz = rte_memzone_reserve(mz_name,
                                 sizeof(struct rte_event_timer_adapter_data),
-                                conf->socket_id, 0);
+                                conf->numa_id, 0);
        if (mz == NULL)
                /* rte_errno set by rte_memzone_reserve */
                return NULL;
@@ -212,7 +212,7 @@ rte_event_timer_adapter_create_ext(
        adapter->data->mz = mz;
        adapter->data->event_dev_id = conf->event_dev_id;
        adapter->data->id = adapter_id;
-       adapter->data->socket_id = conf->socket_id;
+       adapter->data->numa_id = conf->numa_id;
        adapter->data->conf = *conf;  /* copy conf structure */
 
        /* Query eventdev PMD for timer adapter capabilities and ops */
@@ -931,8 +931,8 @@ swtim_init(struct rte_event_timer_adapter *adapter)
        char swtim_name[SWTIM_NAMESIZE];
        snprintf(swtim_name, SWTIM_NAMESIZE, "swtim_%"PRIu8,
                        adapter->data->id);
-       sw = rte_zmalloc_socket(swtim_name, sizeof(*sw), RTE_CACHE_LINE_SIZE,
-                       adapter->data->socket_id);
+       sw = rte_zmalloc_numa(swtim_name, sizeof(*sw), RTE_CACHE_LINE_SIZE,
+                       adapter->data->numa_id);
        if (sw == NULL) {
                EVTIM_LOG_ERR("failed to allocate space for private data");
                rte_errno = ENOMEM;
@@ -958,7 +958,7 @@ swtim_init(struct rte_event_timer_adapter *adapter)
        flags = 0; /* pool is multi-producer, multi-consumer */
        sw->tim_pool = rte_mempool_create(pool_name, pool_size,
                        sizeof(struct rte_timer), cache_size, 0, NULL, NULL,
-                       NULL, NULL, adapter->data->socket_id, flags);
+                       NULL, NULL, adapter->data->numa_id, flags);
        if (sw->tim_pool == NULL) {
                EVTIM_LOG_ERR("failed to create timer object mempool");
                rte_errno = ENOMEM;
@@ -995,7 +995,7 @@ swtim_init(struct rte_event_timer_adapter *adapter)
        memset(&service, 0, sizeof(service));
        snprintf(service.name, RTE_SERVICE_NAME_MAX,
                 "swtim_svc_%"PRIu8, adapter->data->id);
-       service.socket_id = adapter->data->socket_id;
+       service.socket_id = adapter->data->numa_id;
        service.callback = swtim_service_func;
        service.callback_userdata = adapter;
        service.capabilities &= ~(RTE_SERVICE_CAP_MT_SAFE);
@@ -1429,8 +1429,8 @@ handle_ta_info(const char *cmd __rte_unused, const char 
*params,
        rte_tel_data_add_dict_uint(d, "max_tmo_ns", adapter_info.max_tmo_ns);
        rte_tel_data_add_dict_uint(d, "event_dev_id",
                                   adapter_info.conf.event_dev_id);
-       rte_tel_data_add_dict_uint(d, "socket_id",
-                                  adapter_info.conf.socket_id);
+       rte_tel_data_add_dict_uint(d, "numa_id",
+                                  adapter_info.conf.numa_id);
        rte_tel_data_add_dict_uint(d, "clk_src", adapter_info.conf.clk_src);
        rte_tel_data_add_dict_uint(d, "timer_tick_ns",
                                   adapter_info.conf.timer_tick_ns);
diff --git a/lib/eventdev/rte_event_timer_adapter.h 
b/lib/eventdev/rte_event_timer_adapter.h
index 215584b10b..8f9fae5f2e 100644
--- a/lib/eventdev/rte_event_timer_adapter.h
+++ b/lib/eventdev/rte_event_timer_adapter.h
@@ -165,8 +165,15 @@ struct rte_event_timer_adapter_conf {
        /**< Event device identifier */
        uint16_t timer_adapter_id;
        /**< Event timer adapter identifier */
-       uint32_t socket_id;
-       /**< Identifier of socket from which to allocate memory for adapter */
+       union {
+               /** NUMA node ID from which to allocate memory for adapter */
+               uint32_t numa_id;
+               /**
+                * Deprecated alias of numa_id.
+                */
+               __rte_deprecated_msg("use numa_id")
+               uint32_t socket_id;
+       };
        enum rte_event_timer_adapter_clk_src clk_src;
        /**< Clock source for timer adapter */
        uint64_t timer_tick_ns;
diff --git a/lib/eventdev/rte_event_vector_adapter.c 
b/lib/eventdev/rte_event_vector_adapter.c
index 9a839517c8..6222f1c907 100644
--- a/lib/eventdev/rte_event_vector_adapter.c
+++ b/lib/eventdev/rte_event_vector_adapter.c
@@ -253,7 +253,7 @@ rte_event_vector_adapter_create_ext(const struct 
rte_event_vector_adapter_conf *
                goto error;
        }
        mz = rte_memzone_reserve(mz_name, sizeof(struct 
rte_event_vector_adapter_data),
-                                conf->socket_id, 0);
+                                conf->numa_id, 0);
        if (mz == NULL) {
                adapter->ops = NULL;
                EVVEC_LOG_DBG("failed to reserve memzone for vector adapter");
@@ -267,7 +267,7 @@ rte_event_vector_adapter_create_ext(const struct 
rte_event_vector_adapter_conf *
        adapter->data->mz = mz;
        adapter->data->event_dev_id = conf->event_dev_id;
        adapter->data->id = adapter->adapter_id;
-       adapter->data->socket_id = conf->socket_id;
+       adapter->data->numa_id = conf->numa_id;
        adapter->data->conf = *conf;
 
        if (!(caps & RTE_EVENT_VECTOR_ADAPTER_CAP_INTERNAL_PORT)) {
@@ -641,7 +641,7 @@ sw_vector_adapter_service_init(struct 
sw_vector_adapter_data *sw)
        if (mz == NULL) {
                mz = rte_memzone_reserve(SW_VECTOR_ADAPTER_SERVICE_FMT,
                                         sizeof(struct 
sw_vector_adapter_service_data),
-                                        sw->adapter->data->socket_id, 0);
+                                        sw->adapter->data->numa_id, 0);
                if (mz == NULL) {
                        EVVEC_LOG_DBG("failed to reserve memzone for service");
                        return -ENOMEM;
@@ -650,7 +650,7 @@ sw_vector_adapter_service_init(struct 
sw_vector_adapter_data *sw)
                memset(service_data, 0, sizeof(*service_data));
 
                ring = rte_ring_create(SW_VECTOR_ADAPTER_SERVICE_FMT, 
SERVICE_RING_SZ,
-                                      sw->adapter->data->socket_id, 0);
+                                      sw->adapter->data->numa_id, 0);
                if (ring == NULL) {
                        EVVEC_LOG_ERR("failed to create ring for service");
                        rte_memzone_free(mz);
@@ -662,7 +662,7 @@ sw_vector_adapter_service_init(struct 
sw_vector_adapter_data *sw)
                snprintf(service.name, RTE_SERVICE_NAME_MAX, "%s", 
SW_VECTOR_ADAPTER_SERVICE_FMT);
                service.callback = sw_vector_adapter_service_func;
                service.callback_userdata = service_data;
-               service.socket_id = sw->adapter->data->socket_id;
+               service.socket_id = sw->adapter->data->numa_id;
 
                ret = rte_service_component_register(&service, 
&service_data->service_id);
                if (ret < 0) {
@@ -696,7 +696,7 @@ sw_vector_adapter_create(struct rte_event_vector_adapter 
*adapter)
        struct rte_event ev;
 
        snprintf(name, SW_VECTOR_ADAPTER_NAME, "sw_vector_%" PRIx32, 
adapter->data->id);
-       sw = rte_zmalloc_socket(name, sizeof(*sw), RTE_CACHE_LINE_SIZE, 
adapter->data->socket_id);
+       sw = rte_zmalloc_numa(name, sizeof(*sw), RTE_CACHE_LINE_SIZE, 
adapter->data->numa_id);
        if (sw == NULL) {
                EVVEC_LOG_ERR("failed to allocate space for private data");
                rte_errno = ENOMEM;
diff --git a/lib/eventdev/rte_event_vector_adapter.h 
b/lib/eventdev/rte_event_vector_adapter.h
index e85c79010e..cc29aa4baa 100644
--- a/lib/eventdev/rte_event_vector_adapter.h
+++ b/lib/eventdev/rte_event_vector_adapter.h
@@ -136,8 +136,15 @@ extern "C" {
 struct rte_event_vector_adapter_conf {
        uint8_t event_dev_id;
        /**< Event device identifier */
-       uint32_t socket_id;
-       /**< Identifier of socket from which to allocate memory for adapter */
+       union {
+               /** NUMA node ID from which to allocate memory for adapter */
+               uint32_t numa_id;
+               /**
+                * Deprecated alias of numa_id.
+                */
+               __rte_deprecated_msg("use numa_id")
+               uint32_t socket_id;
+       };
        struct rte_event ev;
        /**<
         *  The values from the following event fields will be used when
diff --git a/lib/eventdev/rte_eventdev.c b/lib/eventdev/rte_eventdev.c
index 71de25a3ab..7426fa9e7f 100644
--- a/lib/eventdev/rte_eventdev.c
+++ b/lib/eventdev/rte_eventdev.c
@@ -80,18 +80,25 @@ rte_event_dev_get_dev_id(const char *name)
        return -ENODEV;
 }
 
-RTE_EXPORT_SYMBOL(rte_event_dev_socket_id)
+RTE_EXPORT_SYMBOL(rte_event_dev_numa_id)
 int
-rte_event_dev_socket_id(uint8_t dev_id)
+rte_event_dev_numa_id(uint8_t dev_id)
 {
        struct rte_eventdev *dev;
 
        RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
        dev = &rte_eventdevs[dev_id];
 
-       rte_eventdev_trace_socket_id(dev_id, dev, dev->data->socket_id);
+       rte_eventdev_trace_numa_id(dev_id, dev, dev->data->numa_id);
+
+       return dev->data->numa_id;
+}
 
-       return dev->data->socket_id;
+RTE_EXPORT_SYMBOL(rte_event_dev_socket_id)
+int
+rte_event_dev_socket_id(uint8_t dev_id)
+{
+       return rte_event_dev_numa_id(dev_id);
 }
 
 RTE_EXPORT_SYMBOL(rte_event_dev_info_get)
@@ -1481,7 +1488,7 @@ RTE_EXPORT_SYMBOL(rte_event_vector_pool_create)
 struct rte_mempool *
 rte_event_vector_pool_create(const char *name, unsigned int n,
                             unsigned int cache_size, uint16_t nb_elem,
-                            int socket_id)
+                            int numa_id)
 {
        const char *mp_ops_name;
        struct rte_mempool *mp;
@@ -1497,7 +1504,7 @@ rte_event_vector_pool_create(const char *name, unsigned 
int n,
 
        elt_sz =
                sizeof(struct rte_event_vector) + (nb_elem * sizeof(uintptr_t));
-       mp = rte_mempool_create_empty(name, n, elt_sz, cache_size, 0, socket_id,
+       mp = rte_mempool_create_empty(name, n, elt_sz, cache_size, 0, numa_id,
                                      0);
        if (mp == NULL)
                return NULL;
@@ -1626,7 +1633,7 @@ rte_event_dev_close(uint8_t dev_id)
 
 static inline int
 eventdev_data_alloc(uint8_t dev_id, struct rte_eventdev_data **data,
-                   int socket_id)
+                   int numa_id)
 {
        char mz_name[RTE_EVENTDEV_NAME_MAX_LEN];
        const struct rte_memzone *mz;
@@ -1640,7 +1647,7 @@ eventdev_data_alloc(uint8_t dev_id, struct 
rte_eventdev_data **data,
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
                mz = rte_memzone_reserve(mz_name,
                                sizeof(struct rte_eventdev_data),
-                               socket_id, 0);
+                               numa_id, 0);
        } else
                mz = rte_memzone_lookup(mz_name);
 
@@ -1674,7 +1681,7 @@ eventdev_find_free_device_index(void)
 
 RTE_EXPORT_INTERNAL_SYMBOL(rte_event_pmd_allocate)
 struct rte_eventdev *
-rte_event_pmd_allocate(const char *name, int socket_id)
+rte_event_pmd_allocate(const char *name, int numa_id)
 {
        struct rte_eventdev *eventdev;
        uint8_t dev_id;
@@ -1697,7 +1704,7 @@ rte_event_pmd_allocate(const char *name, int socket_id)
                struct rte_eventdev_data *eventdev_data = NULL;
 
                int retval =
-                       eventdev_data_alloc(dev_id, &eventdev_data, socket_id);
+                       eventdev_data_alloc(dev_id, &eventdev_data, numa_id);
 
                if (retval < 0 || eventdev_data == NULL)
                        return NULL;
@@ -1710,7 +1717,7 @@ rte_event_pmd_allocate(const char *name, int socket_id)
                                RTE_EVENTDEV_NAME_MAX_LEN);
 
                        eventdev->data->dev_id = dev_id;
-                       eventdev->data->socket_id = socket_id;
+                       eventdev->data->numa_id = numa_id;
                        eventdev->data->dev_started = 0;
                }
 
@@ -1838,7 +1845,7 @@ handle_dev_info(const char *cmd __rte_unused,
        rte_tel_data_add_dict_string(d, "dev_driver", 
dev->device->driver->name);
        rte_tel_data_add_dict_string(d, "state",
                dev->data->dev_started ? "started" : "stopped");
-       rte_tel_data_add_dict_int(d, "socket_id", dev->data->socket_id);
+       rte_tel_data_add_dict_int(d, "numa_id", dev->data->numa_id);
        rte_tel_data_add_dict_int(d, "nb_queues", dev->data->nb_queues);
        rte_tel_data_add_dict_int(d, "nb_ports", dev->data->nb_ports);
        rte_tel_data_add_dict_uint_hex(d, "capabilities", 
dev->data->event_dev_cap,
diff --git a/lib/eventdev/rte_eventdev.h b/lib/eventdev/rte_eventdev.h
index 34b1804285..1aaae6469b 100644
--- a/lib/eventdev/rte_eventdev.h
+++ b/lib/eventdev/rte_eventdev.h
@@ -580,9 +580,25 @@ rte_event_dev_count(void);
 int
 rte_event_dev_get_dev_id(const char *name);
 
+/**
+ * Return the NUMA node to which a device is connected.
+ *
+ * @param dev_id
+ *   The identifier of the device.
+ * @return
+ *   The NUMA node ID to which the device is connected or
+ *   a default of zero if the NUMA node could not be determined.
+ *   -EINVAL on error, where the given dev_id value does not
+ *   correspond to any event device.
+ */
+int
+rte_event_dev_numa_id(uint8_t dev_id);
+
 /**
  * Return the NUMA socket to which a device is connected.
  *
+ * This is a legacy alias of rte_event_dev_numa_id().
+ *
  * @param dev_id
  *   The identifier of the device.
  * @return
@@ -2554,9 +2570,9 @@ int rte_event_dev_selftest(uint8_t dev_id);
  *   details.
  * @param nb_elem
  *   The number of elements that a single event vector should be able to hold.
- * @param socket_id
- *   The socket identifier where the memory should be allocated. The
- *   value can be *SOCKET_ID_ANY* if there is no NUMA constraint for the
+ * @param numa_id
+ *   The NUMA node ID where the memory should be allocated. The
+ *   value can be *RTE_NUMA_ID_ANY* if there is no NUMA constraint for the
  *   reserved zone
  *
  * @return
@@ -2573,7 +2589,7 @@ int rte_event_dev_selftest(uint8_t dev_id);
 struct rte_mempool *
 rte_event_vector_pool_create(const char *name, unsigned int n,
                             unsigned int cache_size, uint16_t nb_elem,
-                            int socket_id);
+                            int numa_id);
 
 #include <rte_eventdev_core.h>
 
-- 
2.55.0

Reply via email to