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