> For legacy modes, rename ring_generic/c11 to ring_generic/c11_pvt.
> Furthermore, add new file ring_elem_pvt.h which includes ring_do_eq/deq
> and ring element copy/delete APIs.
>
> For other modes, rename xx_c11_mem to xx_elem_pvt. Move all private APIs
> into these new header files.
>
> Suggested-by: Honnappa Nagarahalli <honnappa.nagaraha...@arm.com>
> Signed-off-by: Feifei Wang <feifei.wa...@arm.com>
> Reviewed-by: Honnappa Nagarahalli <honnappa.nagaraha...@arm.com>
> Reviewed-by: Ruifeng Wang <ruifeng.w...@arm.com>
> ---
> lib/librte_ring/meson.build | 15 +-
> .../{rte_ring_c11_mem.h => ring_c11_pvt.h} | 9 +-
> lib/librte_ring/ring_elem_pvt.h | 385 ++++++++++++++++++
> ...{rte_ring_generic.h => ring_generic_pvt.h} | 6 +-
> ...ring_hts_c11_mem.h => ring_hts_elem_pvt.h} | 88 +++-
> ...ng_peek_c11_mem.h => ring_peek_elem_pvt.h} | 75 +++-
> ...ring_rts_c11_mem.h => ring_rts_elem_pvt.h} | 88 +++-
> lib/librte_ring/rte_ring_elem.h | 374 +----------------
> lib/librte_ring/rte_ring_hts.h | 84 +---
> lib/librte_ring/rte_ring_peek.h | 71 +---
> lib/librte_ring/rte_ring_peek_zc.h | 2 +-
> lib/librte_ring/rte_ring_rts.h | 84 +---
> 12 files changed, 646 insertions(+), 635 deletions(-)
> rename lib/librte_ring/{rte_ring_c11_mem.h => ring_c11_pvt.h} (96%)
> create mode 100644 lib/librte_ring/ring_elem_pvt.h
> rename lib/librte_ring/{rte_ring_generic.h => ring_generic_pvt.h} (98%)
> rename lib/librte_ring/{rte_ring_hts_c11_mem.h => ring_hts_elem_pvt.h} (60%)
> rename lib/librte_ring/{rte_ring_peek_c11_mem.h => ring_peek_elem_pvt.h}
> (62%)
> rename lib/librte_ring/{rte_ring_rts_c11_mem.h => ring_rts_elem_pvt.h} (62%)
>
Sorry, but I don't understand the purpose of that patch.
As I remember by DPDK naming convention all installable headers
should have 'rte_' prefix. Same for public defines (RTE_).
Why to abandon it here?
> diff --git a/lib/librte_ring/meson.build b/lib/librte_ring/meson.build
> index 36fdcb6a5..98eac5810 100644
> --- a/lib/librte_ring/meson.build
> +++ b/lib/librte_ring/meson.build
> @@ -2,15 +2,16 @@
> # Copyright(c) 2017 Intel Corporation
>
> sources = files('rte_ring.c')
> -headers = files('rte_ring.h',
> +headers = files('ring_c11_pvt.h',
> + 'ring_elem_pvt.h',
> + 'ring_generic_pvt.h',
> + 'ring_hts_elem_pvt.h',
> + 'ring_peek_elem_pvt.h',
> + 'ring_rts_elem_pvt.h',
> + 'rte_ring.h',
> 'rte_ring_core.h',
> 'rte_ring_elem.h',
> - 'rte_ring_c11_mem.h',
> - 'rte_ring_generic.h',
> 'rte_ring_hts.h',
> - 'rte_ring_hts_c11_mem.h',
> 'rte_ring_peek.h',
> - 'rte_ring_peek_c11_mem.h',
> 'rte_ring_peek_zc.h',
> - 'rte_ring_rts.h',
> - 'rte_ring_rts_c11_mem.h')
> + 'rte_ring_rts.h')
> diff --git a/lib/librte_ring/rte_ring_c11_mem.h
> b/lib/librte_ring/ring_c11_pvt.h
> similarity index 96%
> rename from lib/librte_ring/rte_ring_c11_mem.h
> rename to lib/librte_ring/ring_c11_pvt.h
> index 7f5eba262..9f2f5318f 100644
> --- a/lib/librte_ring/rte_ring_c11_mem.h
> +++ b/lib/librte_ring/ring_c11_pvt.h
> @@ -7,8 +7,8 @@
> * Used as BSD-3 Licensed with permission from Kip Macy.
> */
>
> -#ifndef _RTE_RING_C11_MEM_H_
> -#define _RTE_RING_C11_MEM_H_
> +#ifndef _RING_C11_PVT_H_
> +#define _RING_C11_PVT_H_
>
> static __rte_always_inline void
> __rte_ring_update_tail(struct rte_ring_headtail *ht, uint32_t old_val,
> @@ -69,9 +69,6 @@ __rte_ring_move_prod_head(struct rte_ring *r, unsigned int
> is_sp,
> /* Ensure the head is read before tail */
> __atomic_thread_fence(__ATOMIC_ACQUIRE);
>
> - /* load-acquire synchronize with store-release of ht->tail
> - * in update_tail.
> - */
> cons_tail = __atomic_load_n(&r->cons.tail,
> __ATOMIC_ACQUIRE);
>
> @@ -178,4 +175,4 @@ __rte_ring_move_cons_head(struct rte_ring *r, int is_sc,
> return n;
> }
>
> -#endif /* _RTE_RING_C11_MEM_H_ */
> +#endif /* _RING_C11_PVT_H_ */
> diff --git a/lib/librte_ring/ring_elem_pvt.h b/lib/librte_ring/ring_elem_pvt.h
> new file mode 100644
> index 000000000..8003e5edc
> --- /dev/null
> +++ b/lib/librte_ring/ring_elem_pvt.h
> @@ -0,0 +1,385 @@
> +/* SPDX-License-Identifier: BSD-3-Clause
> + *
> + * Copyright (c) 2017,2018 HXT-semitech Corporation.
> + * Copyright (c) 2007-2009 Kip Macy km...@freebsd.org
> + * All rights reserved.
> + * Derived from FreeBSD's bufring.h
> + * Used as BSD-3 Licensed with permission from Kip Macy.
> + */
> +
> +#ifndef _RING_ELEM_PVT_H_
> +#define _RING_ELEM_PVT_H_
> +
> +static __rte_always_inline void
> +__rte_ring_enqueue_elems_32(struct rte_ring *r, const uint32_t size,
> + uint32_t idx, const void *obj_table, uint32_t n)
> +{
> + unsigned int i;
> + uint32_t *ring = (uint32_t *)&r[1];
> + const uint32_t *obj = (const uint32_t *)obj_table;
> + if (likely(idx + n < size)) {
> + for (i = 0; i < (n & ~0x7); i += 8, idx += 8) {
> + ring[idx] = obj[i];
> + ring[idx + 1] = obj[i + 1];
> + ring[idx + 2] = obj[i + 2];
> + ring[idx + 3] = obj[i + 3];
> + ring[idx + 4] = obj[i + 4];
> + ring[idx + 5] = obj[i + 5];
> + ring[idx + 6] = obj[i + 6];
> + ring[idx + 7] = obj[i + 7];
> + }
> + switch (n & 0x7) {
> + case 7:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 6:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 5:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 4:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 3:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 2:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 1:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + }
> + } else {
> + for (i = 0; idx < size; i++, idx++)
> + ring[idx] = obj[i];
> + /* Start at the beginning */
> + for (idx = 0; i < n; i++, idx++)
> + ring[idx] = obj[i];
> + }
> +}
> +
> +static __rte_always_inline void
> +__rte_ring_enqueue_elems_64(struct rte_ring *r, uint32_t prod_head,
> + const void *obj_table, uint32_t n)
> +{
> + unsigned int i;
> + const uint32_t size = r->size;
> + uint32_t idx = prod_head & r->mask;
> + uint64_t *ring = (uint64_t *)&r[1];
> + const unaligned_uint64_t *obj = (const unaligned_uint64_t *)obj_table;
> + if (likely(idx + n < size)) {
> + for (i = 0; i < (n & ~0x3); i += 4, idx += 4) {
> + ring[idx] = obj[i];
> + ring[idx + 1] = obj[i + 1];
> + ring[idx + 2] = obj[i + 2];
> + ring[idx + 3] = obj[i + 3];
> + }
> + switch (n & 0x3) {
> + case 3:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 2:
> + ring[idx++] = obj[i++]; /* fallthrough */
> + case 1:
> + ring[idx++] = obj[i++];
> + }
> + } else {
> + for (i = 0; idx < size; i++, idx++)
> + ring[idx] = obj[i];
> + /* Start at the beginning */
> + for (idx = 0; i < n; i++, idx++)
> + ring[idx] = obj[i];
> + }
> +}
> +
> +static __rte_always_inline void
> +__rte_ring_enqueue_elems_128(struct rte_ring *r, uint32_t prod_head,
> + const void *obj_table, uint32_t n)
> +{
> + unsigned int i;
> + const uint32_t size = r->size;
> + uint32_t idx = prod_head & r->mask;
> + rte_int128_t *ring = (rte_int128_t *)&r[1];
> + const rte_int128_t *obj = (const rte_int128_t *)obj_table;
> + if (likely(idx + n < size)) {
> + for (i = 0; i < (n & ~0x1); i += 2, idx += 2)
> + memcpy((void *)(ring + idx),
> + (const void *)(obj + i), 32);
> + switch (n & 0x1) {
> + case 1:
> + memcpy((void *)(ring + idx),
> + (const void *)(obj + i), 16);
> + }
> + } else {
> + for (i = 0; idx < size; i++, idx++)
> + memcpy((void *)(ring + idx),
> + (const void *)(obj + i), 16);
> + /* Start at the beginning */
> + for (idx = 0; i < n; i++, idx++)
> + memcpy((void *)(ring + idx),
> + (const void *)(obj + i), 16);
> + }
> +}
> +
> +/* the actual enqueue of elements on the ring.
> + * Placed here since identical code needed in both
> + * single and multi producer enqueue functions.
> + */
> +static __rte_always_inline void
> +__rte_ring_enqueue_elems(struct rte_ring *r, uint32_t prod_head,
> + const void *obj_table, uint32_t esize, uint32_t num)
> +{
> + /* 8B and 16B copies implemented individually to retain
> + * the current performance.
> + */
> + if (esize == 8)
> + __rte_ring_enqueue_elems_64(r, prod_head, obj_table, num);
> + else if (esize == 16)
> + __rte_ring_enqueue_elems_128(r, prod_head, obj_table, num);
> + else {
> + uint32_t idx, scale, nr_idx, nr_num, nr_size;
> +
> + /* Normalize to uint32_t */
> + scale = esize / sizeof(uint32_t);
> + nr_num = num * scale;
> + idx = prod_head & r->mask;
> + nr_idx = idx * scale;
> + nr_size = r->size * scale;
> + __rte_ring_enqueue_elems_32(r, nr_size, nr_idx,
> + obj_table, nr_num);
> + }
> +}
> +
> +static __rte_always_inline void
> +__rte_ring_dequeue_elems_32(struct rte_ring *r, const uint32_t size,
> + uint32_t idx, void *obj_table, uint32_t n)
> +{
> + unsigned int i;
> + uint32_t *ring = (uint32_t *)&r[1];
> + uint32_t *obj = (uint32_t *)obj_table;
> + if (likely(idx + n < size)) {
> + for (i = 0; i < (n & ~0x7); i += 8, idx += 8) {
> + obj[i] = ring[idx];
> + obj[i + 1] = ring[idx + 1];
> + obj[i + 2] = ring[idx + 2];
> + obj[i + 3] = ring[idx + 3];
> + obj[i + 4] = ring[idx + 4];
> + obj[i + 5] = ring[idx + 5];
> + obj[i + 6] = ring[idx + 6];
> + obj[i + 7] = ring[idx + 7];
> + }
> + switch (n & 0x7) {
> + case 7:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 6:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 5:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 4:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 3:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 2:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 1:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + }
> + } else {
> + for (i = 0; idx < size; i++, idx++)
> + obj[i] = ring[idx];
> + /* Start at the beginning */
> + for (idx = 0; i < n; i++, idx++)
> + obj[i] = ring[idx];
> + }
> +}
> +
> +static __rte_always_inline void
> +__rte_ring_dequeue_elems_64(struct rte_ring *r, uint32_t prod_head,
> + void *obj_table, uint32_t n)
> +{
> + unsigned int i;
> + const uint32_t size = r->size;
> + uint32_t idx = prod_head & r->mask;
> + uint64_t *ring = (uint64_t *)&r[1];
> + unaligned_uint64_t *obj = (unaligned_uint64_t *)obj_table;
> + if (likely(idx + n < size)) {
> + for (i = 0; i < (n & ~0x3); i += 4, idx += 4) {
> + obj[i] = ring[idx];
> + obj[i + 1] = ring[idx + 1];
> + obj[i + 2] = ring[idx + 2];
> + obj[i + 3] = ring[idx + 3];
> + }
> + switch (n & 0x3) {
> + case 3:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 2:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + case 1:
> + obj[i++] = ring[idx++]; /* fallthrough */
> + }
> + } else {
> + for (i = 0; idx < size; i++, idx++)
> + obj[i] = ring[idx];
> + /* Start at the beginning */
> + for (idx = 0; i < n; i++, idx++)
> + obj[i] = ring[idx];
> + }
> +}
> +
> +static __rte_always_inline void
> +__rte_ring_dequeue_elems_128(struct rte_ring *r, uint32_t prod_head,
> + void *obj_table, uint32_t n)
> +{
> + unsigned int i;
> + const uint32_t size = r->size;
> + uint32_t idx = prod_head & r->mask;
> + rte_int128_t *ring = (rte_int128_t *)&r[1];
> + rte_int128_t *obj = (rte_int128_t *)obj_table;
> + if (likely(idx + n < size)) {
> + for (i = 0; i < (n & ~0x1); i += 2, idx += 2)
> + memcpy((void *)(obj + i), (void *)(ring + idx), 32);
> + switch (n & 0x1) {
> + case 1:
> + memcpy((void *)(obj + i), (void *)(ring + idx), 16);
> + }
> + } else {
> + for (i = 0; idx < size; i++, idx++)
> + memcpy((void *)(obj + i), (void *)(ring + idx), 16);
> + /* Start at the beginning */
> + for (idx = 0; i < n; i++, idx++)
> + memcpy((void *)(obj + i), (void *)(ring + idx), 16);
> + }
> +}
> +
> +/* the actual dequeue of elements from the ring.
> + * Placed here since identical code needed in both
> + * single and multi producer enqueue functions.
> + */
> +static __rte_always_inline void
> +__rte_ring_dequeue_elems(struct rte_ring *r, uint32_t cons_head,
> + void *obj_table, uint32_t esize, uint32_t num)
> +{
> + /* 8B and 16B copies implemented individually to retain
> + * the current performance.
> + */
> + if (esize == 8)
> + __rte_ring_dequeue_elems_64(r, cons_head, obj_table, num);
> + else if (esize == 16)
> + __rte_ring_dequeue_elems_128(r, cons_head, obj_table, num);
> + else {
> + uint32_t idx, scale, nr_idx, nr_num, nr_size;
> +
> + /* Normalize to uint32_t */
> + scale = esize / sizeof(uint32_t);
> + nr_num = num * scale;
> + idx = cons_head & r->mask;
> + nr_idx = idx * scale;
> + nr_size = r->size * scale;
> + __rte_ring_dequeue_elems_32(r, nr_size, nr_idx,
> + obj_table, nr_num);
> + }
> +}
> +
> +/* Between load and load. there might be cpu reorder in weak model
> + * (powerpc/arm).
> + * There are 2 choices for the users
> + * 1.use rmb() memory barrier
> + * 2.use one-direction load_acquire/store_release barrier
> + * It depends on performance test results.
> + */
> +#ifdef RTE_USE_C11_MEM_MODEL
> +#include "ring_c11_pvt.h"
> +#else
> +#include "ring_generic_pvt.h"
> +#endif
> +
> +/**
> + * @internal Enqueue several objects on the ring
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of objects.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * This must be the same value used while creating the ring. Otherwise
> + * the results are undefined.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
> + * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from ring
> + * @param is_sp
> + * Indicates whether to use single producer or multi-producer head update
> + * @param free_space
> + * returns the amount of space after the enqueue operation has finished
> + * @return
> + * Actual number of objects enqueued.
> + * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_enqueue_elem(struct rte_ring *r, const void *obj_table,
> + unsigned int esize, unsigned int n,
> + enum rte_ring_queue_behavior behavior, unsigned int is_sp,
> + unsigned int *free_space)
> +{
> + uint32_t prod_head, prod_next;
> + uint32_t free_entries;
> +
> + n = __rte_ring_move_prod_head(r, is_sp, n, behavior,
> + &prod_head, &prod_next, &free_entries);
> + if (n == 0)
> + goto end;
> +
> + __rte_ring_enqueue_elems(r, prod_head, obj_table, esize, n);
> +
> + __rte_ring_update_tail(&r->prod, prod_head, prod_next, is_sp, 1);
> +end:
> + if (free_space != NULL)
> + *free_space = free_entries - n;
> + return n;
> +}
> +
> +/**
> + * @internal Dequeue several objects from the ring
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of objects.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * This must be the same value used while creating the ring. Otherwise
> + * the results are undefined.
> + * @param n
> + * The number of objects to pull from the ring.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
> + * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from ring
> + * @param is_sc
> + * Indicates whether to use single consumer or multi-consumer head update
> + * @param available
> + * returns the number of remaining ring entries after the dequeue has
> finished
> + * @return
> + * - Actual number of objects dequeued.
> + * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_dequeue_elem(struct rte_ring *r, void *obj_table,
> + unsigned int esize, unsigned int n,
> + enum rte_ring_queue_behavior behavior, unsigned int is_sc,
> + unsigned int *available)
> +{
> + uint32_t cons_head, cons_next;
> + uint32_t entries;
> +
> + n = __rte_ring_move_cons_head(r, (int)is_sc, n, behavior,
> + &cons_head, &cons_next, &entries);
> + if (n == 0)
> + goto end;
> +
> + __rte_ring_dequeue_elems(r, cons_head, obj_table, esize, n);
> +
> + __rte_ring_update_tail(&r->cons, cons_head, cons_next, is_sc, 0);
> +
> +end:
> + if (available != NULL)
> + *available = entries - n;
> + return n;
> +}
> +
> +#endif /* _RING_ELEM_PVT_H_ */
> diff --git a/lib/librte_ring/rte_ring_generic.h
> b/lib/librte_ring/ring_generic_pvt.h
> similarity index 98%
> rename from lib/librte_ring/rte_ring_generic.h
> rename to lib/librte_ring/ring_generic_pvt.h
> index 37c62b8d6..fc46a27b2 100644
> --- a/lib/librte_ring/rte_ring_generic.h
> +++ b/lib/librte_ring/ring_generic_pvt.h
> @@ -7,8 +7,8 @@
> * Used as BSD-3 Licensed with permission from Kip Macy.
> */
>
> -#ifndef _RTE_RING_GENERIC_H_
> -#define _RTE_RING_GENERIC_H_
> +#ifndef _RING_GENERIC_PVT_H_
> +#define _RING_GENERIC_PVT_H_
>
> static __rte_always_inline void
> __rte_ring_update_tail(struct rte_ring_headtail *ht, uint32_t old_val,
> @@ -170,4 +170,4 @@ __rte_ring_move_cons_head(struct rte_ring *r, unsigned
> int is_sc,
> return n;
> }
>
> -#endif /* _RTE_RING_GENERIC_H_ */
> +#endif /* _RING_GENERIC_PVT_H_ */
> diff --git a/lib/librte_ring/rte_ring_hts_c11_mem.h
> b/lib/librte_ring/ring_hts_elem_pvt.h
> similarity index 60%
> rename from lib/librte_ring/rte_ring_hts_c11_mem.h
> rename to lib/librte_ring/ring_hts_elem_pvt.h
> index 16e54b6ff..9268750b0 100644
> --- a/lib/librte_ring/rte_ring_hts_c11_mem.h
> +++ b/lib/librte_ring/ring_hts_elem_pvt.h
> @@ -7,8 +7,8 @@
> * Used as BSD-3 Licensed with permission from Kip Macy.
> */
>
> -#ifndef _RTE_RING_HTS_C11_MEM_H_
> -#define _RTE_RING_HTS_C11_MEM_H_
> +#ifndef _RING_HTS_ELEM_PVT_H_
> +#define _RING_HTS_ELEM_PVT_H_
>
> /**
> * @file rte_ring_hts_c11_mem.h
> @@ -161,4 +161,86 @@ __rte_ring_hts_move_cons_head(struct rte_ring *r,
> unsigned int num,
> return n;
> }
>
> -#endif /* _RTE_RING_HTS_C11_MEM_H_ */
> +/**
> + * @internal Enqueue several objects on the HTS ring.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of objects.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * This must be the same value used while creating the ring. Otherwise
> + * the results are undefined.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
> + * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from ring
> + * @param free_space
> + * returns the amount of space after the enqueue operation has finished
> + * @return
> + * Actual number of objects enqueued.
> + * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_hts_enqueue_elem(struct rte_ring *r, const void *obj_table,
> + uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> + uint32_t *free_space)
> +{
> + uint32_t free, head;
> +
> + n = __rte_ring_hts_move_prod_head(r, n, behavior, &head, &free);
> +
> + if (n != 0) {
> + __rte_ring_enqueue_elems(r, head, obj_table, esize, n);
> + __rte_ring_hts_update_tail(&r->hts_prod, head, n, 1);
> + }
> +
> + if (free_space != NULL)
> + *free_space = free - n;
> + return n;
> +}
> +
> +/**
> + * @internal Dequeue several objects from the HTS ring.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of objects.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * This must be the same value used while creating the ring. Otherwise
> + * the results are undefined.
> + * @param n
> + * The number of objects to pull from the ring.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
> + * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from ring
> + * @param available
> + * returns the number of remaining ring entries after the dequeue has
> finished
> + * @return
> + * - Actual number of objects dequeued.
> + * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_hts_dequeue_elem(struct rte_ring *r, void *obj_table,
> + uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> + uint32_t *available)
> +{
> + uint32_t entries, head;
> +
> + n = __rte_ring_hts_move_cons_head(r, n, behavior, &head, &entries);
> +
> + if (n != 0) {
> + __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
> + __rte_ring_hts_update_tail(&r->hts_cons, head, n, 0);
> + }
> +
> + if (available != NULL)
> + *available = entries - n;
> + return n;
> +}
> +
> +#endif /* _RING_HTS_ELEM_PVT_H_ */
> diff --git a/lib/librte_ring/rte_ring_peek_c11_mem.h
> b/lib/librte_ring/ring_peek_elem_pvt.h
> similarity index 62%
> rename from lib/librte_ring/rte_ring_peek_c11_mem.h
> rename to lib/librte_ring/ring_peek_elem_pvt.h
> index 283c7e70b..1c57bcdd6 100644
> --- a/lib/librte_ring/rte_ring_peek_c11_mem.h
> +++ b/lib/librte_ring/ring_peek_elem_pvt.h
> @@ -7,8 +7,8 @@
> * Used as BSD-3 Licensed with permission from Kip Macy.
> */
>
> -#ifndef _RTE_RING_PEEK_C11_MEM_H_
> -#define _RTE_RING_PEEK_C11_MEM_H_
> +#ifndef _RING_PEEK_ELEM_PVT_H_
> +#define _RING_PEEK_ELEM_PVT_H_
>
> /**
> * @file rte_ring_peek_c11_mem.h
> @@ -107,4 +107,73 @@ __rte_ring_hts_set_head_tail(struct
> rte_ring_hts_headtail *ht, uint32_t tail,
> __atomic_store_n(&ht->ht.raw, p.raw, __ATOMIC_RELEASE);
> }
>
> -#endif /* _RTE_RING_PEEK_C11_MEM_H_ */
> +/**
> + * @internal This function moves prod head value.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_enqueue_start(struct rte_ring *r, uint32_t n,
> + enum rte_ring_queue_behavior behavior, uint32_t *free_space)
> +{
> + uint32_t free, head, next;
> +
> + switch (r->prod.sync_type) {
> + case RTE_RING_SYNC_ST:
> + n = __rte_ring_move_prod_head(r, RTE_RING_SYNC_ST, n,
> + behavior, &head, &next, &free);
> + break;
> + case RTE_RING_SYNC_MT_HTS:
> + n = __rte_ring_hts_move_prod_head(r, n, behavior,
> + &head, &free);
> + break;
> + case RTE_RING_SYNC_MT:
> + case RTE_RING_SYNC_MT_RTS:
> + default:
> + /* unsupported mode, shouldn't be here */
> + RTE_ASSERT(0);
> + n = 0;
> + free = 0;
> + }
> +
> + if (free_space != NULL)
> + *free_space = free - n;
> + return n;
> +}
> +
> +/**
> + * @internal This function moves cons head value and copies up to *n*
> + * objects from the ring to the user provided obj_table.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_dequeue_start(struct rte_ring *r, void *obj_table,
> + uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> + uint32_t *available)
> +{
> + uint32_t avail, head, next;
> +
> + switch (r->cons.sync_type) {
> + case RTE_RING_SYNC_ST:
> + n = __rte_ring_move_cons_head(r, RTE_RING_SYNC_ST, n,
> + behavior, &head, &next, &avail);
> + break;
> + case RTE_RING_SYNC_MT_HTS:
> + n = __rte_ring_hts_move_cons_head(r, n, behavior,
> + &head, &avail);
> + break;
> + case RTE_RING_SYNC_MT:
> + case RTE_RING_SYNC_MT_RTS:
> + default:
> + /* unsupported mode, shouldn't be here */
> + RTE_ASSERT(0);
> + n = 0;
> + avail = 0;
> + }
> +
> + if (n != 0)
> + __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
> +
> + if (available != NULL)
> + *available = avail - n;
> + return n;
> +}
> +
> +#endif /* _RING_PEEK_ELEM_PVT_H_ */
> diff --git a/lib/librte_ring/rte_ring_rts_c11_mem.h
> b/lib/librte_ring/ring_rts_elem_pvt.h
> similarity index 62%
> rename from lib/librte_ring/rte_ring_rts_c11_mem.h
> rename to lib/librte_ring/ring_rts_elem_pvt.h
> index 327f22796..cbcec73eb 100644
> --- a/lib/librte_ring/rte_ring_rts_c11_mem.h
> +++ b/lib/librte_ring/ring_rts_elem_pvt.h
> @@ -7,8 +7,8 @@
> * Used as BSD-3 Licensed with permission from Kip Macy.
> */
>
> -#ifndef _RTE_RING_RTS_C11_MEM_H_
> -#define _RTE_RING_RTS_C11_MEM_H_
> +#ifndef _RING_RTS_ELEM_PVT_H_
> +#define _RING_RTS_ELEM_PVT_H_
>
> /**
> * @file rte_ring_rts_c11_mem.h
> @@ -176,4 +176,86 @@ __rte_ring_rts_move_cons_head(struct rte_ring *r,
> uint32_t num,
> return n;
> }
>
> -#endif /* _RTE_RING_RTS_C11_MEM_H_ */
> +/**
> + * @internal Enqueue several objects on the RTS ring.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of objects.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * This must be the same value used while creating the ring. Otherwise
> + * the results are undefined.
> + * @param n
> + * The number of objects to add in the ring from the obj_table.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
> + * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from ring
> + * @param free_space
> + * returns the amount of space after the enqueue operation has finished
> + * @return
> + * Actual number of objects enqueued.
> + * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_rts_enqueue_elem(struct rte_ring *r, const void *obj_table,
> + uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> + uint32_t *free_space)
> +{
> + uint32_t free, head;
> +
> + n = __rte_ring_rts_move_prod_head(r, n, behavior, &head, &free);
> +
> + if (n != 0) {
> + __rte_ring_enqueue_elems(r, head, obj_table, esize, n);
> + __rte_ring_rts_update_tail(&r->rts_prod);
> + }
> +
> + if (free_space != NULL)
> + *free_space = free - n;
> + return n;
> +}
> +
> +/**
> + * @internal Dequeue several objects from the RTS ring.
> + *
> + * @param r
> + * A pointer to the ring structure.
> + * @param obj_table
> + * A pointer to a table of objects.
> + * @param esize
> + * The size of ring element, in bytes. It must be a multiple of 4.
> + * This must be the same value used while creating the ring. Otherwise
> + * the results are undefined.
> + * @param n
> + * The number of objects to pull from the ring.
> + * @param behavior
> + * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
> + * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from ring
> + * @param available
> + * returns the number of remaining ring entries after the dequeue has
> finished
> + * @return
> + * - Actual number of objects dequeued.
> + * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> + */
> +static __rte_always_inline unsigned int
> +__rte_ring_do_rts_dequeue_elem(struct rte_ring *r, void *obj_table,
> + uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> + uint32_t *available)
> +{
> + uint32_t entries, head;
> +
> + n = __rte_ring_rts_move_cons_head(r, n, behavior, &head, &entries);
> +
> + if (n != 0) {
> + __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
> + __rte_ring_rts_update_tail(&r->rts_cons);
> + }
> +
> + if (available != NULL)
> + *available = entries - n;
> + return n;
> +}
> +
> +#endif /* _RING_RTS_ELEM_PVT_H_ */
> diff --git a/lib/librte_ring/rte_ring_elem.h b/lib/librte_ring/rte_ring_elem.h
> index 57344d47d..119b5c0b6 100644
> --- a/lib/librte_ring/rte_ring_elem.h
> +++ b/lib/librte_ring/rte_ring_elem.h
> @@ -21,6 +21,7 @@ extern "C" {
> #endif
>
> #include <rte_ring_core.h>
> +#include <ring_elem_pvt.h>
>
> /**
> * Calculate the memory size needed for a ring with given element size
> @@ -105,379 +106,6 @@ ssize_t rte_ring_get_memsize_elem(unsigned int esize,
> unsigned int count);
> struct rte_ring *rte_ring_create_elem(const char *name, unsigned int esize,
> unsigned int count, int socket_id, unsigned int flags);
>
> -static __rte_always_inline void
> -__rte_ring_enqueue_elems_32(struct rte_ring *r, const uint32_t size,
> - uint32_t idx, const void *obj_table, uint32_t n)
> -{
> - unsigned int i;
> - uint32_t *ring = (uint32_t *)&r[1];
> - const uint32_t *obj = (const uint32_t *)obj_table;
> - if (likely(idx + n < size)) {
> - for (i = 0; i < (n & ~0x7); i += 8, idx += 8) {
> - ring[idx] = obj[i];
> - ring[idx + 1] = obj[i + 1];
> - ring[idx + 2] = obj[i + 2];
> - ring[idx + 3] = obj[i + 3];
> - ring[idx + 4] = obj[i + 4];
> - ring[idx + 5] = obj[i + 5];
> - ring[idx + 6] = obj[i + 6];
> - ring[idx + 7] = obj[i + 7];
> - }
> - switch (n & 0x7) {
> - case 7:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 6:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 5:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 4:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 3:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 2:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 1:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - }
> - } else {
> - for (i = 0; idx < size; i++, idx++)
> - ring[idx] = obj[i];
> - /* Start at the beginning */
> - for (idx = 0; i < n; i++, idx++)
> - ring[idx] = obj[i];
> - }
> -}
> -
> -static __rte_always_inline void
> -__rte_ring_enqueue_elems_64(struct rte_ring *r, uint32_t prod_head,
> - const void *obj_table, uint32_t n)
> -{
> - unsigned int i;
> - const uint32_t size = r->size;
> - uint32_t idx = prod_head & r->mask;
> - uint64_t *ring = (uint64_t *)&r[1];
> - const unaligned_uint64_t *obj = (const unaligned_uint64_t *)obj_table;
> - if (likely(idx + n < size)) {
> - for (i = 0; i < (n & ~0x3); i += 4, idx += 4) {
> - ring[idx] = obj[i];
> - ring[idx + 1] = obj[i + 1];
> - ring[idx + 2] = obj[i + 2];
> - ring[idx + 3] = obj[i + 3];
> - }
> - switch (n & 0x3) {
> - case 3:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 2:
> - ring[idx++] = obj[i++]; /* fallthrough */
> - case 1:
> - ring[idx++] = obj[i++];
> - }
> - } else {
> - for (i = 0; idx < size; i++, idx++)
> - ring[idx] = obj[i];
> - /* Start at the beginning */
> - for (idx = 0; i < n; i++, idx++)
> - ring[idx] = obj[i];
> - }
> -}
> -
> -static __rte_always_inline void
> -__rte_ring_enqueue_elems_128(struct rte_ring *r, uint32_t prod_head,
> - const void *obj_table, uint32_t n)
> -{
> - unsigned int i;
> - const uint32_t size = r->size;
> - uint32_t idx = prod_head & r->mask;
> - rte_int128_t *ring = (rte_int128_t *)&r[1];
> - const rte_int128_t *obj = (const rte_int128_t *)obj_table;
> - if (likely(idx + n < size)) {
> - for (i = 0; i < (n & ~0x1); i += 2, idx += 2)
> - memcpy((void *)(ring + idx),
> - (const void *)(obj + i), 32);
> - switch (n & 0x1) {
> - case 1:
> - memcpy((void *)(ring + idx),
> - (const void *)(obj + i), 16);
> - }
> - } else {
> - for (i = 0; idx < size; i++, idx++)
> - memcpy((void *)(ring + idx),
> - (const void *)(obj + i), 16);
> - /* Start at the beginning */
> - for (idx = 0; i < n; i++, idx++)
> - memcpy((void *)(ring + idx),
> - (const void *)(obj + i), 16);
> - }
> -}
> -
> -/* the actual enqueue of elements on the ring.
> - * Placed here since identical code needed in both
> - * single and multi producer enqueue functions.
> - */
> -static __rte_always_inline void
> -__rte_ring_enqueue_elems(struct rte_ring *r, uint32_t prod_head,
> - const void *obj_table, uint32_t esize, uint32_t num)
> -{
> - /* 8B and 16B copies implemented individually to retain
> - * the current performance.
> - */
> - if (esize == 8)
> - __rte_ring_enqueue_elems_64(r, prod_head, obj_table, num);
> - else if (esize == 16)
> - __rte_ring_enqueue_elems_128(r, prod_head, obj_table, num);
> - else {
> - uint32_t idx, scale, nr_idx, nr_num, nr_size;
> -
> - /* Normalize to uint32_t */
> - scale = esize / sizeof(uint32_t);
> - nr_num = num * scale;
> - idx = prod_head & r->mask;
> - nr_idx = idx * scale;
> - nr_size = r->size * scale;
> - __rte_ring_enqueue_elems_32(r, nr_size, nr_idx,
> - obj_table, nr_num);
> - }
> -}
> -
> -static __rte_always_inline void
> -__rte_ring_dequeue_elems_32(struct rte_ring *r, const uint32_t size,
> - uint32_t idx, void *obj_table, uint32_t n)
> -{
> - unsigned int i;
> - uint32_t *ring = (uint32_t *)&r[1];
> - uint32_t *obj = (uint32_t *)obj_table;
> - if (likely(idx + n < size)) {
> - for (i = 0; i < (n & ~0x7); i += 8, idx += 8) {
> - obj[i] = ring[idx];
> - obj[i + 1] = ring[idx + 1];
> - obj[i + 2] = ring[idx + 2];
> - obj[i + 3] = ring[idx + 3];
> - obj[i + 4] = ring[idx + 4];
> - obj[i + 5] = ring[idx + 5];
> - obj[i + 6] = ring[idx + 6];
> - obj[i + 7] = ring[idx + 7];
> - }
> - switch (n & 0x7) {
> - case 7:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 6:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 5:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 4:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 3:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 2:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 1:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - }
> - } else {
> - for (i = 0; idx < size; i++, idx++)
> - obj[i] = ring[idx];
> - /* Start at the beginning */
> - for (idx = 0; i < n; i++, idx++)
> - obj[i] = ring[idx];
> - }
> -}
> -
> -static __rte_always_inline void
> -__rte_ring_dequeue_elems_64(struct rte_ring *r, uint32_t prod_head,
> - void *obj_table, uint32_t n)
> -{
> - unsigned int i;
> - const uint32_t size = r->size;
> - uint32_t idx = prod_head & r->mask;
> - uint64_t *ring = (uint64_t *)&r[1];
> - unaligned_uint64_t *obj = (unaligned_uint64_t *)obj_table;
> - if (likely(idx + n < size)) {
> - for (i = 0; i < (n & ~0x3); i += 4, idx += 4) {
> - obj[i] = ring[idx];
> - obj[i + 1] = ring[idx + 1];
> - obj[i + 2] = ring[idx + 2];
> - obj[i + 3] = ring[idx + 3];
> - }
> - switch (n & 0x3) {
> - case 3:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 2:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - case 1:
> - obj[i++] = ring[idx++]; /* fallthrough */
> - }
> - } else {
> - for (i = 0; idx < size; i++, idx++)
> - obj[i] = ring[idx];
> - /* Start at the beginning */
> - for (idx = 0; i < n; i++, idx++)
> - obj[i] = ring[idx];
> - }
> -}
> -
> -static __rte_always_inline void
> -__rte_ring_dequeue_elems_128(struct rte_ring *r, uint32_t prod_head,
> - void *obj_table, uint32_t n)
> -{
> - unsigned int i;
> - const uint32_t size = r->size;
> - uint32_t idx = prod_head & r->mask;
> - rte_int128_t *ring = (rte_int128_t *)&r[1];
> - rte_int128_t *obj = (rte_int128_t *)obj_table;
> - if (likely(idx + n < size)) {
> - for (i = 0; i < (n & ~0x1); i += 2, idx += 2)
> - memcpy((void *)(obj + i), (void *)(ring + idx), 32);
> - switch (n & 0x1) {
> - case 1:
> - memcpy((void *)(obj + i), (void *)(ring + idx), 16);
> - }
> - } else {
> - for (i = 0; idx < size; i++, idx++)
> - memcpy((void *)(obj + i), (void *)(ring + idx), 16);
> - /* Start at the beginning */
> - for (idx = 0; i < n; i++, idx++)
> - memcpy((void *)(obj + i), (void *)(ring + idx), 16);
> - }
> -}
> -
> -/* the actual dequeue of elements from the ring.
> - * Placed here since identical code needed in both
> - * single and multi producer enqueue functions.
> - */
> -static __rte_always_inline void
> -__rte_ring_dequeue_elems(struct rte_ring *r, uint32_t cons_head,
> - void *obj_table, uint32_t esize, uint32_t num)
> -{
> - /* 8B and 16B copies implemented individually to retain
> - * the current performance.
> - */
> - if (esize == 8)
> - __rte_ring_dequeue_elems_64(r, cons_head, obj_table, num);
> - else if (esize == 16)
> - __rte_ring_dequeue_elems_128(r, cons_head, obj_table, num);
> - else {
> - uint32_t idx, scale, nr_idx, nr_num, nr_size;
> -
> - /* Normalize to uint32_t */
> - scale = esize / sizeof(uint32_t);
> - nr_num = num * scale;
> - idx = cons_head & r->mask;
> - nr_idx = idx * scale;
> - nr_size = r->size * scale;
> - __rte_ring_dequeue_elems_32(r, nr_size, nr_idx,
> - obj_table, nr_num);
> - }
> -}
> -
> -/* Between load and load. there might be cpu reorder in weak model
> - * (powerpc/arm).
> - * There are 2 choices for the users
> - * 1.use rmb() memory barrier
> - * 2.use one-direction load_acquire/store_release barrier
> - * It depends on performance test results.
> - * By default, move common functions to rte_ring_generic.h
> - */
> -#ifdef RTE_USE_C11_MEM_MODEL
> -#include "rte_ring_c11_mem.h"
> -#else
> -#include "rte_ring_generic.h"
> -#endif
> -
> -/**
> - * @internal Enqueue several objects on the ring
> - *
> - * @param r
> - * A pointer to the ring structure.
> - * @param obj_table
> - * A pointer to a table of objects.
> - * @param esize
> - * The size of ring element, in bytes. It must be a multiple of 4.
> - * This must be the same value used while creating the ring. Otherwise
> - * the results are undefined.
> - * @param n
> - * The number of objects to add in the ring from the obj_table.
> - * @param behavior
> - * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
> - * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from ring
> - * @param is_sp
> - * Indicates whether to use single producer or multi-producer head update
> - * @param free_space
> - * returns the amount of space after the enqueue operation has finished
> - * @return
> - * Actual number of objects enqueued.
> - * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_enqueue_elem(struct rte_ring *r, const void *obj_table,
> - unsigned int esize, unsigned int n,
> - enum rte_ring_queue_behavior behavior, unsigned int is_sp,
> - unsigned int *free_space)
> -{
> - uint32_t prod_head, prod_next;
> - uint32_t free_entries;
> -
> - n = __rte_ring_move_prod_head(r, is_sp, n, behavior,
> - &prod_head, &prod_next, &free_entries);
> - if (n == 0)
> - goto end;
> -
> - __rte_ring_enqueue_elems(r, prod_head, obj_table, esize, n);
> -
> - __rte_ring_update_tail(&r->prod, prod_head, prod_next, is_sp, 1);
> -end:
> - if (free_space != NULL)
> - *free_space = free_entries - n;
> - return n;
> -}
> -
> -/**
> - * @internal Dequeue several objects from the ring
> - *
> - * @param r
> - * A pointer to the ring structure.
> - * @param obj_table
> - * A pointer to a table of objects.
> - * @param esize
> - * The size of ring element, in bytes. It must be a multiple of 4.
> - * This must be the same value used while creating the ring. Otherwise
> - * the results are undefined.
> - * @param n
> - * The number of objects to pull from the ring.
> - * @param behavior
> - * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
> - * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from ring
> - * @param is_sc
> - * Indicates whether to use single consumer or multi-consumer head update
> - * @param available
> - * returns the number of remaining ring entries after the dequeue has
> finished
> - * @return
> - * - Actual number of objects dequeued.
> - * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_dequeue_elem(struct rte_ring *r, void *obj_table,
> - unsigned int esize, unsigned int n,
> - enum rte_ring_queue_behavior behavior, unsigned int is_sc,
> - unsigned int *available)
> -{
> - uint32_t cons_head, cons_next;
> - uint32_t entries;
> -
> - n = __rte_ring_move_cons_head(r, (int)is_sc, n, behavior,
> - &cons_head, &cons_next, &entries);
> - if (n == 0)
> - goto end;
> -
> - __rte_ring_dequeue_elems(r, cons_head, obj_table, esize, n);
> -
> - __rte_ring_update_tail(&r->cons, cons_head, cons_next, is_sc, 0);
> -
> -end:
> - if (available != NULL)
> - *available = entries - n;
> - return n;
> -}
> -
> /**
> * Enqueue several objects on the ring (multi-producers safe).
> *
> diff --git a/lib/librte_ring/rte_ring_hts.h b/lib/librte_ring/rte_ring_hts.h
> index 359b15771..bdbdafc9f 100644
> --- a/lib/librte_ring/rte_ring_hts.h
> +++ b/lib/librte_ring/rte_ring_hts.h
> @@ -29,89 +29,7 @@
> extern "C" {
> #endif
>
> -#include <rte_ring_hts_c11_mem.h>
> -
> -/**
> - * @internal Enqueue several objects on the HTS ring.
> - *
> - * @param r
> - * A pointer to the ring structure.
> - * @param obj_table
> - * A pointer to a table of objects.
> - * @param esize
> - * The size of ring element, in bytes. It must be a multiple of 4.
> - * This must be the same value used while creating the ring. Otherwise
> - * the results are undefined.
> - * @param n
> - * The number of objects to add in the ring from the obj_table.
> - * @param behavior
> - * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
> - * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from ring
> - * @param free_space
> - * returns the amount of space after the enqueue operation has finished
> - * @return
> - * Actual number of objects enqueued.
> - * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_hts_enqueue_elem(struct rte_ring *r, const void *obj_table,
> - uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> - uint32_t *free_space)
> -{
> - uint32_t free, head;
> -
> - n = __rte_ring_hts_move_prod_head(r, n, behavior, &head, &free);
> -
> - if (n != 0) {
> - __rte_ring_enqueue_elems(r, head, obj_table, esize, n);
> - __rte_ring_hts_update_tail(&r->hts_prod, head, n, 1);
> - }
> -
> - if (free_space != NULL)
> - *free_space = free - n;
> - return n;
> -}
> -
> -/**
> - * @internal Dequeue several objects from the HTS ring.
> - *
> - * @param r
> - * A pointer to the ring structure.
> - * @param obj_table
> - * A pointer to a table of objects.
> - * @param esize
> - * The size of ring element, in bytes. It must be a multiple of 4.
> - * This must be the same value used while creating the ring. Otherwise
> - * the results are undefined.
> - * @param n
> - * The number of objects to pull from the ring.
> - * @param behavior
> - * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
> - * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from ring
> - * @param available
> - * returns the number of remaining ring entries after the dequeue has
> finished
> - * @return
> - * - Actual number of objects dequeued.
> - * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_hts_dequeue_elem(struct rte_ring *r, void *obj_table,
> - uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> - uint32_t *available)
> -{
> - uint32_t entries, head;
> -
> - n = __rte_ring_hts_move_cons_head(r, n, behavior, &head, &entries);
> -
> - if (n != 0) {
> - __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
> - __rte_ring_hts_update_tail(&r->hts_cons, head, n, 0);
> - }
> -
> - if (available != NULL)
> - *available = entries - n;
> - return n;
> -}
> +#include <ring_hts_elem_pvt.h>
>
> /**
> * Enqueue several objects on the HTS ring (multi-producers safe).
> diff --git a/lib/librte_ring/rte_ring_peek.h b/lib/librte_ring/rte_ring_peek.h
> index 45f707dc7..0dd402be4 100644
> --- a/lib/librte_ring/rte_ring_peek.h
> +++ b/lib/librte_ring/rte_ring_peek.h
> @@ -48,39 +48,7 @@
> extern "C" {
> #endif
>
> -#include <rte_ring_peek_c11_mem.h>
> -
> -/**
> - * @internal This function moves prod head value.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_enqueue_start(struct rte_ring *r, uint32_t n,
> - enum rte_ring_queue_behavior behavior, uint32_t *free_space)
> -{
> - uint32_t free, head, next;
> -
> - switch (r->prod.sync_type) {
> - case RTE_RING_SYNC_ST:
> - n = __rte_ring_move_prod_head(r, RTE_RING_SYNC_ST, n,
> - behavior, &head, &next, &free);
> - break;
> - case RTE_RING_SYNC_MT_HTS:
> - n = __rte_ring_hts_move_prod_head(r, n, behavior,
> - &head, &free);
> - break;
> - case RTE_RING_SYNC_MT:
> - case RTE_RING_SYNC_MT_RTS:
> - default:
> - /* unsupported mode, shouldn't be here */
> - RTE_ASSERT(0);
> - n = 0;
> - free = 0;
> - }
> -
> - if (free_space != NULL)
> - *free_space = free - n;
> - return n;
> -}
> +#include <ring_peek_elem_pvt.h>
>
> /**
> * Start to enqueue several objects on the ring.
> @@ -248,43 +216,6 @@ rte_ring_enqueue_finish(struct rte_ring *r, void * const
> *obj_table,
> rte_ring_enqueue_elem_finish(r, obj_table, sizeof(uintptr_t), n);
> }
>
> -/**
> - * @internal This function moves cons head value and copies up to *n*
> - * objects from the ring to the user provided obj_table.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_dequeue_start(struct rte_ring *r, void *obj_table,
> - uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> - uint32_t *available)
> -{
> - uint32_t avail, head, next;
> -
> - switch (r->cons.sync_type) {
> - case RTE_RING_SYNC_ST:
> - n = __rte_ring_move_cons_head(r, RTE_RING_SYNC_ST, n,
> - behavior, &head, &next, &avail);
> - break;
> - case RTE_RING_SYNC_MT_HTS:
> - n = __rte_ring_hts_move_cons_head(r, n, behavior,
> - &head, &avail);
> - break;
> - case RTE_RING_SYNC_MT:
> - case RTE_RING_SYNC_MT_RTS:
> - default:
> - /* unsupported mode, shouldn't be here */
> - RTE_ASSERT(0);
> - n = 0;
> - avail = 0;
> - }
> -
> - if (n != 0)
> - __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
> -
> - if (available != NULL)
> - *available = avail - n;
> - return n;
> -}
> -
> /**
> * Start to dequeue several objects from the ring.
> * Note that user has to call appropriate dequeue_finish()
> diff --git a/lib/librte_ring/rte_ring_peek_zc.h
> b/lib/librte_ring/rte_ring_peek_zc.h
> index cb3bbd067..bc8252a18 100644
> --- a/lib/librte_ring/rte_ring_peek_zc.h
> +++ b/lib/librte_ring/rte_ring_peek_zc.h
> @@ -72,7 +72,7 @@
> extern "C" {
> #endif
>
> -#include <rte_ring_peek_c11_mem.h>
> +#include <ring_peek_elem_pvt.h>
>
> /**
> * Ring zero-copy information structure.
> diff --git a/lib/librte_ring/rte_ring_rts.h b/lib/librte_ring/rte_ring_rts.h
> index afc12abe2..83d9903e2 100644
> --- a/lib/librte_ring/rte_ring_rts.h
> +++ b/lib/librte_ring/rte_ring_rts.h
> @@ -56,89 +56,7 @@
> extern "C" {
> #endif
>
> -#include <rte_ring_rts_c11_mem.h>
> -
> -/**
> - * @internal Enqueue several objects on the RTS ring.
> - *
> - * @param r
> - * A pointer to the ring structure.
> - * @param obj_table
> - * A pointer to a table of objects.
> - * @param esize
> - * The size of ring element, in bytes. It must be a multiple of 4.
> - * This must be the same value used while creating the ring. Otherwise
> - * the results are undefined.
> - * @param n
> - * The number of objects to add in the ring from the obj_table.
> - * @param behavior
> - * RTE_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
> - * RTE_RING_QUEUE_VARIABLE: Enqueue as many items as possible from ring
> - * @param free_space
> - * returns the amount of space after the enqueue operation has finished
> - * @return
> - * Actual number of objects enqueued.
> - * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_rts_enqueue_elem(struct rte_ring *r, const void *obj_table,
> - uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> - uint32_t *free_space)
> -{
> - uint32_t free, head;
> -
> - n = __rte_ring_rts_move_prod_head(r, n, behavior, &head, &free);
> -
> - if (n != 0) {
> - __rte_ring_enqueue_elems(r, head, obj_table, esize, n);
> - __rte_ring_rts_update_tail(&r->rts_prod);
> - }
> -
> - if (free_space != NULL)
> - *free_space = free - n;
> - return n;
> -}
> -
> -/**
> - * @internal Dequeue several objects from the RTS ring.
> - *
> - * @param r
> - * A pointer to the ring structure.
> - * @param obj_table
> - * A pointer to a table of objects.
> - * @param esize
> - * The size of ring element, in bytes. It must be a multiple of 4.
> - * This must be the same value used while creating the ring. Otherwise
> - * the results are undefined.
> - * @param n
> - * The number of objects to pull from the ring.
> - * @param behavior
> - * RTE_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
> - * RTE_RING_QUEUE_VARIABLE: Dequeue as many items as possible from ring
> - * @param available
> - * returns the number of remaining ring entries after the dequeue has
> finished
> - * @return
> - * - Actual number of objects dequeued.
> - * If behavior == RTE_RING_QUEUE_FIXED, this will be 0 or n only.
> - */
> -static __rte_always_inline unsigned int
> -__rte_ring_do_rts_dequeue_elem(struct rte_ring *r, void *obj_table,
> - uint32_t esize, uint32_t n, enum rte_ring_queue_behavior behavior,
> - uint32_t *available)
> -{
> - uint32_t entries, head;
> -
> - n = __rte_ring_rts_move_cons_head(r, n, behavior, &head, &entries);
> -
> - if (n != 0) {
> - __rte_ring_dequeue_elems(r, head, obj_table, esize, n);
> - __rte_ring_rts_update_tail(&r->rts_cons);
> - }
> -
> - if (available != NULL)
> - *available = entries - n;
> - return n;
> -}
> +#include <ring_rts_elem_pvt.h>
>
> /**
> * Enqueue several objects on the RTS ring (multi-producers safe).
> --
> 2.17.1
