From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by dpdk.org (Postfix) with ESMTP id 21F96F614 for ; Tue, 24 Jan 2017 11:40:05 +0100 (CET) Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga102.jf.intel.com with ESMTP; 24 Jan 2017 02:40:05 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.33,278,1477983600"; d="scan'208";a="34686954" Received: from sivswdev01.ir.intel.com (HELO localhost.localdomain) ([10.237.217.45]) by orsmga002.jf.intel.com with ESMTP; 24 Jan 2017 02:40:04 -0800 From: Bruce Richardson To: olivier.matz@6wind.com Cc: dev@dpdk.org, Bruce Richardson Date: Tue, 24 Jan 2017 10:39:37 +0000 Message-Id: <1485254377-20098-5-git-send-email-bruce.richardson@intel.com> X-Mailer: git-send-email 1.7.0.7 In-Reply-To: <1485254377-20098-1-git-send-email-bruce.richardson@intel.com> References: <1485254377-20098-1-git-send-email-bruce.richardson@intel.com> Subject: [dpdk-dev] [PATCH RFCv2 4/4] ring: add new event ring class X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 24 Jan 2017 10:40:07 -0000 using a placeholder struct type of the correct (16B) size, create an event ring type and unit test it to verify the generalized ring implementation works. Signed-off-by: Bruce Richardson --- app/test/Makefile | 1 + app/test/test_event_ring.c | 83 +++++ lib/librte_ring/Makefile | 2 + lib/librte_ring/rte_event_ring.c | 87 +++++ lib/librte_ring/rte_event_ring.h | 696 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 869 insertions(+) create mode 100644 app/test/test_event_ring.c create mode 100644 lib/librte_ring/rte_event_ring.c create mode 100644 lib/librte_ring/rte_event_ring.h diff --git a/app/test/Makefile b/app/test/Makefile index 9de301f..c0ab2ba 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -96,6 +96,7 @@ SRCS-y += test_memory.c SRCS-y += test_memzone.c SRCS-y += test_ring.c +SRCS-y += test_event_ring.c SRCS-y += test_ring_perf.c SRCS-y += test_pmd_perf.c diff --git a/app/test/test_event_ring.c b/app/test/test_event_ring.c new file mode 100644 index 0000000..94f85cd --- /dev/null +++ b/app/test/test_event_ring.c @@ -0,0 +1,83 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include "test.h" + +#define BURST_SIZE 24 /* not a power of two so we can test wrap around better */ +#define RING_SIZE 128 +#define ENQ_ITERATIONS 48 + +#define ERR_OUT() do { \ + printf("Error %s:%d\n", __FILE__, __LINE__); \ + return -1; \ +} while (0) + +static int +test_event_ring(void) +{ + struct rte_event in_events[BURST_SIZE]; + struct rte_event out_events[BURST_SIZE]; + unsigned int i; + + struct rte_ring *ering = rte_event_ring_create("TEST_RING", RING_SIZE, + rte_socket_id(), RING_F_SP_ENQ|RING_F_SC_DEQ); + if (ering == NULL) + ERR_OUT(); + + for (i = 0; i < BURST_SIZE; i++) + in_events[i].event_metadata = rte_rand(); + + for (i = 0; i < ENQ_ITERATIONS; i++) + if (rte_event_ring_enqueue_bulk(ering, in_events, + RTE_DIM(in_events)) != 0) { + unsigned j; + + if (rte_event_ring_dequeue_burst(ering, out_events, + RTE_DIM(out_events)) != RTE_DIM(out_events)) + ERR_OUT(); + for (j = 0; j < RTE_DIM(out_events); j++) + if (out_events[j].event_metadata != + in_events[j].event_metadata) + ERR_OUT(); + /* retry, now that we've made space */ + if (rte_event_ring_enqueue_bulk(ering, in_events, + RTE_DIM(in_events)) != 0) + ERR_OUT(); + } + + return 0; +} + +REGISTER_TEST_COMMAND(event_ring_autotest, test_event_ring); diff --git a/lib/librte_ring/Makefile b/lib/librte_ring/Makefile index 5cebb29..fb1c9e5 100644 --- a/lib/librte_ring/Makefile +++ b/lib/librte_ring/Makefile @@ -43,10 +43,12 @@ LIBABIVER := 1 # all source are stored in SRCS-y SRCS-$(CONFIG_RTE_LIBRTE_RING) += rte_common_ring.c SRCS-$(CONFIG_RTE_LIBRTE_RING) += rte_ring.c +SRCS-$(CONFIG_RTE_LIBRTE_RING) += rte_event_ring.c # install includes SYMLINK-$(CONFIG_RTE_LIBRTE_RING)-include += rte_ring.h SYMLINK-$(CONFIG_RTE_LIBRTE_RING)-include += rte_common_ring.h +SYMLINK-$(CONFIG_RTE_LIBRTE_RING)-include += rte_event_ring.h DEPDIRS-$(CONFIG_RTE_LIBRTE_RING) += lib/librte_eal diff --git a/lib/librte_ring/rte_event_ring.c b/lib/librte_ring/rte_event_ring.c new file mode 100644 index 0000000..db053bc --- /dev/null +++ b/lib/librte_ring/rte_event_ring.c @@ -0,0 +1,87 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "rte_event_ring.h" + +ssize_t +rte_event_ring_get_memsize(unsigned count) +{ + return rte_common_ring_get_memsize(count, sizeof(struct rte_event)); +} + +int +rte_event_ring_init(struct rte_ring *r, const char *name, unsigned count, + unsigned flags) +{ + return rte_common_ring_init(r, name, count, flags, sizeof(struct rte_event)); +} + + +struct rte_ring * +rte_event_ring_create(const char *name, unsigned count, int socket_id, + unsigned flags) +{ + return rte_common_ring_create(name, count, socket_id, flags, + sizeof(struct rte_event)); +} + +void +rte_event_ring_free(struct rte_ring *r) +{ + return rte_common_ring_free(r); +} + +int +rte_event_ring_set_water_mark(struct rte_ring *r, unsigned count) +{ + return rte_common_ring_set_water_mark(r, count); +} + +void +rte_event_ring_dump(FILE *f, const struct rte_ring *r) +{ + return rte_common_ring_dump(f, r); +} + +void +rte_event_ring_list_dump(FILE *f) +{ + rte_common_ring_list_dump(f); +} + +struct rte_ring * +rte_event_ring_lookup(const char *name) +{ + return rte_common_ring_lookup(name); +} + diff --git a/lib/librte_ring/rte_event_ring.h b/lib/librte_ring/rte_event_ring.h new file mode 100644 index 0000000..a175800 --- /dev/null +++ b/lib/librte_ring/rte_event_ring.h @@ -0,0 +1,696 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _RTE_EVENT_RING_H_ +#define _RTE_EVENT_RING_H_ + +/** + * @file + * RTE Event Ring + * + * The Ring Manager is a fixed-size event queue, implemented as a table of + * events. Head and tail pointers are modified atomically, allowing + * concurrent access to it. It has the following features: + * + * - FIFO (First In First Out) + * - Maximum size is fixed; the pointers are stored in a table. + * - Lockless implementation. + * - Multi- or single-consumer dequeue. + * - Multi- or single-producer enqueue. + * - Bulk dequeue. + * - Bulk enqueue. + * + * Note: the ring implementation is not preemptable. A lcore must not + * be interrupted by another task that uses the same ring. + * + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "rte_common_ring.h" + +struct rte_event { + uint64_t event_metadata; + struct rte_mbuf *mbuf; +}; + +/** + * Calculate the memory size needed for a ring + * + * This function returns the number of bytes needed for a ring, given + * the number of elements in it. This value is the sum of the size of + * the structure rte_ring and the size of the memory needed by the + * objects pointers. The value is aligned to a cache line size. + * + * @param count + * The number of elements in the ring (must be a power of 2). + * @return + * - The memory size needed for the ring on success. + * - -EINVAL if count is not a power of 2. + */ +ssize_t rte_event_ring_get_memsize(unsigned count); + +/** + * Initialize a ring structure. + * + * Initialize a ring structure in memory pointed by "r". The size of the + * memory area must be large enough to store the ring structure and the + * object table. It is advised to use rte_event_ring_get_memsize() to get the + * appropriate size. + * + * The ring size is set to *count*, which must be a power of two. Water + * marking is disabled by default. The real usable ring size is + * *count-1* instead of *count* to differentiate a free ring from an + * empty ring. + * + * The ring is not added in RTE_TAILQ_RING global list. Indeed, the + * memory given by the caller may not be shareable among dpdk + * processes. + * + * @param r + * The pointer to the ring structure followed by the objects table. + * @param name + * The name of the ring. + * @param count + * The number of elements in the ring (must be a power of 2). + * @param flags + * An OR of the following: + * - RING_F_SP_ENQ: If this flag is set, the default behavior when + * using ``rte_event_ring_enqueue()`` or ``rte_event_ring_enqueue_bulk()`` + * is "single-producer". Otherwise, it is "multi-producers". + * - RING_F_SC_DEQ: If this flag is set, the default behavior when + * using ``rte_event_ring_dequeue()`` or ``rte_event_ring_dequeue_bulk()`` + * is "single-consumer". Otherwise, it is "multi-consumers". + * @return + * 0 on success, or a negative value on error. + */ +int rte_event_ring_init(struct rte_ring *r, const char *name, unsigned count, + unsigned flags); + +/** + * Create a new ring named *name* in memory. + * + * This function uses ``memzone_reserve()`` to allocate memory. Then it + * calls rte_event_ring_init() to initialize an empty ring. + * + * The new ring size is set to *count*, which must be a power of + * two. Water marking is disabled by default. The real usable ring size + * is *count-1* instead of *count* to differentiate a free ring from an + * empty ring. + * + * The ring is added in RTE_TAILQ_RING list. + * + * @param name + * The name of the ring. + * @param count + * The size of the ring (must be a power of 2). + * @param socket_id + * The *socket_id* argument is the socket identifier in case of + * NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA + * constraint for the reserved zone. + * @param flags + * An OR of the following: + * - RING_F_SP_ENQ: If this flag is set, the default behavior when + * using ``rte_event_ring_enqueue()`` or ``rte_event_ring_enqueue_bulk()`` + * is "single-producer". Otherwise, it is "multi-producers". + * - RING_F_SC_DEQ: If this flag is set, the default behavior when + * using ``rte_event_ring_dequeue()`` or ``rte_event_ring_dequeue_bulk()`` + * is "single-consumer". Otherwise, it is "multi-consumers". + * @return + * On success, the pointer to the new allocated ring. NULL on error with + * rte_errno set appropriately. Possible errno values include: + * - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure + * - E_RTE_SECONDARY - function was called from a secondary process instance + * - EINVAL - count provided is not a power of 2 + * - ENOSPC - the maximum number of memzones has already been allocated + * - EEXIST - a memzone with the same name already exists + * - ENOMEM - no appropriate memory area found in which to create memzone + */ +struct rte_ring *rte_event_ring_create(const char *name, unsigned count, + int socket_id, unsigned flags); +/** + * De-allocate all memory used by the ring. + * + * @param r + * Ring to free + */ +void rte_event_ring_free(struct rte_ring *r); + +/** + * Change the high water mark. + * + * If *count* is 0, water marking is disabled. Otherwise, it is set to the + * *count* value. The *count* value must be greater than 0 and less + * than the ring size. + * + * This function can be called at any time (not necessarily at + * initialization). + * + * @param r + * A pointer to the ring structure. + * @param count + * The new water mark value. + * @return + * - 0: Success; water mark changed. + * - -EINVAL: Invalid water mark value. + */ +int rte_event_ring_set_water_mark(struct rte_ring *r, unsigned count); + +/** + * Dump the status of the ring to a file. + * + * @param f + * A pointer to a file for output + * @param r + * A pointer to the ring structure. + */ +void rte_event_ring_dump(FILE *f, const struct rte_ring *r); + +/** + * Enqueue several objects on the ring (multi-producers safe). + * + * This function uses a "compare and set" instruction to move the + * producer index atomically. + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects). + * @param n + * The number of objects to add in the ring from the obj_table. + * @return + * - 0: Success; objects enqueue. + * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the + * high water mark is exceeded. + * - -ENOBUFS: Not enough room in the ring to enqueue, no object is enqueued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_mp_enqueue_bulk(struct rte_ring *r, const struct rte_event * const obj_table, + unsigned n) +{ + return __rte_common_ring_mp_do_enqueue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_FIXED); +} + +/** + * Enqueue several objects on a ring (NOT multi-producers safe). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects). + * @param n + * The number of objects to add in the ring from the obj_table. + * @return + * - 0: Success; objects enqueued. + * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the + * high water mark is exceeded. + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_sp_enqueue_bulk(struct rte_ring *r, const struct rte_event * const obj_table, + unsigned n) +{ + return __rte_common_ring_sp_do_enqueue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_FIXED); +} + +/** + * Enqueue several objects on a ring. + * + * This function calls the multi-producer or the single-producer + * version depending on the default behavior that was specified at + * ring creation time (see flags). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects). + * @param n + * The number of objects to add in the ring from the obj_table. + * @return + * - 0: Success; objects enqueued. + * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the + * high water mark is exceeded. + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_enqueue_bulk(struct rte_ring *r, const struct rte_event * const obj_table, + unsigned n) +{ + if (r->prod.sp_enqueue) + return rte_event_ring_sp_enqueue_bulk(r, obj_table, n); + else + return rte_event_ring_mp_enqueue_bulk(r, obj_table, n); +} + +/** + * Enqueue one object on a ring (multi-producers safe). + * + * This function uses a "compare and set" instruction to move the + * producer index atomically. + * + * @param r + * A pointer to the ring structure. + * @param obj + * A pointer to the object to be added. + * @return + * - 0: Success; objects enqueued. + * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the + * high water mark is exceeded. + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_mp_enqueue(struct rte_ring *r, const struct rte_event obj) +{ + return rte_event_ring_mp_enqueue_bulk(r, &obj, 1); +} + +/** + * Enqueue one object on a ring (NOT multi-producers safe). + * + * @param r + * A pointer to the ring structure. + * @param obj + * A pointer to the object to be added. + * @return + * - 0: Success; objects enqueued. + * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the + * high water mark is exceeded. + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_sp_enqueue(struct rte_ring *r, const struct rte_event obj) +{ + return rte_event_ring_sp_enqueue_bulk(r, &obj, 1); +} + +/** + * Enqueue one object on a ring. + * + * This function calls the multi-producer or the single-producer + * version, depending on the default behaviour that was specified at + * ring creation time (see flags). + * + * @param r + * A pointer to the ring structure. + * @param obj + * A pointer to the object to be added. + * @return + * - 0: Success; objects enqueued. + * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the + * high water mark is exceeded. + * - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_enqueue(struct rte_ring *r, const struct rte_event obj) +{ + if (r->prod.sp_enqueue) + return rte_event_ring_sp_enqueue(r, obj); + else + return rte_event_ring_mp_enqueue(r, obj); +} + +/** + * Dequeue several objects from a ring (multi-consumers safe). + * + * This function uses a "compare and set" instruction to move the + * consumer index atomically. + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects) that will be filled. + * @param n + * The number of objects to dequeue from the ring to the obj_table. + * @return + * - 0: Success; objects dequeued. + * - -ENOENT: Not enough entries in the ring to dequeue; no object is + * dequeued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_mc_dequeue_bulk(struct rte_ring *r, struct rte_event * const obj_table, unsigned n) +{ + return __rte_common_ring_mc_do_dequeue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_FIXED); +} + +/** + * Dequeue several objects from a ring (NOT multi-consumers safe). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects) that will be filled. + * @param n + * The number of objects to dequeue from the ring to the obj_table, + * must be strictly positive. + * @return + * - 0: Success; objects dequeued. + * - -ENOENT: Not enough entries in the ring to dequeue; no object is + * dequeued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_sc_dequeue_bulk(struct rte_ring *r, struct rte_event * const obj_table, unsigned n) +{ + return __rte_common_ring_sc_do_dequeue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_FIXED); +} + +/** + * Dequeue several objects from a ring. + * + * This function calls the multi-consumers or the single-consumer + * version, depending on the default behaviour that was specified at + * ring creation time (see flags). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects) that will be filled. + * @param n + * The number of objects to dequeue from the ring to the obj_table. + * @return + * - 0: Success; objects dequeued. + * - -ENOENT: Not enough entries in the ring to dequeue, no object is + * dequeued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_dequeue_bulk(struct rte_ring *r, struct rte_event * const obj_table, unsigned n) +{ + if (r->cons.sc_dequeue) + return rte_event_ring_sc_dequeue_bulk(r, obj_table, n); + else + return rte_event_ring_mc_dequeue_bulk(r, obj_table, n); +} + +/** + * Dequeue one object from a ring (multi-consumers safe). + * + * This function uses a "compare and set" instruction to move the + * consumer index atomically. + * + * @param r + * A pointer to the ring structure. + * @param obj_p + * A pointer to a void * pointer (object) that will be filled. + * @return + * - 0: Success; objects dequeued. + * - -ENOENT: Not enough entries in the ring to dequeue; no object is + * dequeued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_mc_dequeue(struct rte_ring *r, struct rte_event *obj_p) +{ + return rte_event_ring_mc_dequeue_bulk(r, obj_p, 1); +} + +/** + * Dequeue one object from a ring (NOT multi-consumers safe). + * + * @param r + * A pointer to the ring structure. + * @param obj_p + * A pointer to a void * pointer (object) that will be filled. + * @return + * - 0: Success; objects dequeued. + * - -ENOENT: Not enough entries in the ring to dequeue, no object is + * dequeued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_sc_dequeue(struct rte_ring *r, struct rte_event *obj_p) +{ + return rte_event_ring_sc_dequeue_bulk(r, obj_p, 1); +} + +/** + * Dequeue one object from a ring. + * + * This function calls the multi-consumers or the single-consumer + * version depending on the default behaviour that was specified at + * ring creation time (see flags). + * + * @param r + * A pointer to the ring structure. + * @param obj_p + * A pointer to a void * pointer (object) that will be filled. + * @return + * - 0: Success, objects dequeued. + * - -ENOENT: Not enough entries in the ring to dequeue, no object is + * dequeued. + */ +static inline int __attribute__((always_inline)) +rte_event_ring_dequeue(struct rte_ring *r, struct rte_event *obj_p) +{ + if (r->cons.sc_dequeue) + return rte_event_ring_sc_dequeue(r, obj_p); + else + return rte_event_ring_mc_dequeue(r, obj_p); +} + +/** + * Test if a ring is full. + * + * @param r + * A pointer to the ring structure. + * @return + * - 1: The ring is full. + * - 0: The ring is not full. + */ +static inline int +rte_event_ring_full(const struct rte_ring *r) +{ + return rte_common_ring_full(r); +} + +/** + * Test if a ring is empty. + * + * @param r + * A pointer to the ring structure. + * @return + * - 1: The ring is empty. + * - 0: The ring is not empty. + */ +static inline int +rte_event_ring_empty(const struct rte_ring *r) +{ + return rte_common_ring_empty(r); +} + +/** + * Return the number of entries in a ring. + * + * @param r + * A pointer to the ring structure. + * @return + * The number of entries in the ring. + */ +static inline unsigned +rte_event_ring_count(const struct rte_ring *r) +{ + return rte_common_ring_count(r); +} + +/** + * Return the number of free entries in a ring. + * + * @param r + * A pointer to the ring structure. + * @return + * The number of free entries in the ring. + */ +static inline unsigned +rte_event_ring_free_count(const struct rte_ring *r) +{ + return rte_common_ring_free_count(r); +} + +/** + * Dump the status of all rings on the console + * + * @param f + * A pointer to a file for output + */ +void rte_event_ring_list_dump(FILE *f); + +/** + * Search a ring from its name + * + * @param name + * The name of the ring. + * @return + * The pointer to the ring matching the name, or NULL if not found, + * with rte_errno set appropriately. Possible rte_errno values include: + * - ENOENT - required entry not available to return. + */ +struct rte_ring *rte_event_ring_lookup(const char *name); + +/** + * Enqueue several objects on the ring (multi-producers safe). + * + * This function uses a "compare and set" instruction to move the + * producer index atomically. + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects). + * @param n + * The number of objects to add in the ring from the obj_table. + * @return + * - n: Actual number of objects enqueued. + */ +static inline unsigned __attribute__((always_inline)) +rte_event_ring_mp_enqueue_burst(struct rte_ring *r, const struct rte_event * const obj_table, + unsigned n) +{ + return __rte_common_ring_mp_do_enqueue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_VARIABLE); +} + +/** + * Enqueue several objects on a ring (NOT multi-producers safe). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects). + * @param n + * The number of objects to add in the ring from the obj_table. + * @return + * - n: Actual number of objects enqueued. + */ +static inline unsigned __attribute__((always_inline)) +rte_event_ring_sp_enqueue_burst(struct rte_ring *r, const struct rte_event * const obj_table, + unsigned n) +{ + return __rte_common_ring_sp_do_enqueue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_VARIABLE); +} + +/** + * Enqueue several objects on a ring. + * + * This function calls the multi-producer or the single-producer + * version depending on the default behavior that was specified at + * ring creation time (see flags). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects). + * @param n + * The number of objects to add in the ring from the obj_table. + * @return + * - n: Actual number of objects enqueued. + */ +static inline unsigned __attribute__((always_inline)) +rte_event_ring_enqueue_burst(struct rte_ring *r, const struct rte_event * const obj_table, + unsigned n) +{ + if (r->prod.sp_enqueue) + return rte_event_ring_sp_enqueue_burst(r, obj_table, n); + else + return rte_event_ring_mp_enqueue_burst(r, obj_table, n); +} + +/** + * Dequeue several objects from a ring (multi-consumers safe). When the request + * objects are more than the available objects, only dequeue the actual number + * of objects + * + * This function uses a "compare and set" instruction to move the + * consumer index atomically. + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects) that will be filled. + * @param n + * The number of objects to dequeue from the ring to the obj_table. + * @return + * - n: Actual number of objects dequeued, 0 if ring is empty + */ +static inline unsigned __attribute__((always_inline)) +rte_event_ring_mc_dequeue_burst(struct rte_ring *r, struct rte_event * const obj_table, unsigned n) +{ + return __rte_common_ring_mc_do_dequeue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_VARIABLE); +} + +/** + * Dequeue several objects from a ring (NOT multi-consumers safe).When the + * request objects are more than the available objects, only dequeue the + * actual number of objects + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects) that will be filled. + * @param n + * The number of objects to dequeue from the ring to the obj_table. + * @return + * - n: Actual number of objects dequeued, 0 if ring is empty + */ +static inline unsigned __attribute__((always_inline)) +rte_event_ring_sc_dequeue_burst(struct rte_ring *r, struct rte_event * const obj_table, unsigned n) +{ + return __rte_common_ring_sc_do_dequeue(r, obj_table, n, sizeof(struct rte_event), RTE_RING_QUEUE_VARIABLE); +} + +/** + * Dequeue multiple objects from a ring up to a maximum number. + * + * This function calls the multi-consumers or the single-consumer + * version, depending on the default behaviour that was specified at + * ring creation time (see flags). + * + * @param r + * A pointer to the ring structure. + * @param obj_table + * A pointer to a table of void * pointers (objects) that will be filled. + * @param n + * The number of objects to dequeue from the ring to the obj_table. + * @return + * - Number of objects dequeued + */ +static inline unsigned __attribute__((always_inline)) +rte_event_ring_dequeue_burst(struct rte_ring *r, struct rte_event * const obj_table, unsigned n) +{ + if (r->cons.sc_dequeue) + return rte_event_ring_sc_dequeue_burst(r, obj_table, n); + else + return rte_event_ring_mc_dequeue_burst(r, obj_table, n); +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_EVENT_RING_H_ */ -- 2.9.3