DPDK  23.07.0
rte_event_ring.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2016-2017 Intel Corporation
3  * Copyright(c) 2019 Arm Limited
4  */
5 
14 #ifndef _RTE_EVENT_RING_
15 #define _RTE_EVENT_RING_
16 
17 #ifdef __cplusplus
18 extern "C" {
19 #endif
20 
21 #include <stdint.h>
22 
23 #include <rte_common.h>
24 #include <rte_ring.h>
25 #include <rte_ring_elem.h>
26 #include "rte_eventdev.h"
27 
28 #define RTE_TAILQ_EVENT_RING_NAME "RTE_EVENT_RING"
29 
38  struct rte_ring r;
39 };
40 
49 static __rte_always_inline unsigned int
51 {
52  return rte_ring_count(&r->r);
53 }
54 
64 static __rte_always_inline unsigned int
66 {
67  return rte_ring_free_count(&r->r);
68 }
69 
70 
90 static __rte_always_inline unsigned int
92  const struct rte_event *events,
93  unsigned int n, uint16_t *free_space)
94 {
95  unsigned int num;
96  uint32_t space;
97 
98  num = rte_ring_enqueue_bulk_elem(&r->r, events,
99  sizeof(struct rte_event), n,
100  &space);
101 
102  if (free_space != NULL)
103  *free_space = space;
104 
105  return num;
106 }
107 
126 static __rte_always_inline unsigned int
128  struct rte_event *events,
129  unsigned int n, uint16_t *available)
130 {
131  unsigned int num;
132  uint32_t remaining;
133 
134  num = rte_ring_dequeue_bulk_elem(&r->r, events,
135  sizeof(struct rte_event), n,
136  &remaining);
137 
138  if (available != NULL)
139  *available = remaining;
140 
141  return num;
142 }
143 
164 static __rte_always_inline unsigned int
166  const struct rte_event *events,
167  unsigned int n, uint16_t *free_space)
168 {
169  unsigned int num;
170  uint32_t space;
171 
172  num = rte_ring_enqueue_burst_elem(&r->r, events,
173  sizeof(struct rte_event), n,
174  &space);
175 
176  if (free_space != NULL)
177  *free_space = space;
178 
179  return num;
180 }
181 
200 static __rte_always_inline unsigned int
202  struct rte_event *events,
203  unsigned int n, uint16_t *available)
204 {
205  unsigned int num;
206  uint32_t remaining;
207 
208  num = rte_ring_dequeue_burst_elem(&r->r, events,
209  sizeof(struct rte_event), n,
210  &remaining);
211 
212  if (available != NULL)
213  *available = remaining;
214 
215  return num;
216 }
217 
218 /*
219  * Initializes an already-allocated ring structure
220  *
221  * @param r
222  * pointer to the ring memory to be initialized
223  * @param name
224  * name to be given to the ring
225  * @param count
226  * the number of elements to be stored in the ring. If the flag
227  * ``RING_F_EXACT_SZ`` is not set, this must be a power of 2, and the actual
228  * usable space in the ring will be ``count - 1`` entries. If the flag
229  * ``RING_F_EXACT_SZ`` is set, the this can be any value up to the ring size
230  * limit - 1, and the usable space will be exactly that requested.
231  * @param flags
232  * An OR of the following:
233  * - RING_F_SP_ENQ: If this flag is set, the default behavior when
234  * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()``
235  * is "single-producer". Otherwise, it is "multi-producers".
236  * - RING_F_SC_DEQ: If this flag is set, the default behavior when
237  * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()``
238  * is "single-consumer". Otherwise, it is "multi-consumers".
239  * - RING_F_EXACT_SZ: If this flag is set, the ``count`` parameter is to
240  * be taken as the exact usable size of the ring, and as such does not
241  * need to be a power of 2. The underlying ring memory should be a
242  * power-of-2 size greater than the count value.
243  * @return
244  * 0 on success, or a negative value on error.
245  */
246 int
247 rte_event_ring_init(struct rte_event_ring *r, const char *name,
248  unsigned int count, unsigned int flags);
249 
250 /*
251  * Create an event ring structure
252  *
253  * This function allocates memory and initializes an event ring inside that
254  * memory.
255  *
256  * @param name
257  * name to be given to the ring
258  * @param count
259  * the number of elements to be stored in the ring. If the flag
260  * ``RING_F_EXACT_SZ`` is not set, this must be a power of 2, and the actual
261  * usable space in the ring will be ``count - 1`` entries. If the flag
262  * ``RING_F_EXACT_SZ`` is set, the this can be any value up to the ring size
263  * limit - 1, and the usable space will be exactly that requested.
264  * @param socket_id
265  * The *socket_id* argument is the socket identifier in case of
266  * NUMA. The value can be *SOCKET_ID_ANY* if there is no NUMA
267  * constraint for the reserved zone.
268  * @param flags
269  * An OR of the following:
270  * - RING_F_SP_ENQ: If this flag is set, the default behavior when
271  * using ``rte_ring_enqueue()`` or ``rte_ring_enqueue_bulk()``
272  * is "single-producer". Otherwise, it is "multi-producers".
273  * - RING_F_SC_DEQ: If this flag is set, the default behavior when
274  * using ``rte_ring_dequeue()`` or ``rte_ring_dequeue_bulk()``
275  * is "single-consumer". Otherwise, it is "multi-consumers".
276  * - RING_F_EXACT_SZ: If this flag is set, the ``count`` parameter is to
277  * be taken as the exact usable size of the ring, and as such does not
278  * need to be a power of 2. The underlying ring memory should be a
279  * power-of-2 size greater than the count value.
280  * @return
281  * On success, the pointer to the new allocated ring. NULL on error with
282  * rte_errno set appropriately. Possible errno values include:
283  * - E_RTE_NO_CONFIG - function could not get pointer to rte_config structure
284  * - E_RTE_SECONDARY - function was called from a secondary process instance
285  * - EINVAL - count provided is not a power of 2
286  * - ENOSPC - the maximum number of memzones has already been allocated
287  * - EEXIST - a memzone with the same name already exists
288  * - ENOMEM - no appropriate memory area found in which to create memzone
289  */
290 struct rte_event_ring *
291 rte_event_ring_create(const char *name, unsigned int count, int socket_id,
292  unsigned int flags);
293 
304 struct rte_event_ring *
305 rte_event_ring_lookup(const char *name);
306 
314 void
316 
327 static inline unsigned int
329 {
330  return rte_ring_get_size(&r->r);
331 }
332 
341 static inline unsigned int
343 {
344  return rte_ring_get_capacity(&r->r);
345 }
346 
347 #ifdef __cplusplus
348 }
349 #endif
350 
351 #endif
#define __rte_always_inline
Definition: rte_common.h:255
struct rte_event_ring * rte_event_ring_lookup(const char *name)
void rte_event_ring_free(struct rte_event_ring *r)
static __rte_always_inline unsigned int rte_ring_enqueue_bulk_elem(struct rte_ring *r, const void *obj_table, unsigned int esize, unsigned int n, unsigned int *free_space)
static __rte_always_inline unsigned int rte_event_ring_enqueue_burst(struct rte_event_ring *r, const struct rte_event *events, unsigned int n, uint16_t *free_space)
static unsigned int rte_ring_get_capacity(const struct rte_ring *r)
Definition: rte_ring.h:581
static unsigned int rte_ring_get_size(const struct rte_ring *r)
Definition: rte_ring.h:567
static __rte_always_inline unsigned int rte_event_ring_free_count(const struct rte_event_ring *r)
static unsigned int rte_event_ring_get_capacity(const struct rte_event_ring *r)
static __rte_always_inline unsigned int rte_ring_enqueue_burst_elem(struct rte_ring *r, const void *obj_table, unsigned int esize, unsigned int n, unsigned int *free_space)
static __rte_always_inline unsigned int rte_event_ring_dequeue_bulk(struct rte_event_ring *r, struct rte_event *events, unsigned int n, uint16_t *available)
static __rte_always_inline unsigned int rte_event_ring_dequeue_burst(struct rte_event_ring *r, struct rte_event *events, unsigned int n, uint16_t *available)
static __rte_always_inline unsigned int rte_event_ring_enqueue_bulk(struct rte_event_ring *r, const struct rte_event *events, unsigned int n, uint16_t *free_space)
static __rte_always_inline unsigned int rte_event_ring_count(const struct rte_event_ring *r)
static __rte_always_inline unsigned int rte_ring_dequeue_bulk_elem(struct rte_ring *r, void *obj_table, unsigned int esize, unsigned int n, unsigned int *available)
static unsigned int rte_event_ring_get_size(const struct rte_event_ring *r)
static unsigned int rte_ring_free_count(const struct rte_ring *r)
Definition: rte_ring.h:519
static __rte_always_inline unsigned int rte_ring_dequeue_burst_elem(struct rte_ring *r, void *obj_table, unsigned int esize, unsigned int n, unsigned int *available)
static unsigned int rte_ring_count(const struct rte_ring *r)
Definition: rte_ring.h:502