This is an automated email from the ASF dual-hosted git repository. xiaoxiang781216 pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/nuttx.git
commit 178b7583f9320e1279b41a662977ebc94faa0d9c Author: chenzihan1 <[email protected]> AuthorDate: Thu Jun 4 16:13:40 2026 +0800 include/nuttx/ring: simplify public API naming Shorten ring public macro names by removing redundant verbs: - ring_xxxx_dequeue_skip -> ring_xxxx_skip Skip always operates on consumer side, "dequeue" is redundant. - ring_xxxx_enqueue_overwrite -> ring_xxxx_overwrite Overwrite always implies enqueue, "enqueue" is redundant. Signed-off-by: chenzihan1 <[email protected]> Signed-off-by: Bowen Wang <[email protected]> --- include/nuttx/ring.h | 112 +++++++++++++++++++++++++-------------------------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/include/nuttx/ring.h b/include/nuttx/ring.h index 27dfdb93c72..ac135f09190 100644 --- a/include/nuttx/ring.h +++ b/include/nuttx/ring.h @@ -63,12 +63,12 @@ * ring_mpmc_enqueue(&g_ring, &val, 1); * ring_mpmc_dequeue(&g_ring, &out, 1); * - * 3. Dequeue Skip (advance index without reading data): + * 3. Skip (advance consumer index without reading data): * - * ring_spsc_dequeue_skip(&g_ring, n); - * ring_mpsc_dequeue_skip(&g_ring, n); - * ring_spmc_dequeue_skip(&g_ring, n); - * ring_mpmc_dequeue_skip(&g_ring, n); + * ring_spsc_skip(&g_ring, n); + * ring_mpsc_skip(&g_ring, n); + * ring_spmc_skip(&g_ring, n); + * ring_mpmc_skip(&g_ring, n); * * Skip-to (advance cons_tail to a specific target index): * @@ -79,8 +79,8 @@ * * 4. Overwrite Mode (SPMC/MPMC only, discards oldest on full): * - * ring_spmc_enqueue_overwrite(&g_ring, &val, 1); - * ring_mpmc_enqueue_overwrite(&g_ring, &val, 1); + * ring_spmc_overwrite(&g_ring, &val, 1); + * ring_mpmc_overwrite(&g_ring, &val, 1); * // Consumer MUST use MC dequeue (ring_spmc/mpmc_dequeue) * * 5. Zero-copy enqueue/dequeue (start/finish pattern): @@ -100,16 +100,16 @@ * // Read from buf.ptr1 (len1) and buf.ptr2 (len2) * ring_spsc_dequeue_finish(&g_ring, &buf); * - * 6. Zero-copy overwrite enqueue (start/finish pattern): + * 6. Zero-copy overwrite (start/finish pattern): * * struct ring_buf_s buf; - * ring_spmc_enqueue_overwrite_start(&g_ring, count, - * elem_size, &buf); + * ring_spmc_overwrite_start(&g_ring, count, + * elem_size, &buf); * memcpy(buf.ptr1, src, buf.len1 * elem_size); * if (buf.ptr2) * memcpy(buf.ptr2, src + buf.len1 * elem_size, * buf.len2 * elem_size); - * ring_spmc_enqueue_overwrite_finish(&g_ring, &buf); + * ring_spmc_overwrite_finish(&g_ring, &buf); * * 7. Query: * @@ -347,9 +347,9 @@ (ring_is_ready(r) ? \ ring_sc_dequeue(RING_BASE(r), items, count, sizeof(*(items))) : 0) -#define ring_spsc_dequeue_skip(r, count) \ +#define ring_spsc_skip(r, count) \ (ring_is_ready(r) ? \ - ring_sc_dequeue_skip(RING_BASE(r), count) : 0) + ring_sc_skip(RING_BASE(r), count) : 0) #define ring_mpmc_enqueue(r, items, count) \ ring_mp_enqueue(RING_BASE(r), items, count, sizeof(*(items))) @@ -369,20 +369,20 @@ #define ring_mpsc_dequeue(r, items, count) \ ring_sc_dequeue(RING_BASE(r), items, count, sizeof(*(items))) -#define ring_mpmc_dequeue_skip(r, count) \ - ring_mc_dequeue_skip(RING_BASE(r), count) +#define ring_mpmc_skip(r, count) \ + ring_mc_skip(RING_BASE(r), count) -#define ring_spmc_dequeue_skip(r, count) \ - ring_mc_dequeue_skip(RING_BASE(r), count) +#define ring_spmc_skip(r, count) \ + ring_mc_skip(RING_BASE(r), count) -#define ring_mpsc_dequeue_skip(r, count) \ - ring_sc_dequeue_skip(RING_BASE(r), count) +#define ring_mpsc_skip(r, count) \ + ring_sc_skip(RING_BASE(r), count) #define ring_mpsc_skipto(r, target) \ ring_sc_skipto(RING_BASE(r), target) #define ring_spsc_skipto(r, target) \ - ring_sc_skipto(RING_BASE(r), target) + ring_sc_skipto(RING_BASE(r), target) #define ring_spmc_skipto(r, target) \ ring_mc_skipto(RING_BASE(r), target) @@ -390,7 +390,7 @@ #define ring_mpmc_skipto(r, target) \ ring_mc_skipto(RING_BASE(r), target) -/* Overwrite enqueue: when the ring is full, discard oldest data to +/* Overwrite: when the ring is full, discard oldest data to * make room. The discard path acts as a virtual multi-consumer, * so the dequeue side MUST use MC protocol (ring_spmc_dequeue or * ring_mpmc_dequeue) regardless of the number of real consumers. @@ -400,22 +400,22 @@ * discard, which conflicts with SC's plain-store protocol. */ -#define ring_spmc_enqueue_overwrite(r, items, count) \ - ring_sp_enqueue_overwrite(RING_BASE(r), items, count, sizeof(*(items))) +#define ring_spmc_overwrite(r, items, count) \ + ring_sp_overwrite(RING_BASE(r), items, count, sizeof(*(items))) -#define ring_mpmc_enqueue_overwrite(r, items, count) \ - ring_mp_enqueue_overwrite(RING_BASE(r), items, count, sizeof(*(items))) +#define ring_mpmc_overwrite(r, items, count) \ + ring_mp_overwrite(RING_BASE(r), items, count, sizeof(*(items))) -#define ring_spmc_enqueue_overwrite_start(r, count, elem_size, b) \ - ring_sp_enqueue_overwrite_start(RING_BASE(r), count, elem_size, b) +#define ring_spmc_overwrite_start(r, count, elem_size, b) \ + ring_sp_overwrite_start(RING_BASE(r), count, elem_size, b) -#define ring_spmc_enqueue_overwrite_finish(r, b) \ +#define ring_spmc_overwrite_finish(r, b) \ ring_sp_finish(RING_BASE(r), b) -#define ring_mpmc_enqueue_overwrite_start(r, count, elem_size, b) \ - ring_mp_enqueue_overwrite_start(RING_BASE(r), count, elem_size, b) +#define ring_mpmc_overwrite_start(r, count, elem_size, b) \ + ring_mp_overwrite_start(RING_BASE(r), count, elem_size, b) -#define ring_mpmc_enqueue_overwrite_finish(r, b) \ +#define ring_mpmc_overwrite_finish(r, b) \ ring_mp_finish(RING_BASE(r), b) #define ring_spsc_enqueue_start(r, count, elem_size, b) \ @@ -1312,16 +1312,16 @@ ring_mc_dequeue(FAR struct ring_s *r, FAR void *items, } /**************************************************************************** - * Name: ring_sc_dequeue_skip + * Name: ring_sc_skip * * Description: - * Single-consumer dequeue skip. Advance cons_tail by count without + * Single-consumer skip. Advance cons_tail by count without * reading data. Returns actual count skipped. * ****************************************************************************/ static inline_function uint32_t -ring_sc_dequeue_skip(FAR struct ring_s *r, uint32_t count) +ring_sc_skip(FAR struct ring_s *r, uint32_t count) { struct ring_buf_s buf; @@ -1349,23 +1349,23 @@ ring_sc_skipto(FAR struct ring_s *r, uint32_t target) if (count != 0) { - return ring_sc_dequeue_skip(r, count); + return ring_sc_skip(r, count); } return 0; } /**************************************************************************** - * Name: ring_mc_dequeue_skip + * Name: ring_mc_skip * * Description: - * Multi-consumer dequeue skip. Reserve and finish slots on + * Multi-consumer skip. Reserve and finish slots on * cons_head and cons_tail without reading data. * ****************************************************************************/ static inline_function uint32_t -ring_mc_dequeue_skip(FAR struct ring_s *r, uint32_t count) +ring_mc_skip(FAR struct ring_s *r, uint32_t count) { struct ring_buf_s buf; @@ -1381,7 +1381,7 @@ ring_mc_dequeue_skip(FAR struct ring_s *r, uint32_t count) * Description: * Multi-consumer skip-to. Advance cons_tail to the specified target * index. This is a convenience wrapper that computes the skip count - * from the current cons_tail and then calls ring_mc_dequeue_skip. + * from the current cons_tail and then calls ring_mc_skip. * If target is behind cons_tail (already consumed), does nothing. * ****************************************************************************/ @@ -1394,14 +1394,14 @@ ring_mc_skipto(FAR struct ring_s *r, uint32_t target) if (count != 0) { - return ring_mc_dequeue_skip(r, count); + return ring_mc_skip(r, count); } return 0; } /**************************************************************************** - * Name: ring_sp_enqueue_overwrite_start + * Name: ring_sp_overwrite_start * * Description: * Single-producer overwrite start. Discard oldest committed data @@ -1414,8 +1414,8 @@ ring_mc_skipto(FAR struct ring_s *r, uint32_t target) ****************************************************************************/ static inline_function uint32_t -ring_sp_enqueue_overwrite_start(FAR struct ring_s *r, uint32_t count, - size_t elem_size, FAR struct ring_buf_s *buf) +ring_sp_overwrite_start(FAR struct ring_s *r, uint32_t count, + size_t elem_size, FAR struct ring_buf_s *buf) { uint32_t prod_idx; uint32_t cons_idx; @@ -1458,10 +1458,10 @@ ring_sp_enqueue_overwrite_start(FAR struct ring_s *r, uint32_t count, } /**************************************************************************** - * Name: ring_sp_enqueue_overwrite + * Name: ring_sp_overwrite * * Description: - * Single-producer overwrite enqueue (copy variant). Returns the net + * Single-producer overwrite (copy variant). Returns the net * number of elements added to the ring (count - discarded); * when the ring was full, the count of evicted elements is subtracted * from the inserted count so the caller sees the true delta in @@ -1470,13 +1470,13 @@ ring_sp_enqueue_overwrite_start(FAR struct ring_s *r, uint32_t count, ****************************************************************************/ static inline_function uint32_t -ring_sp_enqueue_overwrite(FAR struct ring_s *r, FAR const void *items, - uint32_t count, size_t elem_size) +ring_sp_overwrite(FAR struct ring_s *r, FAR const void *items, + uint32_t count, size_t elem_size) { struct ring_buf_s buf; uint32_t discard; - discard = ring_sp_enqueue_overwrite_start(r, count, elem_size, &buf); + discard = ring_sp_overwrite_start(r, count, elem_size, &buf); ring_copy_from(&buf, (FAR const char *)items + (count - buf.cnt) * elem_size, elem_size); @@ -1486,7 +1486,7 @@ ring_sp_enqueue_overwrite(FAR struct ring_s *r, FAR const void *items, } /**************************************************************************** - * Name: ring_mp_enqueue_overwrite_start + * Name: ring_mp_overwrite_start * * Description: * Multi-producer overwrite start. Discard oldest committed data @@ -1500,8 +1500,8 @@ ring_sp_enqueue_overwrite(FAR struct ring_s *r, FAR const void *items, ****************************************************************************/ static inline_function uint32_t -ring_mp_enqueue_overwrite_start(FAR struct ring_s *r, uint32_t count, - size_t elem_size, FAR struct ring_buf_s *buf) +ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t count, + size_t elem_size, FAR struct ring_buf_s *buf) { uint32_t old_prod; uint32_t new_prod; @@ -1570,10 +1570,10 @@ ring_mp_enqueue_overwrite_start(FAR struct ring_s *r, uint32_t count, } /**************************************************************************** - * Name: ring_mp_enqueue_overwrite + * Name: ring_mp_overwrite * * Description: - * Multi-producer overwrite enqueue (copy variant). Returns the net + * Multi-producer overwrite (copy variant). Returns the net * number of elements added to the ring (count - discarded); * when the ring was full, the count of evicted elements is subtracted * from the inserted count so the caller sees the true delta in @@ -1582,13 +1582,13 @@ ring_mp_enqueue_overwrite_start(FAR struct ring_s *r, uint32_t count, ****************************************************************************/ static inline_function uint32_t -ring_mp_enqueue_overwrite(FAR struct ring_s *r, FAR const void *items, - uint32_t count, size_t elem_size) +ring_mp_overwrite(FAR struct ring_s *r, FAR const void *items, + uint32_t count, size_t elem_size) { struct ring_buf_s buf; uint32_t discard; - discard = ring_mp_enqueue_overwrite_start(r, count, elem_size, &buf); + discard = ring_mp_overwrite_start(r, count, elem_size, &buf); ring_copy_from(&buf, (FAR const char *)items + (count - buf.cnt) * elem_size, elem_size);
