rte_stack.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2019 Intel Corporation
 */

#ifndef _RTE_STACK_H_
#define _RTE_STACK_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <rte_atomic.h>
#include <rte_compat.h>
#include <rte_debug.h>
#include <rte_errno.h>
#include <rte_memzone.h>
#include <rte_spinlock.h>

#define RTE_TAILQ_STACK_NAME "RTE_STACK"
#define RTE_STACK_MZ_PREFIX "STK_"

#define RTE_STACK_NAMESIZE (RTE_MEMZONE_NAMESIZE - \
                           sizeof(RTE_STACK_MZ_PREFIX) + 1)

struct rte_stack_lf_elem {
        void *data;                     
        struct rte_stack_lf_elem *next; 
};

struct rte_stack_lf_head {
        struct rte_stack_lf_elem *top; 
        uint64_t cnt; 
};

struct rte_stack_lf_list {
        struct rte_stack_lf_head head __rte_aligned(16);
        rte_atomic64_t len;
};

/* Structure containing two lock-free LIFO lists: the stack itself and a list
 * of free linked-list elements.
 */
struct rte_stack_lf {
        struct rte_stack_lf_list used __rte_cache_aligned;
        struct rte_stack_lf_list free __rte_cache_aligned;
        struct rte_stack_lf_elem elems[] __rte_cache_aligned;
};

/* Structure containing the LIFO, its current length, and a lock for mutual
 * exclusion.
 */
struct rte_stack_std {
        rte_spinlock_t lock; 
        uint32_t len; 
        void *objs[]; 
};

/* The RTE stack structure contains the LIFO structure itself, plus metadata
 * such as its name and memzone pointer.
 */
struct rte_stack {
        char name[RTE_STACK_NAMESIZE] __rte_cache_aligned;
        const struct rte_memzone *memzone;
        uint32_t capacity; 
        uint32_t flags; 
        RTE_STD_C11
        union {
                struct rte_stack_lf stack_lf; 
                struct rte_stack_std stack_std; 
        };
} __rte_cache_aligned;

#define RTE_STACK_F_LF 0x0001

#include "rte_stack_std.h"
#include "rte_stack_lf.h"

static __rte_always_inline unsigned int __rte_experimental
rte_stack_push(struct rte_stack *s, void * const *obj_table, unsigned int n)
{
        RTE_ASSERT(s != NULL);
        RTE_ASSERT(obj_table != NULL);

        if (s->flags & RTE_STACK_F_LF)
                return __rte_stack_lf_push(s, obj_table, n);
        else
                return __rte_stack_std_push(s, obj_table, n);
}

static __rte_always_inline unsigned int __rte_experimental
rte_stack_pop(struct rte_stack *s, void **obj_table, unsigned int n)
{
        RTE_ASSERT(s != NULL);
        RTE_ASSERT(obj_table != NULL);

        if (s->flags & RTE_STACK_F_LF)
                return __rte_stack_lf_pop(s, obj_table, n);
        else
                return __rte_stack_std_pop(s, obj_table, n);
}

static __rte_always_inline unsigned int __rte_experimental
rte_stack_count(struct rte_stack *s)
{
        RTE_ASSERT(s != NULL);

        if (s->flags & RTE_STACK_F_LF)
                return __rte_stack_lf_count(s);
        else
                return __rte_stack_std_count(s);
}

static __rte_always_inline unsigned int __rte_experimental
rte_stack_free_count(struct rte_stack *s)
{
        RTE_ASSERT(s != NULL);

        return s->capacity - rte_stack_count(s);
}

struct rte_stack *__rte_experimental
rte_stack_create(const char *name, unsigned int count, int socket_id,
                 uint32_t flags);

void __rte_experimental
rte_stack_free(struct rte_stack *s);

struct rte_stack * __rte_experimental
rte_stack_lookup(const char *name);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_STACK_H_ */