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 df24cfd2d6bca126407186ee70de1a0519227ef3
Author: Bowen Wang <[email protected]>
AuthorDate: Mon Nov 2 23:38:41 2026 +0800

    include/ring: drop elem_size, the ring works in bytes only
    
    The data area is a uint8_t array and capacity counts bytes, but every
    index is still scaled by elem_size when an address is formed.  Any
    elem_size above one walks past data[]: sixteen uint32_t enqueued into a
    16-byte ring write 64 bytes.
    
    Remove elem_size everywhere.  Counts, lengths and ring_buf_s fields are
    bytes; the copy macros take a void pointer instead of sizing the
    element from it, and the zero-copy start macros lose their elem_size
    argument.
    
    Signed-off-by: Bowen Wang <[email protected]>
---
 include/nuttx/ring.h | 407 ++++++++++++++++++++++-----------------------------
 1 file changed, 175 insertions(+), 232 deletions(-)

diff --git a/include/nuttx/ring.h b/include/nuttx/ring.h
index 2ea5d50fa45..225d861ca3f 100644
--- a/include/nuttx/ring.h
+++ b/include/nuttx/ring.h
@@ -41,7 +41,7 @@
  *
  *   Init takes the blob and its total size, and derives the geometry.  The
  *   multi-core calls also take a rewind count, replaying that many
- *   already-consumed elements across a warm restart, 0 to disable:
+ *   already-consumed bytes across a warm restart, 0 to disable:
  *     ring_mpmc_init(&g_ring, g_blob, sizeof(g_blob), 0);  // SMP/BMP, CAS
  *     ring_mpsc_init(&g_ring, g_blob, sizeof(g_blob), 0);  // alias of mpmc
  *     ring_spmc_init(&g_ring, g_blob, sizeof(g_blob), 0);  // alias of mpmc
@@ -56,9 +56,12 @@
  *
  * 2. Mode Selection:
  *
+ *   The ring is a byte queue: every count, return value and length below is
+ *   in bytes, whatever type items points to.
+ *
  *   SPSC - Single Producer, Single Consumer (volatile + barrier):
- *     ring_spsc_enqueue(&g_ring, &val, 1);
- *     ring_spsc_dequeue(&g_ring, &out, 1);
+ *     ring_spsc_enqueue(&g_ring, buf, len);
+ *     ring_spsc_dequeue(&g_ring, buf, sizeof(buf));
  *
  *   Enqueue takes as much as fits and reports how much that was.  When the
  *   payload is indivisible - a framed record whose reader splits on a length
@@ -84,16 +87,16 @@
  *   where a rival may claim more right after the reservation lands.
  *
  *   MPSC - Multiple Producers, Single Consumer:
- *     ring_mpsc_enqueue(&g_ring, &val, 1);
- *     ring_mpsc_dequeue(&g_ring, &out, 1);
+ *     ring_mpsc_enqueue(&g_ring, buf, len);
+ *     ring_mpsc_dequeue(&g_ring, buf, sizeof(buf));
  *
  *   SPMC - Single Producer, Multiple Consumers:
- *     ring_spmc_enqueue(&g_ring, &val, 1);
- *     ring_spmc_dequeue(&g_ring, &out, 1);
+ *     ring_spmc_enqueue(&g_ring, buf, len);
+ *     ring_spmc_dequeue(&g_ring, buf, sizeof(buf));
  *
  *   MPMC - Multiple Producers, Multiple Consumers:
- *     ring_mpmc_enqueue(&g_ring, &val, 1);
- *     ring_mpmc_dequeue(&g_ring, &out, 1);
+ *     ring_mpmc_enqueue(&g_ring, buf, len);
+ *     ring_mpmc_dequeue(&g_ring, buf, sizeof(buf));
  *
  * 3. Skip (advance consumer index without reading data):
  *
@@ -111,8 +114,8 @@
  *
  * 4. Overwrite Mode (SPMC/MPMC only, discards oldest on full):
  *
- *     ring_spmc_overwrite(&g_ring, &val, 1);
- *     ring_mpmc_overwrite(&g_ring, &val, 1);
+ *     ring_spmc_overwrite(&g_ring, buf, len);
+ *     ring_mpmc_overwrite(&g_ring, buf, len);
  *     // Consumer MUST use MC dequeue (ring_spmc/mpmc_dequeue)
  *
  * 5. Zero-copy enqueue/dequeue (start/finish pattern):
@@ -120,42 +123,39 @@
  *     struct ring_buf_s buf;
  *
  *     // Enqueue (all modes: spsc/mpsc/spmc/mpmc):
- *     ring_spsc_enqueue_start(&g_ring, count, elem_size, &buf);
- *     memcpy(buf.ptr1, src, buf.len1 * elem_size);
+ *     ring_spsc_enqueue_start(&g_ring, count, &buf);
+ *     memcpy(buf.ptr1, src, buf.len1);
  *     if (buf.ptr2)
- *       memcpy(buf.ptr2, src + buf.len1 * elem_size,
- *              buf.len2 * elem_size);
+ *       memcpy(buf.ptr2, src + buf.len1, buf.len2);
  *     ring_spsc_enqueue_finish(&g_ring, &buf);
  *
- *     ring_spsc_enqueue_start_bulk(&g_ring, count, elem_size, NULL, &buf);
+ *     ring_spsc_enqueue_start_bulk(&g_ring, count, NULL, &buf);
  *     if (buf.cnt != 0)
  *       { ... fill and finish as above ... }
  *
  *     // Dequeue (all modes):
- *     ring_spsc_dequeue_start(&g_ring, count, elem_size, &buf);
+ *     ring_spsc_dequeue_start(&g_ring, count, &buf);
  *     // Read from buf.ptr1 (len1) and buf.ptr2 (len2)
  *     ring_spsc_dequeue_finish(&g_ring, &buf);
  *
- *     ring_spsc_dequeue_start_bulk(&g_ring, count, elem_size, NULL, &buf);
+ *     ring_spsc_dequeue_start_bulk(&g_ring, count, NULL, &buf);
  *     if (buf.cnt != 0)
  *       { ... read and finish as above ... }
  *
  * 6. Zero-copy overwrite (start/finish pattern):
  *
  *     struct ring_buf_s buf;
- *     ring_spmc_overwrite_start(&g_ring, count,
- *                               elem_size, &buf);
- *     memcpy(buf.ptr1, src, buf.len1 * elem_size);
+ *     ring_spmc_overwrite_start(&g_ring, count, &buf);
+ *     memcpy(buf.ptr1, src, buf.len1);
  *     if (buf.ptr2)
- *       memcpy(buf.ptr2, src + buf.len1 * elem_size,
- *              buf.len2 * elem_size);
+ *       memcpy(buf.ptr2, src + buf.len1, buf.len2);
  *     ring_spmc_overwrite_finish(&g_ring, &buf);
  *
  * 7. Query:
  *
- *     ring_count(&g_ring);     // Elements currently in ring
- *     ring_capacity(&g_ring);  // Max elements
- *     ring_space(&g_ring);     // Free slots
+ *     ring_count(&g_ring);     // Bytes currently in ring
+ *     ring_capacity(&g_ring);  // Max bytes
+ *     ring_space(&g_ring);     // Free bytes
  *     ring_is_ready(&g_ring);  // true if initialized
  */
 
@@ -258,58 +258,58 @@
 
 #define ring_spsc_enqueue(r, items, count) \
   (ring_is_ready(r) ? \
-   ring_sp_enqueue(r, items, count, sizeof(*(items))) : 0)
+   ring_sp_enqueue(r, items, count) : 0)
 
 #define ring_spsc_enqueue_bulk(r, items, count, space) \
   (ring_is_ready(r) ? \
-   ring_sp_enqueue_bulk(r, items, count, sizeof(*(items)), space) : 0)
+   ring_sp_enqueue_bulk(r, items, count, space) : 0)
 
 #define ring_spsc_dequeue(r, items, count) \
   (ring_is_ready(r) ? \
-   ring_sc_dequeue(r, items, count, sizeof(*(items))) : 0)
+   ring_sc_dequeue(r, items, count) : 0)
 
 #define ring_spsc_dequeue_bulk(r, items, count, avail) \
   (ring_is_ready(r) ? \
-   ring_sc_dequeue_bulk(r, items, count, sizeof(*(items)), avail) : 0)
+   ring_sc_dequeue_bulk(r, items, count, avail) : 0)
 
 #define ring_spsc_skip(r, count) \
   (ring_is_ready(r) ? ring_sc_skip(r, count) : 0)
 
 #define ring_mpmc_enqueue(r, items, count) \
-  ring_mp_enqueue(r, items, count, sizeof(*(items)))
+  ring_mp_enqueue(r, items, count)
 
 #define ring_mpmc_enqueue_bulk(r, items, count, space) \
-  ring_mp_enqueue_bulk(r, items, count, sizeof(*(items)), space)
+  ring_mp_enqueue_bulk(r, items, count, space)
 
 #define ring_mpmc_dequeue(r, items, count) \
-  ring_mc_dequeue(r, items, count, sizeof(*(items)))
+  ring_mc_dequeue(r, items, count)
 
 #define ring_mpmc_dequeue_bulk(r, items, count, avail) \
-  ring_mc_dequeue_bulk(r, items, count, sizeof(*(items)), avail)
+  ring_mc_dequeue_bulk(r, items, count, avail)
 
 #define ring_spmc_enqueue(r, items, count) \
-  ring_sp_enqueue(r, items, count, sizeof(*(items)))
+  ring_sp_enqueue(r, items, count)
 
 #define ring_spmc_enqueue_bulk(r, items, count, space) \
-  ring_sp_enqueue_bulk(r, items, count, sizeof(*(items)), space)
+  ring_sp_enqueue_bulk(r, items, count, space)
 
 #define ring_spmc_dequeue(r, items, count) \
-  ring_mc_dequeue(r, items, count, sizeof(*(items)))
+  ring_mc_dequeue(r, items, count)
 
 #define ring_spmc_dequeue_bulk(r, items, count, avail) \
-  ring_mc_dequeue_bulk(r, items, count, sizeof(*(items)), avail)
+  ring_mc_dequeue_bulk(r, items, count, avail)
 
 #define ring_mpsc_enqueue(r, items, count) \
-  ring_mp_enqueue(r, items, count, sizeof(*(items)))
+  ring_mp_enqueue(r, items, count)
 
 #define ring_mpsc_enqueue_bulk(r, items, count, space) \
-  ring_mp_enqueue_bulk(r, items, count, sizeof(*(items)), space)
+  ring_mp_enqueue_bulk(r, items, count, space)
 
 #define ring_mpsc_dequeue(r, items, count) \
-  ring_sc_dequeue(r, items, count, sizeof(*(items)))
+  ring_sc_dequeue(r, items, count)
 
 #define ring_mpsc_dequeue_bulk(r, items, count, avail) \
-  ring_sc_dequeue_bulk(r, items, count, sizeof(*(items)), avail)
+  ring_sc_dequeue_bulk(r, items, count, avail)
 
 #define ring_mpmc_skip(r, count) ring_mc_skip(r, count)
 #define ring_spmc_skip(r, count) ring_mc_skip(r, count)
@@ -331,96 +331,96 @@
  */
 
 #define ring_spmc_overwrite(r, items, count) \
-  ring_sp_overwrite(r, items, count, sizeof(*(items)))
+  ring_sp_overwrite(r, items, count)
 
 #define ring_mpmc_overwrite(r, items, count) \
-  ring_mp_overwrite(r, items, count, sizeof(*(items)))
+  ring_mp_overwrite(r, items, count)
 
-#define ring_spmc_overwrite_start(r, count, elem_size, b) \
-  ring_sp_overwrite_start(r, count, elem_size, b)
+#define ring_spmc_overwrite_start(r, count, b) \
+  ring_sp_overwrite_start(r, count, b)
 
 #define ring_spmc_overwrite_finish(r, b) ring_sp_finish(r, b)
 
-#define ring_mpmc_overwrite_start(r, count, elem_size, b) \
-  ring_mp_overwrite_start(r, count, elem_size, b)
+#define ring_mpmc_overwrite_start(r, count, b) \
+  ring_mp_overwrite_start(r, count, b)
 
 #define ring_mpmc_overwrite_finish(r, b) ring_mp_finish(r, b)
 
-#define ring_spsc_enqueue_start(r, count, elem_size, b) \
-  ring_sp_start(r, count, elem_size, false, NULL, b)
+#define ring_spsc_enqueue_start(r, count, b) \
+  ring_sp_start(r, count, false, NULL, b)
 
-#define ring_spsc_enqueue_start_bulk(r, count, elem_size, space, b) \
-  ring_sp_start(r, count, elem_size, true, space, b)
+#define ring_spsc_enqueue_start_bulk(r, count, space, b) \
+  ring_sp_start(r, count, true, space, b)
 
 #define ring_spsc_enqueue_finish(r, b) ring_sp_finish(r, b)
 
-#define ring_spsc_dequeue_start(r, count, elem_size, b) \
-  ring_sc_start(r, count, elem_size, false, NULL, b)
+#define ring_spsc_dequeue_start(r, count, b) \
+  ring_sc_start(r, count, false, NULL, b)
 
-#define ring_spsc_dequeue_start_bulk(r, count, elem_size, avail, b) \
-  ring_sc_start(r, count, elem_size, true, avail, b)
+#define ring_spsc_dequeue_start_bulk(r, count, avail, b) \
+  ring_sc_start(r, count, true, avail, b)
 
 #define ring_spsc_dequeue_finish(r, b) ring_sc_finish(r, b)
 
-#define ring_mpmc_enqueue_start(r, count, elem_size, b) \
-  ring_mp_start(r, count, elem_size, false, NULL, b)
+#define ring_mpmc_enqueue_start(r, count, b) \
+  ring_mp_start(r, count, false, NULL, b)
 
-#define ring_mpmc_enqueue_start_bulk(r, count, elem_size, space, b) \
-  ring_mp_start(r, count, elem_size, true, space, b)
+#define ring_mpmc_enqueue_start_bulk(r, count, space, b) \
+  ring_mp_start(r, count, true, space, b)
 
 #define ring_mpmc_enqueue_finish(r, b) ring_mp_finish(r, b)
 
-#define ring_mpmc_dequeue_start(r, count, elem_size, b) \
-  ring_mc_start(r, count, elem_size, false, NULL, b)
+#define ring_mpmc_dequeue_start(r, count, b) \
+  ring_mc_start(r, count, false, NULL, b)
 
-#define ring_mpmc_dequeue_start_bulk(r, count, elem_size, avail, b) \
-  ring_mc_start(r, count, elem_size, true, avail, b)
+#define ring_mpmc_dequeue_start_bulk(r, count, avail, b) \
+  ring_mc_start(r, count, true, avail, b)
 
 #define ring_mpmc_dequeue_finish(r, b) ring_mc_finish(r, b)
 
-#define ring_spmc_enqueue_start(r, count, elem_size, b) \
-  ring_sp_start(r, count, elem_size, false, NULL, b)
+#define ring_spmc_enqueue_start(r, count, b) \
+  ring_sp_start(r, count, false, NULL, b)
 
-#define ring_spmc_enqueue_start_bulk(r, count, elem_size, space, b) \
-  ring_sp_start(r, count, elem_size, true, space, b)
+#define ring_spmc_enqueue_start_bulk(r, count, space, b) \
+  ring_sp_start(r, count, true, space, b)
 
 #define ring_spmc_enqueue_finish(r, b) ring_sp_finish(r, b)
 
-#define ring_spmc_dequeue_start(r, count, elem_size, b) \
-  ring_mc_start(r, count, elem_size, false, NULL, b)
+#define ring_spmc_dequeue_start(r, count, b) \
+  ring_mc_start(r, count, false, NULL, b)
 
-#define ring_spmc_dequeue_start_bulk(r, count, elem_size, avail, b) \
-  ring_mc_start(r, count, elem_size, true, avail, b)
+#define ring_spmc_dequeue_start_bulk(r, count, avail, b) \
+  ring_mc_start(r, count, true, avail, b)
 
 #define ring_spmc_dequeue_finish(r, b) ring_mc_finish(r, b)
 
-#define ring_mpsc_enqueue_start(r, count, elem_size, b) \
-  ring_mp_start(r, count, elem_size, false, NULL, b)
+#define ring_mpsc_enqueue_start(r, count, b) \
+  ring_mp_start(r, count, false, NULL, b)
 
-#define ring_mpsc_enqueue_start_bulk(r, count, elem_size, space, b) \
-  ring_mp_start(r, count, elem_size, true, space, b)
+#define ring_mpsc_enqueue_start_bulk(r, count, space, b) \
+  ring_mp_start(r, count, true, space, b)
 
 #define ring_mpsc_enqueue_finish(r, b) ring_mp_finish(r, b)
 
-#define ring_mpsc_dequeue_start(r, count, elem_size, b) \
-  ring_sc_start(r, count, elem_size, false, NULL, b)
+#define ring_mpsc_dequeue_start(r, count, b) \
+  ring_sc_start(r, count, false, NULL, b)
 
-#define ring_mpsc_dequeue_start_bulk(r, count, elem_size, avail, b) \
-  ring_sc_start(r, count, elem_size, true, avail, b)
+#define ring_mpsc_dequeue_start_bulk(r, count, avail, b) \
+  ring_sc_start(r, count, true, avail, b)
 
 #define ring_mpsc_dequeue_finish(r, b) ring_sc_finish(r, b)
 
 #define ring_mpsc_peek(r, items, count, index) \
-  ring_sc_peek(r, items, count, sizeof(*(items)), index)
+  ring_sc_peek(r, items, count, index)
 
 #define ring_spsc_peek(r, items, count, index) \
-  ring_sc_peek(r, items, count, sizeof(*(items)), index)
+  ring_sc_peek(r, items, count, index)
 
 #define ring_mpmc_peek(r, items, count, index) \
-  ring_mc_peek(r, items, count, sizeof(*(items)), index)
+  ring_mc_peek(r, items, count, index)
 
 #define ring_spmc_peek(r, items, count, index) \
-  ring_mc_peek(r, items, count, sizeof(*(items)), index)
+  ring_mc_peek(r, items, count, index)
 
 /* Peek at a fixed offset from the oldest element (cons_tail), without
  * advancing.  Unlike the external-index peek above, the read position is
@@ -429,16 +429,16 @@
  */
 
 #define ring_mpsc_peek_at(r, items, count, offset) \
-  ring_sc_peek_at(r, items, count, sizeof(*(items)), offset)
+  ring_sc_peek_at(r, items, count, offset)
 
 #define ring_spsc_peek_at(r, items, count, offset) \
-  ring_sc_peek_at(r, items, count, sizeof(*(items)), offset)
+  ring_sc_peek_at(r, items, count, offset)
 
 #define ring_mpmc_peek_at(r, items, count, offset) \
-  ring_mc_peek_at(r, items, count, sizeof(*(items)), offset)
+  ring_mc_peek_at(r, items, count, offset)
 
 #define ring_spmc_peek_at(r, items, count, offset) \
-  ring_mc_peek_at(r, items, count, sizeof(*(items)), offset)
+  ring_mc_peek_at(r, items, count, offset)
 
 /****************************************************************************
  * Public Types
@@ -513,11 +513,11 @@ struct ring_s
 struct ring_buf_s
 {
   FAR void    *ptr1;              /* First contiguous segment */
-  uint32_t     len1;              /* Element count in first segment */
+  uint32_t     len1;              /* Byte count in first segment */
   FAR void    *ptr2;              /* Second segment (wrap), NULL if none */
-  uint32_t     len2;              /* Element count in second segment */
+  uint32_t     len2;              /* Byte count in second segment */
   uint32_t     idx;               /* Internal: start index */
-  uint32_t     cnt;               /* Internal: total slots reserved */
+  uint32_t     cnt;               /* Total bytes reserved */
 };
 
 /****************************************************************************
@@ -673,7 +673,7 @@ static inline_function uint32_t ring_reset(FAR struct 
ring_s *r)
  *
  *   buf    - the blob to operate on
  *   buflen - total blob size in bytes (header + data)
- *   rewind - elements to replay on a warm restart, 0 for none
+ *   rewind - bytes to replay on a warm restart, 0 for none
  *
  * Returned Value:
  *   true if this caller ran the init body (the first one this boot), false
@@ -761,19 +761,19 @@ ring_spsc_init(FAR struct ring_s *r, FAR void *buf, 
uint32_t buflen,
  *   would make every later CAS wait for a producer/consumer that no longer
  *   exists.
  *
- *   rewind additionally replays elements the previous run had already
- *   consumed, by pulling cons_tail back that many elements.  It is a count
- *   of elements, not bytes, and it is clamped to the free space
- *   (capacity - count): the live data occupies count slots and the whole
- *   remaining area is exactly the window of already-consumed-but-still-
- *   present data.  It only makes sense for a blob that survives reboot (a
- *   located .noinit section or shared SRAM); pass 0 otherwise.  A cold
- *   start has nothing to replay, and a blob with corrupted indices
- *   (count > capacity) is reset - neither path applies rewind.
+ *   rewind additionally replays bytes the previous run had already
+ *   consumed, by pulling cons_tail back that many bytes.  It is clamped to
+ *   the free space (capacity - count): the live data occupies count bytes
+ *   and the whole remaining area is exactly the window of
+ *   already-consumed-but-still-present data.  It only makes sense for a
+ *   blob that survives reboot (a located .noinit section or shared SRAM);
+ *   pass 0 otherwise.  A cold start has nothing to replay, and a blob with
+ *   corrupted indices (count > capacity) is reset - neither path applies
+ *   rewind.
  *
  *   buf    - the blob to operate on
  *   buflen - total blob size in bytes (header + data)
- *   rewind - elements of already-consumed data to replay on a warm restart,
+ *   rewind - bytes of already-consumed data to replay on a warm restart,
  *            0 to disable
  *
  * Returned Value:
@@ -941,7 +941,7 @@ static inline_function void ring_free(FAR struct ring_s *r)
 
 static inline_function void
 ring_buf_init(FAR struct ring_buf_s *buf, FAR struct ring_s *r,
-              uint32_t idx, uint32_t count, size_t elem_size)
+              uint32_t idx, uint32_t count)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t first;
@@ -965,14 +965,14 @@ ring_buf_init(FAR struct ring_buf_s *buf, FAR struct 
ring_s *r,
 
   if (first >= count)
     {
-      buf->ptr1 = blob->data + idx * elem_size;
+      buf->ptr1 = blob->data + idx;
       buf->len1 = count;
       buf->ptr2 = NULL;
       buf->len2 = 0;
     }
   else
     {
-      buf->ptr1 = blob->data + idx * elem_size;
+      buf->ptr1 = blob->data + idx;
       buf->len1 = first;
       buf->ptr2 = blob->data;
       buf->len2 = count - first;
@@ -988,39 +988,14 @@ ring_buf_init(FAR struct ring_buf_s *buf, FAR struct 
ring_s *r,
  ****************************************************************************/
 
 static inline_function void
-ring_copy_from(FAR struct ring_buf_s *buf, FAR const void *items,
-               size_t elem_size)
+ring_copy_from(FAR struct ring_buf_s *buf, FAR const void *items)
 {
-  if (buf->cnt == 1)
-    {
-      if (elem_size == sizeof(uint8_t))
-        {
-          *(FAR uint8_t *)buf->ptr1 = *(FAR const uint8_t *)items;
-        }
-      else if (elem_size == sizeof(uint16_t))
-        {
-          *(FAR uint16_t *)buf->ptr1 = *(FAR const uint16_t *)items;
-        }
-      else if (elem_size == sizeof(uint32_t))
-        {
-          *(FAR uint32_t *)buf->ptr1 = *(FAR const uint32_t *)items;
-        }
-      else if (elem_size == sizeof(uint64_t))
-        {
-          *(FAR uint64_t *)buf->ptr1 = *(FAR const uint64_t *)items;
-        }
-      else
-        {
-          memcpy(buf->ptr1, items, elem_size);
-        }
-    }
-  else if (buf->cnt != 0)
+  if (buf->cnt != 0)
     {
-      memcpy(buf->ptr1, items, buf->len1 * elem_size);
+      memcpy(buf->ptr1, items, buf->len1);
       if (buf->len2 != 0)
         {
-          memcpy(buf->ptr2, (FAR const char *)items + buf->len1 * elem_size,
-                 buf->len2 * elem_size);
+          memcpy(buf->ptr2, (FAR const char *)items + buf->len1, buf->len2);
         }
     }
 }
@@ -1034,38 +1009,14 @@ ring_copy_from(FAR struct ring_buf_s *buf, FAR const 
void *items,
  ****************************************************************************/
 
 static inline_function void
-ring_copy_to(FAR struct ring_buf_s *buf, FAR void *items, size_t elem_size)
+ring_copy_to(FAR struct ring_buf_s *buf, FAR void *items)
 {
-  if (buf->cnt == 1)
-    {
-      if (elem_size == sizeof(uint8_t))
-        {
-          *(FAR uint8_t *)items = *(FAR const uint8_t *)buf->ptr1;
-        }
-      else if (elem_size == sizeof(uint16_t))
-        {
-          *(FAR uint16_t *)items = *(FAR const uint16_t *)buf->ptr1;
-        }
-      else if (elem_size == sizeof(uint32_t))
-        {
-          *(FAR uint32_t *)items = *(FAR const uint32_t *)buf->ptr1;
-        }
-      else if (elem_size == sizeof(uint64_t))
-        {
-          *(FAR uint64_t *)items = *(FAR const uint64_t *)buf->ptr1;
-        }
-      else
-        {
-          memcpy(items, buf->ptr1, elem_size);
-        }
-    }
-  else if (buf->cnt != 0)
+  if (buf->cnt != 0)
     {
-      memcpy(items, buf->ptr1, buf->len1 * elem_size);
+      memcpy(items, buf->ptr1, buf->len1);
       if (buf->len2 != 0)
         {
-          memcpy((FAR char *)items + buf->len1 * elem_size,
-                 buf->ptr2, buf->len2 * elem_size);
+          memcpy((FAR char *)items + buf->len1, buf->ptr2, buf->len2);
         }
     }
 }
@@ -1079,8 +1030,8 @@ ring_copy_to(FAR struct ring_buf_s *buf, FAR void *items, 
size_t elem_size)
  ****************************************************************************/
 
 static inline_function void
-ring_sp_start(FAR struct ring_s *r, uint32_t count, size_t elem_size,
-              bool bulk, FAR uint32_t *space, FAR struct ring_buf_s *buf)
+ring_sp_start(FAR struct ring_s *r, uint32_t count, bool bulk,
+              FAR uint32_t *space, FAR struct ring_buf_s *buf)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t prod_index = RTS_IDX(blob->prod_tail);
@@ -1104,7 +1055,7 @@ ring_sp_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
       *space = free_space - n;
     }
 
-  ring_buf_init(buf, r, prod_index, n, elem_size);
+  ring_buf_init(buf, r, prod_index, n);
 }
 
 /****************************************************************************
@@ -1117,8 +1068,8 @@ ring_sp_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
  ****************************************************************************/
 
 static inline_function void
-ring_mp_start(FAR struct ring_s *r, uint32_t count, size_t elem_size,
-              bool bulk, FAR uint32_t *space, FAR struct ring_buf_s *buf)
+ring_mp_start(FAR struct ring_s *r, uint32_t count, bool bulk,
+              FAR uint32_t *space, FAR struct ring_buf_s *buf)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t old_head;
@@ -1157,7 +1108,7 @@ ring_mp_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
       *space = free_space - n;
     }
 
-  ring_buf_init(buf, r, RTS_IDX(old_head), n, elem_size);
+  ring_buf_init(buf, r, RTS_IDX(old_head), n);
 }
 
 /****************************************************************************
@@ -1170,8 +1121,8 @@ ring_mp_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
  ****************************************************************************/
 
 static inline_function void
-ring_sc_start(FAR struct ring_s *r, uint32_t count, size_t elem_size,
-              bool bulk, FAR uint32_t *avail, FAR struct ring_buf_s *buf)
+ring_sc_start(FAR struct ring_s *r, uint32_t count, bool bulk,
+              FAR uint32_t *avail, FAR struct ring_buf_s *buf)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t cons_index = RTS_IDX(blob->cons_tail);
@@ -1204,7 +1155,7 @@ ring_sc_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
       *avail = available - n;
     }
 
-  ring_buf_init(buf, r, cons_index, n, elem_size);
+  ring_buf_init(buf, r, cons_index, n);
 }
 
 /****************************************************************************
@@ -1217,8 +1168,8 @@ ring_sc_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
  ****************************************************************************/
 
 static inline_function void
-ring_mc_start(FAR struct ring_s *r, uint32_t count, size_t elem_size,
-              bool bulk, FAR uint32_t *avail, FAR struct ring_buf_s *buf)
+ring_mc_start(FAR struct ring_s *r, uint32_t count, bool bulk,
+              FAR uint32_t *avail, FAR struct ring_buf_s *buf)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t old_head;
@@ -1263,7 +1214,7 @@ ring_mc_start(FAR struct ring_s *r, uint32_t count, 
size_t elem_size,
       *avail = available - n;
     }
 
-  ring_buf_init(buf, r, RTS_IDX(old_head), n, elem_size);
+  ring_buf_init(buf, r, RTS_IDX(old_head), n);
 }
 
 /****************************************************************************
@@ -1365,7 +1316,7 @@ ring_sc_finish(FAR struct ring_s *r, FAR struct 
ring_buf_s *buf)
 
 static inline_function uint32_t
 ring_sc_peek(FAR struct ring_s *r, FAR void *items, uint32_t count,
-             size_t elem_size, FAR uint32_t *index)
+             FAR uint32_t *index)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t cons_index;
@@ -1388,8 +1339,8 @@ ring_sc_peek(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
     {
       struct ring_buf_s buf;
 
-      ring_buf_init(&buf, r, cons_index, n, elem_size);
-      ring_copy_to(&buf, items, elem_size);
+      ring_buf_init(&buf, r, cons_index, n);
+      ring_copy_to(&buf, items);
       cons_index = ring_advance(r, cons_index, n);
     }
 
@@ -1416,7 +1367,7 @@ ring_sc_peek(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
 
 static inline_function uint32_t
 ring_mc_peek(FAR struct ring_s *r, FAR void *items, uint32_t count,
-             size_t elem_size, FAR uint32_t *index)
+             FAR uint32_t *index)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t cons_index;
@@ -1443,8 +1394,8 @@ ring_mc_peek(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
           break;
         }
 
-      ring_buf_init(&buf, r, cons_index, n, elem_size);
-      ring_copy_to(&buf, items, elem_size);
+      ring_buf_init(&buf, r, cons_index, n);
+      ring_copy_to(&buf, items);
 
       /* Verify data wasn't overwritten during copy:
        * If cons_tail advanced past our read position, retry.
@@ -1481,7 +1432,7 @@ ring_mc_peek(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
 
 static inline_function uint32_t
 ring_sc_peek_at(FAR struct ring_s *r, FAR void *items, uint32_t count,
-                size_t elem_size, uint32_t offset)
+                uint32_t offset)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t index;
@@ -1492,7 +1443,7 @@ ring_sc_peek_at(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
     }
 
   index = ring_advance(r, offset, RTS_IDX(blob->cons_tail));
-  return ring_sc_peek(r, items, count, elem_size, &index);
+  return ring_sc_peek(r, items, count, &index);
 }
 
 /****************************************************************************
@@ -1509,7 +1460,7 @@ ring_sc_peek_at(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
 
 static inline_function uint32_t
 ring_mc_peek_at(FAR struct ring_s *r, FAR void *items, uint32_t count,
-                size_t elem_size, uint32_t offset)
+                uint32_t offset)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t index;
@@ -1521,7 +1472,7 @@ ring_mc_peek_at(FAR struct ring_s *r, FAR void *items, 
uint32_t count,
 
   index = ring_advance(r, offset,
                        RTS_IDX(atomic_read_acquire(&blob->cons_tail)));
-  return ring_mc_peek(r, items, count, elem_size, &index);
+  return ring_mc_peek(r, items, count, &index);
 }
 
 /****************************************************************************
@@ -1574,12 +1525,12 @@ ring_mc_finish(FAR struct ring_s *r, FAR struct 
ring_buf_s *buf)
 
 static inline_function uint32_t
 ring_sp_enqueue(FAR struct ring_s *r, FAR const void *items,
-                uint32_t count, size_t elem_size)
+                uint32_t count)
 {
   struct ring_buf_s buf;
 
-  ring_sp_start(r, count, elem_size, false, NULL, &buf);
-  ring_copy_from(&buf, items, elem_size);
+  ring_sp_start(r, count, false, NULL, &buf);
+  ring_copy_from(&buf, items);
   ring_sp_finish(r, &buf);
 
   return buf.cnt;
@@ -1599,13 +1550,12 @@ ring_sp_enqueue(FAR struct ring_s *r, FAR const void 
*items,
 
 static inline_function uint32_t
 ring_sp_enqueue_bulk(FAR struct ring_s *r, FAR const void *items,
-                     uint32_t count, size_t elem_size,
-                     FAR uint32_t *space)
+                     uint32_t count, FAR uint32_t *space)
 {
   struct ring_buf_s buf;
 
-  ring_sp_start(r, count, elem_size, true, space, &buf);
-  ring_copy_from(&buf, items, elem_size);
+  ring_sp_start(r, count, true, space, &buf);
+  ring_copy_from(&buf, items);
   ring_sp_finish(r, &buf);
 
   return buf.cnt;
@@ -1627,12 +1577,12 @@ ring_sp_enqueue_bulk(FAR struct ring_s *r, FAR const 
void *items,
 
 static inline_function uint32_t
 ring_mp_enqueue(FAR struct ring_s *r, FAR const void *items,
-                uint32_t count, size_t elem_size)
+                uint32_t count)
 {
   struct ring_buf_s buf;
 
-  ring_mp_start(r, count, elem_size, false, NULL, &buf);
-  ring_copy_from(&buf, items, elem_size);
+  ring_mp_start(r, count, false, NULL, &buf);
+  ring_copy_from(&buf, items);
   ring_mp_finish(r, &buf);
 
   return buf.cnt;
@@ -1652,13 +1602,12 @@ ring_mp_enqueue(FAR struct ring_s *r, FAR const void 
*items,
 
 static inline_function uint32_t
 ring_mp_enqueue_bulk(FAR struct ring_s *r, FAR const void *items,
-                     uint32_t count, size_t elem_size,
-                     FAR uint32_t *space)
+                     uint32_t count, FAR uint32_t *space)
 {
   struct ring_buf_s buf;
 
-  ring_mp_start(r, count, elem_size, true, space, &buf);
-  ring_copy_from(&buf, items, elem_size);
+  ring_mp_start(r, count, true, space, &buf);
+  ring_copy_from(&buf, items);
   ring_mp_finish(r, &buf);
 
   return buf.cnt;
@@ -1674,12 +1623,12 @@ ring_mp_enqueue_bulk(FAR struct ring_s *r, FAR const 
void *items,
 
 static inline_function uint32_t
 ring_sc_dequeue(FAR struct ring_s *r, FAR void *items,
-                uint32_t count, size_t elem_size)
+                uint32_t count)
 {
   struct ring_buf_s buf;
 
-  ring_sc_start(r, count, elem_size, false, NULL, &buf);
-  ring_copy_to(&buf, items, elem_size);
+  ring_sc_start(r, count, false, NULL, &buf);
+  ring_copy_to(&buf, items);
   ring_sc_finish(r, &buf);
 
   return buf.cnt;
@@ -1700,13 +1649,12 @@ ring_sc_dequeue(FAR struct ring_s *r, FAR void *items,
 
 static inline_function uint32_t
 ring_sc_dequeue_bulk(FAR struct ring_s *r, FAR void *items,
-                     uint32_t count, size_t elem_size,
-                     FAR uint32_t *avail)
+                     uint32_t count, FAR uint32_t *avail)
 {
   struct ring_buf_s buf;
 
-  ring_sc_start(r, count, elem_size, true, avail, &buf);
-  ring_copy_to(&buf, items, elem_size);
+  ring_sc_start(r, count, true, avail, &buf);
+  ring_copy_to(&buf, items);
   ring_sc_finish(r, &buf);
 
   return buf.cnt;
@@ -1725,12 +1673,12 @@ ring_sc_dequeue_bulk(FAR struct ring_s *r, FAR void 
*items,
 
 static inline_function uint32_t
 ring_mc_dequeue(FAR struct ring_s *r, FAR void *items,
-                uint32_t count, size_t elem_size)
+                uint32_t count)
 {
   struct ring_buf_s buf;
 
-  ring_mc_start(r, count, elem_size, false, NULL, &buf);
-  ring_copy_to(&buf, items, elem_size);
+  ring_mc_start(r, count, false, NULL, &buf);
+  ring_copy_to(&buf, items);
   ring_mc_finish(r, &buf);
 
   return buf.cnt;
@@ -1752,13 +1700,12 @@ ring_mc_dequeue(FAR struct ring_s *r, FAR void *items,
 
 static inline_function uint32_t
 ring_mc_dequeue_bulk(FAR struct ring_s *r, FAR void *items,
-                     uint32_t count, size_t elem_size,
-                     FAR uint32_t *avail)
+                     uint32_t count, FAR uint32_t *avail)
 {
   struct ring_buf_s buf;
 
-  ring_mc_start(r, count, elem_size, true, avail, &buf);
-  ring_copy_to(&buf, items, elem_size);
+  ring_mc_start(r, count, true, avail, &buf);
+  ring_copy_to(&buf, items);
   ring_mc_finish(r, &buf);
 
   return buf.cnt;
@@ -1778,7 +1725,7 @@ ring_sc_skip(FAR struct ring_s *r, uint32_t count)
 {
   struct ring_buf_s buf;
 
-  ring_sc_start(r, count, 0, false, NULL, &buf);
+  ring_sc_start(r, count, false, NULL, &buf);
   ring_sc_finish(r, &buf);
 
   return buf.cnt;
@@ -1829,7 +1776,7 @@ ring_mc_skip(FAR struct ring_s *r, uint32_t count)
 {
   struct ring_buf_s buf;
 
-  ring_mc_start(r, count, 0, false, NULL, &buf);
+  ring_mc_start(r, count, false, NULL, &buf);
   ring_mc_finish(r, &buf);
 
   return buf.cnt;
@@ -1882,7 +1829,7 @@ ring_mc_skipto(FAR struct ring_s *r, uint32_t target)
 
 static inline_function uint32_t
 ring_sp_overwrite_start(FAR struct ring_s *r, uint32_t count,
-                        size_t elem_size, FAR struct ring_buf_s *buf)
+                        FAR struct ring_buf_s *buf)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t prod_idx;
@@ -1917,14 +1864,14 @@ ring_sp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
                           ring_advance(r, cons_idx, discard));
       if (atomic_cmpxchg_relaxed(&blob->cons_head, &old_cons, new_cons))
         {
-          ring_buf_init(buf, r, cons_idx, discard, elem_size);
+          ring_buf_init(buf, r, cons_idx, discard);
           ring_mc_finish(r, buf);
           all_discard += discard;
           break;
         }
     }
 
-  ring_buf_init(buf, r, prod_idx, count, elem_size);
+  ring_buf_init(buf, r, prod_idx, count);
   return all_discard;
 }
 
@@ -1940,15 +1887,13 @@ ring_sp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
 
 static inline_function uint32_t
 ring_sp_overwrite(FAR struct ring_s *r, FAR const void *items,
-                  uint32_t count, size_t elem_size)
+                  uint32_t count)
 {
   struct ring_buf_s buf;
   uint32_t discard;
 
-  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);
+  discard = ring_sp_overwrite_start(r, count, &buf);
+  ring_copy_from(&buf, (FAR const char *)items + (count - buf.cnt));
   ring_sp_finish(r, &buf);
 
   return discard;
@@ -1970,7 +1915,7 @@ ring_sp_overwrite(FAR struct ring_s *r, FAR const void 
*items,
 
 static inline_function uint32_t
 ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t count,
-                        size_t elem_size, FAR struct ring_buf_s *buf)
+                        FAR struct ring_buf_s *buf)
 {
   FAR struct ring_blob_s *blob = r->blob;
   uint32_t old_prod;
@@ -1997,7 +1942,7 @@ ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
        * deadlocks the RTS tail sync.  Return an empty buf instead.
        */
 
-      ring_buf_init(buf, r, 0, 0, elem_size);
+      ring_buf_init(buf, r, 0, 0);
       return all_discard;
     }
 
@@ -2037,7 +1982,7 @@ ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
                * early, so no prod_head reservation is left unmatched.
                */
 
-              ring_buf_init(buf, r, 0, 0, elem_size);
+              ring_buf_init(buf, r, 0, 0);
               return all_discard + count;
             }
 
@@ -2049,7 +1994,7 @@ ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
               continue;
             }
 
-          ring_buf_init(buf, r, cons_idx, discard, elem_size);
+          ring_buf_init(buf, r, cons_idx, discard);
           ring_mc_finish(r, buf);
           all_discard += discard;
         }
@@ -2062,7 +2007,7 @@ ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
         }
     }
 
-  ring_buf_init(buf, r, prod_idx, count, elem_size);
+  ring_buf_init(buf, r, prod_idx, count);
   return all_discard;
 }
 
@@ -2078,15 +2023,13 @@ ring_mp_overwrite_start(FAR struct ring_s *r, uint32_t 
count,
 
 static inline_function uint32_t
 ring_mp_overwrite(FAR struct ring_s *r, FAR const void *items,
-                  uint32_t count, size_t elem_size)
+                  uint32_t count)
 {
   struct ring_buf_s buf;
   uint32_t discard;
 
-  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);
+  discard = ring_mp_overwrite_start(r, count, &buf);
+  ring_copy_from(&buf, (FAR const char *)items + (count - buf.cnt));
   ring_mp_finish(r, &buf);
 
   return discard;

Reply via email to