net/bnxt: fix mark id update to mbuf
[dpdk.git] / 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_ */