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 <stdalign.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 {
    alignas(16) struct rte_stack_lf_head head;
    RTE_ATOMIC(uint64_t) len;
};

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

/* 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_cache_aligned rte_stack {
    alignas(RTE_CACHE_LINE_SIZE) char name[RTE_STACK_NAMESIZE];
    const struct rte_memzone *memzone;
    uint32_t capacity; 
    uint32_t flags; 
    union {
        struct rte_stack_lf stack_lf; 
        struct rte_stack_std stack_std; 
    };
};

#define RTE_STACK_F_LF 0x0001

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

static __rte_always_inline unsigned int
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_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_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_stack_free_count(struct rte_stack *s)
{
    RTE_ASSERT(s != NULL);

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

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

void
rte_stack_free(struct rte_stack *s);

struct rte_stack *
rte_stack_lookup(const char *name);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_STACK_H_ */