The ring allows the management of queues. Instead of having a linked list of infinite size, the rte_ring has the following properties:

1. FIFO
2. Maximum size is fixed, the objects are stored in a table
3. Objects can be pointers or elements of multiple of 4 byte size
4. Lockless implementation
5. Multi-consumer or single-consumer dequeue
6. Multi-producer or single-producer enqueue
7. Bulk dequeue - Dequeues the specified count of objects if successful; otherwise fails
8. Bulk enqueue - Enqueues the specified count of objects if successful; otherwise fails
9. Burst dequeue - Dequeue the maximum available objects if the specified count cannot be fulfilled
10. Burst enqueue - Enqueue the maximum available objects if the specified count cannot be fulfilled

• 1、Anatomy of a Ring Buffer

  This section explains how a ring buffer operates. The ring structure is composed of two head and tail couples; one is used by producers and one is used by the consumers. The figures of the following sections refer to them as prod_head, prod_tail, cons_head and cons_tail.

  Each figure represents a simplified state of the ring, which is a circular buffer. The content of the function local variables is represented on the top of the figure, and the content of ring structure is represented on the bottom of the figure.

  • 1.1、Single Producer Enqueue

    This section explains what occurs when a producer adds an object to the ring. In this example, only the producer head and tail (prod_head and prod_tail) are modified, and there is only one producer.

    The initial state is to have a prod_head and prod_tail pointing at the same location.

    • 1.1.1、Enqueue First Step

      First, ring->prod_head and ring->cons_tail are copied in local variables. The prod_next local variable points to the next element of the table, or several elements after in case of bulk enqueue.

    If there is not enough room in the ring (this is detected by checking cons_tail), it returns an error.
    

    • 1.1.2、Enqueue Second Step

      The second step is to modify ring->prod_head in ring structure to point to the same location as prod_next.

      The added object is copied in the ring (obj4).
      

    • 1.1.3、Enqueue Second Step

      Once the object is added in the ring, ring->prod_tail in the ring structure is modified to point to the same location as ring->prod_head. The enqueue operation is finished.
      

  • 1.2、Single Consumer Dequeue

    This section explains what occurs when a consumer dequeues an object from the ring. In this example, only the consumer head and tail (cons_head and cons_tail) are modified and there is only one consumer.

    The initial state is to have a cons_head and cons_tail pointing at the same location.

    • 1.2.1、Dequeue First Step

      First, ring->cons_head and ring->prod_tail are copied in local variables.The cons_next local variable points to the next element of the table, or several elements after in the case of bulk dequeue.

      If there are not enough objects in the ring (this is detected by checking prod_tail), it returns an error.
      

    • 1.2.2、Dequeue Second Step

      The second step is to modify ring->cons_head in the ring structure to point to the same location as cons_next.

      The dequeued object (obj1) is copied in the pointer given by the user.
      

    • 1.2.3、Dequeue Last Step

      Finally, ring->cons_tail in the ring structure is modified to point to the same location as ring->cons_head. The dequeue operation is finished.
      

  • 1.3、Multiple Producers Enqueue

    This section explains what occurs when two producers concurrently add an object to the ring. In this example, only the producer head and tail (prod_head and prod_tail) are modified.

    The initial state is to have a prod_head and prod_tail pointing at the same location.

    • 1.3.1、Multiple Producers Enqueue First Step

      On both cores, ring->prod_head and ring->cons_tail are copied in local variables. The prod_next local variable points to the next element of the table, or several elements after in the case of bulk enqueue.

      If there is not enough room in the ring (this is detected by checking cons_tail), it returns an error.
      

    • 1.3.2、Multiple Producers Enqueue Second Step

      The second step is to modify ring->prod_head in the ring structure to point to the same location as prod_next. This operation is done using a Compare And Swap (CAS) instruction, which does the following operations atomically:

      1. If ring->prod_head is different to local variable prod_head, the CAS operation fails, and the code restarts at first step.
      2. Otherwise, ring->prod_head is set to local prod_next, the CAS operation is successful, and processing continues.

      In the figure, the operation succeeded on core 1, and step one restarted on core 2.
      

    • 1.3.3、Multiple Producers Enqueue Third Step

      The CAS operation is retried on core 2 with success.

      The core 1 updates one element of the ring(obj4), and the core 2 updates another one (obj5).
      

    • 1.3.4、Multiple Producers Enqueue Fourth Step

      Each core now wants to update ring->prod_tail. A core can only update it if ring->prod_tail is equal to the prod_head local variable. This is only true on core 1. The operation is finished on core 1.
      

    • 1.3.5、Multiple Producers Enqueue Last Step

      Once ring->prod_tail is updated by core 1, core 2 is allowed to update it too. The operation is also finished on core 2.