lib/librte_stack/rte_stack_std.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #ifndef _RTE_STACK_STD_H_
   6 #define _RTE_STACK_STD_H_
   7
   8 #include <rte_branch_prediction.h>
   9
  10 /**
  11  * @internal Push several objects on the stack (MT-safe).
  12  *
  13  * @param s
  14  *   A pointer to the stack structure.
  15  * @param obj_table
  16  *   A pointer to a table of void * pointers (objects).
  17  * @param n
  18  *   The number of objects to push on the stack from the obj_table.
  19  * @return
  20  *   Actual number of objects pushed (either 0 or *n*).
  21  */
  22 __rte_experimental
  23 static __rte_always_inline unsigned int
  24 __rte_stack_std_push(struct rte_stack *s, void * const *obj_table,
  25                      unsigned int n)
  26 {
  27         struct rte_stack_std *stack = &s->stack_std;
  28         unsigned int index;
  29         void **cache_objs;
  30
  31         rte_spinlock_lock(&stack->lock);
  32         cache_objs = &stack->objs[stack->len];
  33
  34         /* Is there sufficient space in the stack? */
  35         if ((stack->len + n) > s->capacity) {
  36                 rte_spinlock_unlock(&stack->lock);
  37                 return 0;
  38         }
  39
  40         /* Add elements back into the cache */
  41         for (index = 0; index < n; ++index, obj_table++)
  42                 cache_objs[index] = *obj_table;
  43
  44         stack->len += n;
  45
  46         rte_spinlock_unlock(&stack->lock);
  47         return n;
  48 }
  49
  50 /**
  51  * @internal Pop several objects from the stack (MT-safe).
  52  *
  53  * @param s
  54  *   A pointer to the stack structure.
  55  * @param obj_table
  56  *   A pointer to a table of void * pointers (objects).
  57  * @param n
  58  *   The number of objects to pull from the stack.
  59  * @return
  60  *   Actual number of objects popped (either 0 or *n*).
  61  */
  62 __rte_experimental
  63 static __rte_always_inline unsigned int
  64 __rte_stack_std_pop(struct rte_stack *s, void **obj_table, unsigned int n)
  65 {
  66         struct rte_stack_std *stack = &s->stack_std;
  67         unsigned int index, len;
  68         void **cache_objs;
  69
  70         rte_spinlock_lock(&stack->lock);
  71
  72         if (unlikely(n > stack->len)) {
  73                 rte_spinlock_unlock(&stack->lock);
  74                 return 0;
  75         }
  76
  77         cache_objs = stack->objs;
  78
  79         for (index = 0, len = stack->len - 1; index < n;
  80                         ++index, len--, obj_table++)
  81                 *obj_table = cache_objs[len];
  82
  83         stack->len -= n;
  84         rte_spinlock_unlock(&stack->lock);
  85
  86         return n;
  87 }
  88
  89 /**
  90  * @internal Return the number of used entries in a stack.
  91  *
  92  * @param s
  93  *   A pointer to the stack structure.
  94  * @return
  95  *   The number of used entries in the stack.
  96  */
  97 __rte_experimental
  98 static __rte_always_inline unsigned int
  99 __rte_stack_std_count(struct rte_stack *s)
 100 {
 101         return (unsigned int)s->stack_std.len;
 102 }
 103
 104 /**
 105  * @internal Initialize a standard stack.
 106  *
 107  * @param s
 108  *   A pointer to the stack structure.
 109  */
 110 void
 111 rte_stack_std_init(struct rte_stack *s);
 112
 113 /**
 114  * @internal Return the memory required for a standard stack.
 115  *
 116  * @param count
 117  *   The size of the stack.
 118  * @return
 119  *   The bytes to allocate for a standard stack.
 120  */
 121 ssize_t
 122 rte_stack_std_get_memsize(unsigned int count);
 123
 124 #endif /* _RTE_STACK_STD_H_ */