>
> Hi Feifei,
>
> > > > 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?
> >
> > This change refers to you and Honnappa's discussion about ring:
> > https://mails.dpdk.org/archives/dev/2020-May/166803.html
> >
> > And it is to separate the external APIs that can be called by users,
> > from internal APIs that cannot be called by users.
> > The internal functions are included in the files with xx_pvt.h.
>
> Even these xx_pvt.h files contain internal API and not supposed to be
> included directly,
> they have to be installed into public dir (<dpdk-install-dir/include).
> So I think we need to keep DPDK public prefixes for them (and inside them):
> rte_xx_pvt.h (_RTE_).
As another thought - it is probably good to introduce new generic naming
convention
for such sort of files (internal ones that still have to be exposed).
Might be '_rte_' prefix or so...
Though I suppose it would require broader discussion first.
>
> Konstantin
>
> >
> > Best Regards
> > Feifei
> > >
> > > > 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
