net/mlx5: support connection tracking between two ports

[dpdk.git] / drivers / event / sw / event_ring.h

diff --git a/drivers/event/sw/event_ring.h b/drivers/event/sw/event_ring.h
index 0230872..2b86ca9 100644 (file)
--- a/drivers/event/sw/event_ring.h
+++ b/drivers/event/sw/event_ring.h
@@ -20,23 +20,20 @@
 #include <rte_memory.h>
 #include <rte_malloc.h>
 
-#define QE_RING_NAMESIZE 32
-
-struct qe_ring {
-       char name[QE_RING_NAMESIZE] __rte_cache_aligned;
-       uint32_t ring_size; /* size of memory block allocated to the ring */
-       uint32_t mask;      /* mask for read/write values == ring_size -1 */
-       uint32_t size;      /* actual usable space in the ring */
-       volatile uint32_t write_idx __rte_cache_aligned;
-       volatile uint32_t read_idx __rte_cache_aligned;
-
-       struct rte_event ring[0] __rte_cache_aligned;
+/* Custom single threaded ring implementation used for ROB */
+struct rob_ring {
+       uint32_t ring_size;
+       uint32_t mask;
+       uint32_t size;
+       uint32_t write_idx;
+       uint32_t read_idx;
+       void *ring[0] __rte_cache_aligned;
 };
 
-static inline struct qe_ring *
-qe_ring_create(const char *name, unsigned int size, unsigned int socket_id)
+static inline struct rob_ring *
+rob_ring_create(unsigned int size, unsigned int socket_id)
 {
-       struct qe_ring *retval;
+       struct rob_ring *retval;
        const uint32_t ring_size = rte_align32pow2(size + 1);
        size_t memsize = sizeof(*retval) +
                        (ring_size * sizeof(retval->ring[0]));
@@ -44,8 +41,6 @@ qe_ring_create(const char *name, unsigned int size, unsigned int socket_id)
        retval = rte_zmalloc_socket(NULL, memsize, 0, socket_id);
        if (retval == NULL)
                goto end;
-
-       snprintf(retval->name, sizeof(retval->name), "EVDEV_RG_%s", name);
        retval->ring_size = ring_size;
        retval->mask = ring_size - 1;
        retval->size = size;
@@ -54,100 +49,50 @@ end:
 }
 
 static inline void
-qe_ring_destroy(struct qe_ring *r)
+rob_ring_free(struct rob_ring *r)
 {
        rte_free(r);
 }
 
 static __rte_always_inline unsigned int
-qe_ring_count(const struct qe_ring *r)
+rob_ring_count(const struct rob_ring *r)
 {
        return r->write_idx - r->read_idx;
 }
 
 static __rte_always_inline unsigned int
-qe_ring_free_count(const struct qe_ring *r)
+rob_ring_free_count(const struct rob_ring *r)
 {
-       return r->size - qe_ring_count(r);
+       return r->size - rob_ring_count(r);
 }
 
 static __rte_always_inline unsigned int
-qe_ring_enqueue_burst(struct qe_ring *r, const struct rte_event *qes,
-               unsigned int nb_qes, uint16_t *free_count)
+rob_ring_enqueue(struct rob_ring *r, void *re)
 {
        const uint32_t size = r->size;
        const uint32_t mask = r->mask;
        const uint32_t read = r->read_idx;
        uint32_t write = r->write_idx;
        const uint32_t space = read + size - write;
-       uint32_t i;
-
-       if (space < nb_qes)
-               nb_qes = space;
-
-       for (i = 0; i < nb_qes; i++, write++)
-               r->ring[write & mask] = qes[i];
-
-       rte_smp_wmb();
-
-       if (nb_qes != 0)
-               r->write_idx = write;
-
-       *free_count = space - nb_qes;
-
-       return nb_qes;
+       if (space < 1)
+               return 0;
+       r->ring[write & mask] = re;
+       r->write_idx++;
+       return 1;
 }
 
 static __rte_always_inline unsigned int
-qe_ring_enqueue_burst_with_ops(struct qe_ring *r, const struct rte_event *qes,
-               unsigned int nb_qes, uint8_t *ops)
-{
-       const uint32_t size = r->size;
-       const uint32_t mask = r->mask;
-       const uint32_t read = r->read_idx;
-       uint32_t write = r->write_idx;
-       const uint32_t space = read + size - write;
-       uint32_t i;
-
-       if (space < nb_qes)
-               nb_qes = space;
-
-       for (i = 0; i < nb_qes; i++, write++) {
-               r->ring[write & mask] = qes[i];
-               r->ring[write & mask].op = ops[i];
-       }
-
-       rte_smp_wmb();
-
-       if (nb_qes != 0)
-               r->write_idx = write;
-
-       return nb_qes;
-}
-
-static __rte_always_inline unsigned int
-qe_ring_dequeue_burst(struct qe_ring *r, struct rte_event *qes,
-               unsigned int nb_qes)
+rob_ring_dequeue(struct rob_ring *r, void **re)
 {
        const uint32_t mask = r->mask;
        uint32_t read = r->read_idx;
        const uint32_t write = r->write_idx;
        const uint32_t items = write - read;
-       uint32_t i;
-
-       if (items < nb_qes)
-               nb_qes = items;
-
-
-       for (i = 0; i < nb_qes; i++, read++)
-               qes[i] = r->ring[read & mask];
-
-       rte_smp_rmb();
-
-       if (nb_qes != 0)
-               r->read_idx += nb_qes;
-
-       return nb_qes;
+       if (items < 1)
+               return 0;
+       *re = r->ring[read & mask];
+       r->read_idx++;
+       return 1;
 }
 
 #endif