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
|
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2016 Intel Corporation
*/
#include <stdio.h>
#include <rte_mempool.h>
#include <rte_malloc.h>
struct rte_mempool_stack {
rte_spinlock_t sl;
uint32_t size;
uint32_t len;
void *objs[];
};
static int
stack_alloc(struct rte_mempool *mp)
{
struct rte_mempool_stack *s;
unsigned n = mp->size;
int size = sizeof(*s) + (n+16)*sizeof(void *);
/* Allocate our local memory structure */
s = rte_zmalloc_socket("mempool-stack",
size,
RTE_CACHE_LINE_SIZE,
mp->socket_id);
if (s == NULL) {
RTE_LOG(ERR, MEMPOOL, "Cannot allocate stack!\n");
return -ENOMEM;
}
rte_spinlock_init(&s->sl);
s->size = n;
mp->pool_data = s;
return 0;
}
static int
stack_enqueue(struct rte_mempool *mp, void * const *obj_table,
unsigned n)
{
struct rte_mempool_stack *s = mp->pool_data;
void **cache_objs;
unsigned index;
rte_spinlock_lock(&s->sl);
cache_objs = &s->objs[s->len];
/* Is there sufficient space in the stack ? */
if ((s->len + n) > s->size) {
rte_spinlock_unlock(&s->sl);
return -ENOBUFS;
}
/* Add elements back into the cache */
for (index = 0; index < n; ++index, obj_table++)
cache_objs[index] = *obj_table;
s->len += n;
rte_spinlock_unlock(&s->sl);
return 0;
}
static int
stack_dequeue(struct rte_mempool *mp, void **obj_table,
unsigned n)
{
struct rte_mempool_stack *s = mp->pool_data;
void **cache_objs;
unsigned index, len;
rte_spinlock_lock(&s->sl);
if (unlikely(n > s->len)) {
rte_spinlock_unlock(&s->sl);
return -ENOENT;
}
cache_objs = s->objs;
for (index = 0, len = s->len - 1; index < n;
++index, len--, obj_table++)
*obj_table = cache_objs[len];
s->len -= n;
rte_spinlock_unlock(&s->sl);
return 0;
}
static unsigned
stack_get_count(const struct rte_mempool *mp)
{
struct rte_mempool_stack *s = mp->pool_data;
return s->len;
}
static void
stack_free(struct rte_mempool *mp)
{
rte_free((void *)(mp->pool_data));
}
static struct rte_mempool_ops ops_stack = {
.name = "stack",
.alloc = stack_alloc,
.free = stack_free,
.enqueue = stack_enqueue,
.dequeue = stack_dequeue,
.get_count = stack_get_count
};
MEMPOOL_REGISTER_OPS(ops_stack);
|
