rte_stack_lf.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2019 Intel Corporation
 */
 
#ifndef _RTE_STACK_LF_H_
#define _RTE_STACK_LF_H_
 
#if !(defined(RTE_ARCH_X86_64) || defined(RTE_ARCH_ARM64))
#include "rte_stack_lf_stubs.h"
#else
#include "rte_stack_lf_c11.h"
 
#define RTE_STACK_LF_SUPPORTED
#endif
 
static __rte_always_inline unsigned int
__rte_stack_lf_count(struct rte_stack *s)
{
    /* stack_lf_push() and stack_lf_pop() do not update the list's contents
     * and stack_lf->len atomically, which can cause the list to appear
     * shorter than it actually is if this function is called while other
     * threads are modifying the list.
     *
     * However, given the inherently approximate nature of the get_count
     * callback -- even if the list and its size were updated atomically,
     * the size could change between when get_count executes and when the
     * value is returned to the caller -- this is acceptable.
     *
     * The stack_lf->len updates are placed such that the list may appear to
     * have fewer elements than it does, but will never appear to have more
     * elements. If the mempool is near-empty to the point that this is a
     * concern, the user should consider increasing the mempool size.
     */
    return __rte_stack_lf_elems_count(&s->stack_lf.used);
}
 
static __rte_always_inline unsigned int
__rte_stack_lf_push(struct rte_stack *s,
            void * const *obj_table,
            unsigned int n)
{
    struct rte_stack_lf_elem *tmp, *first, *last = NULL;
    unsigned int i;
 
    if (unlikely(n == 0))
        return 0;
 
    /* Pop n free elements */
    first = __rte_stack_lf_pop_elems(&s->stack_lf.free, n, NULL, &last);
    if (unlikely(first == NULL))
        return 0;
 
    /* Construct the list elements */
    for (tmp = first, i = 0; i < n; i++, tmp = tmp->next)
        tmp->data = obj_table[n - i - 1];
 
    /* Push them to the used list */
    __rte_stack_lf_push_elems(&s->stack_lf.used, first, last, n);
 
    return n;
}
 
static __rte_always_inline unsigned int
__rte_stack_lf_pop(struct rte_stack *s, void **obj_table, unsigned int n)
{
    struct rte_stack_lf_elem *first, *last = NULL;
 
    if (unlikely(n == 0))
        return 0;
 
    /* Pop n used elements */
    __rte_assume(obj_table != NULL);
    first = __rte_stack_lf_pop_elems(&s->stack_lf.used,
                     n, obj_table, &last);
    if (unlikely(first == NULL))
        return 0;
 
    /* Push the list elements to the free list */
    __rte_stack_lf_push_elems(&s->stack_lf.free, first, last, n);
 
    return n;
}
 
void
rte_stack_lf_init(struct rte_stack *s, unsigned int count);
 
ssize_t
rte_stack_lf_get_memsize(unsigned int count);
 
#endif /* _RTE_STACK_LF_H_ */