rte_ring.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2010-2020 Intel Corporation
 * Copyright (c) 2007-2009 Kip Macy kmacy@freebsd.org
 * All rights reserved.
 * Derived from FreeBSD's bufring.h
 * Used as BSD-3 Licensed with permission from Kip Macy.
 */
 
#ifndef _RTE_RING_H_
#define _RTE_RING_H_
 
#include <rte_ring_core.h>
#include <rte_ring_elem.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
ssize_t rte_ring_get_memsize(unsigned int count);
 
int rte_ring_init(struct rte_ring *r, const char *name, unsigned int count,
    unsigned int flags);
 
struct rte_ring *rte_ring_create(const char *name, unsigned int count,
                 int socket_id, unsigned int flags);
 
void rte_ring_free(struct rte_ring *r);
 
void rte_ring_dump(FILE *f, const struct rte_ring *r);
 
static __rte_always_inline unsigned int
rte_ring_mp_enqueue_bulk(struct rte_ring *r, void * const *obj_table,
             unsigned int n, unsigned int *free_space)
{
    return rte_ring_mp_enqueue_bulk_elem(r, obj_table, sizeof(void *),
            n, free_space);
}
 
static __rte_always_inline unsigned int
rte_ring_sp_enqueue_bulk(struct rte_ring *r, void * const *obj_table,
             unsigned int n, unsigned int *free_space)
{
    return rte_ring_sp_enqueue_bulk_elem(r, obj_table, sizeof(void *),
            n, free_space);
}
 
static __rte_always_inline unsigned int
rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table,
              unsigned int n, unsigned int *free_space)
{
    return rte_ring_enqueue_bulk_elem(r, obj_table, sizeof(void *),
            n, free_space);
}
 
static __rte_always_inline int
rte_ring_mp_enqueue(struct rte_ring *r, void *obj)
{
    return rte_ring_mp_enqueue_elem(r, &obj, sizeof(void *));
}
 
static __rte_always_inline int
rte_ring_sp_enqueue(struct rte_ring *r, void *obj)
{
    return rte_ring_sp_enqueue_elem(r, &obj, sizeof(void *));
}
 
static __rte_always_inline int
rte_ring_enqueue(struct rte_ring *r, void *obj)
{
    return rte_ring_enqueue_elem(r, &obj, sizeof(void *));
}
 
static __rte_always_inline unsigned int
rte_ring_mc_dequeue_bulk(struct rte_ring *r, void **obj_table,
        unsigned int n, unsigned int *available)
{
    return rte_ring_mc_dequeue_bulk_elem(r, obj_table, sizeof(void *),
            n, available);
}
 
static __rte_always_inline unsigned int
rte_ring_sc_dequeue_bulk(struct rte_ring *r, void **obj_table,
        unsigned int n, unsigned int *available)
{
    return rte_ring_sc_dequeue_bulk_elem(r, obj_table, sizeof(void *),
            n, available);
}
 
static __rte_always_inline unsigned int
rte_ring_dequeue_bulk(struct rte_ring *r, void **obj_table, unsigned int n,
        unsigned int *available)
{
    return rte_ring_dequeue_bulk_elem(r, obj_table, sizeof(void *),
            n, available);
}
 
static __rte_always_inline int
rte_ring_mc_dequeue(struct rte_ring *r, void **obj_p)
{
    return rte_ring_mc_dequeue_elem(r, obj_p, sizeof(void *));
}
 
static __rte_always_inline int
rte_ring_sc_dequeue(struct rte_ring *r, void **obj_p)
{
    return rte_ring_sc_dequeue_elem(r, obj_p, sizeof(void *));
}
 
static __rte_always_inline int
rte_ring_dequeue(struct rte_ring *r, void **obj_p)
{
    return rte_ring_dequeue_elem(r, obj_p, sizeof(void *));
}
 
void
rte_ring_reset(struct rte_ring *r);
 
static inline unsigned int
rte_ring_count(const struct rte_ring *r)
{
    uint32_t prod_tail = r->prod.tail;
    uint32_t cons_tail = r->cons.tail;
    uint32_t count = (prod_tail - cons_tail) & r->mask;
    return (count > r->capacity) ? r->capacity : count;
}
 
static inline unsigned int
rte_ring_free_count(const struct rte_ring *r)
{
    return r->capacity - rte_ring_count(r);
}
 
static inline int
rte_ring_full(const struct rte_ring *r)
{
    return rte_ring_free_count(r) == 0;
}
 
static inline int
rte_ring_empty(const struct rte_ring *r)
{
    uint32_t prod_tail = r->prod.tail;
    uint32_t cons_tail = r->cons.tail;
    return cons_tail == prod_tail;
}
 
static inline unsigned int
rte_ring_get_size(const struct rte_ring *r)
{
    return r->size;
}
 
static inline unsigned int
rte_ring_get_capacity(const struct rte_ring *r)
{
    return r->capacity;
}
 
static inline enum rte_ring_sync_type
rte_ring_get_prod_sync_type(const struct rte_ring *r)
{
    return r->prod.sync_type;
}
 
static inline int
rte_ring_is_prod_single(const struct rte_ring *r)
{
    return (rte_ring_get_prod_sync_type(r) == RTE_RING_SYNC_ST);
}
 
static inline enum rte_ring_sync_type
rte_ring_get_cons_sync_type(const struct rte_ring *r)
{
    return r->cons.sync_type;
}
 
static inline int
rte_ring_is_cons_single(const struct rte_ring *r)
{
    return (rte_ring_get_cons_sync_type(r) == RTE_RING_SYNC_ST);
}
 
void rte_ring_list_dump(FILE *f);
 
struct rte_ring *rte_ring_lookup(const char *name);
 
static __rte_always_inline unsigned int
rte_ring_mp_enqueue_burst(struct rte_ring *r, void * const *obj_table,
             unsigned int n, unsigned int *free_space)
{
    return rte_ring_mp_enqueue_burst_elem(r, obj_table, sizeof(void *),
            n, free_space);
}
 
static __rte_always_inline unsigned int
rte_ring_sp_enqueue_burst(struct rte_ring *r, void * const *obj_table,
             unsigned int n, unsigned int *free_space)
{
    return rte_ring_sp_enqueue_burst_elem(r, obj_table, sizeof(void *),
            n, free_space);
}
 
static __rte_always_inline unsigned int
rte_ring_enqueue_burst(struct rte_ring *r, void * const *obj_table,
              unsigned int n, unsigned int *free_space)
{
    return rte_ring_enqueue_burst_elem(r, obj_table, sizeof(void *),
            n, free_space);
}
 
static __rte_always_inline unsigned int
rte_ring_mc_dequeue_burst(struct rte_ring *r, void **obj_table,
        unsigned int n, unsigned int *available)
{
    return rte_ring_mc_dequeue_burst_elem(r, obj_table, sizeof(void *),
            n, available);
}
 
static __rte_always_inline unsigned int
rte_ring_sc_dequeue_burst(struct rte_ring *r, void **obj_table,
        unsigned int n, unsigned int *available)
{
    return rte_ring_sc_dequeue_burst_elem(r, obj_table, sizeof(void *),
            n, available);
}
 
static __rte_always_inline unsigned int
rte_ring_dequeue_burst(struct rte_ring *r, void **obj_table,
        unsigned int n, unsigned int *available)
{
    return rte_ring_dequeue_burst_elem(r, obj_table, sizeof(void *),
            n, available);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_RING_H_ */