net/ice: fix perfect match for ACL rule
[dpdk.git] / app / test / test_stack.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2019 Intel Corporation
3  */
4
5 #include <string.h>
6
7 #include <rte_atomic.h>
8 #include <rte_lcore.h>
9 #include <rte_malloc.h>
10 #include <rte_random.h>
11 #include <rte_stack.h>
12
13 #include "test.h"
14
15 #define STACK_SIZE 4096
16 #define MAX_BULK 32
17
18 static int
19 test_stack_push_pop(struct rte_stack *s, void **obj_table, unsigned int bulk_sz)
20 {
21         unsigned int i, ret;
22         void **popped_objs;
23
24         popped_objs = rte_calloc(NULL, STACK_SIZE, sizeof(void *), 0);
25         if (popped_objs == NULL) {
26                 printf("[%s():%u] failed to calloc %zu bytes\n",
27                        __func__, __LINE__, STACK_SIZE * sizeof(void *));
28                 return -1;
29         }
30
31         for (i = 0; i < STACK_SIZE; i += bulk_sz) {
32                 ret = rte_stack_push(s, &obj_table[i], bulk_sz);
33
34                 if (ret != bulk_sz) {
35                         printf("[%s():%u] push returned: %d (expected %u)\n",
36                                __func__, __LINE__, ret, bulk_sz);
37                         rte_free(popped_objs);
38                         return -1;
39                 }
40
41                 if (rte_stack_count(s) != i + bulk_sz) {
42                         printf("[%s():%u] stack count: %u (expected %u)\n",
43                                __func__, __LINE__, rte_stack_count(s),
44                                i + bulk_sz);
45                         rte_free(popped_objs);
46                         return -1;
47                 }
48
49                 if (rte_stack_free_count(s) != STACK_SIZE - i - bulk_sz) {
50                         printf("[%s():%u] stack free count: %u (expected %u)\n",
51                                __func__, __LINE__, rte_stack_count(s),
52                                STACK_SIZE - i - bulk_sz);
53                         rte_free(popped_objs);
54                         return -1;
55                 }
56         }
57
58         for (i = 0; i < STACK_SIZE; i += bulk_sz) {
59                 ret = rte_stack_pop(s, &popped_objs[i], bulk_sz);
60
61                 if (ret != bulk_sz) {
62                         printf("[%s():%u] pop returned: %d (expected %u)\n",
63                                __func__, __LINE__, ret, bulk_sz);
64                         rte_free(popped_objs);
65                         return -1;
66                 }
67
68                 if (rte_stack_count(s) != STACK_SIZE - i - bulk_sz) {
69                         printf("[%s():%u] stack count: %u (expected %u)\n",
70                                __func__, __LINE__, rte_stack_count(s),
71                                STACK_SIZE - i - bulk_sz);
72                         rte_free(popped_objs);
73                         return -1;
74                 }
75
76                 if (rte_stack_free_count(s) != i + bulk_sz) {
77                         printf("[%s():%u] stack free count: %u (expected %u)\n",
78                                __func__, __LINE__, rte_stack_count(s),
79                                i + bulk_sz);
80                         rte_free(popped_objs);
81                         return -1;
82                 }
83         }
84
85         for (i = 0; i < STACK_SIZE; i++) {
86                 if (obj_table[i] != popped_objs[STACK_SIZE - i - 1]) {
87                         printf("[%s():%u] Incorrect value %p at index 0x%x\n",
88                                __func__, __LINE__,
89                                popped_objs[STACK_SIZE - i - 1], i);
90                         rte_free(popped_objs);
91                         return -1;
92                 }
93         }
94
95         rte_free(popped_objs);
96
97         return 0;
98 }
99
100 static int
101 test_stack_basic(uint32_t flags)
102 {
103         struct rte_stack *s = NULL;
104         void **obj_table = NULL;
105         int i, ret = -1;
106
107         obj_table = rte_calloc(NULL, STACK_SIZE, sizeof(void *), 0);
108         if (obj_table == NULL) {
109                 printf("[%s():%u] failed to calloc %zu bytes\n",
110                        __func__, __LINE__, STACK_SIZE * sizeof(void *));
111                 goto fail_test;
112         }
113
114         for (i = 0; i < STACK_SIZE; i++)
115                 obj_table[i] = (void *)(uintptr_t)i;
116
117         s = rte_stack_create(__func__, STACK_SIZE, rte_socket_id(), flags);
118         if (s == NULL) {
119                 printf("[%s():%u] failed to create a stack\n",
120                        __func__, __LINE__);
121                 goto fail_test;
122         }
123
124         if (rte_stack_lookup(__func__) != s) {
125                 printf("[%s():%u] failed to lookup a stack\n",
126                        __func__, __LINE__);
127                 goto fail_test;
128         }
129
130         if (rte_stack_count(s) != 0) {
131                 printf("[%s():%u] stack count: %u (expected 0)\n",
132                        __func__, __LINE__, rte_stack_count(s));
133                 goto fail_test;
134         }
135
136         if (rte_stack_free_count(s) != STACK_SIZE) {
137                 printf("[%s():%u] stack free count: %u (expected %u)\n",
138                        __func__, __LINE__, rte_stack_count(s), STACK_SIZE);
139                 goto fail_test;
140         }
141
142         ret = test_stack_push_pop(s, obj_table, 1);
143         if (ret) {
144                 printf("[%s():%u] Single object push/pop failed\n",
145                        __func__, __LINE__);
146                 goto fail_test;
147         }
148
149         ret = test_stack_push_pop(s, obj_table, MAX_BULK);
150         if (ret) {
151                 printf("[%s():%u] Bulk object push/pop failed\n",
152                        __func__, __LINE__);
153                 goto fail_test;
154         }
155
156         ret = rte_stack_push(s, obj_table, 2 * STACK_SIZE);
157         if (ret != 0) {
158                 printf("[%s():%u] Excess objects push succeeded\n",
159                        __func__, __LINE__);
160                 goto fail_test;
161         }
162
163         ret = rte_stack_pop(s, obj_table, 1);
164         if (ret != 0) {
165                 printf("[%s():%u] Empty stack pop succeeded\n",
166                        __func__, __LINE__);
167                 goto fail_test;
168         }
169
170         ret = 0;
171
172 fail_test:
173         rte_stack_free(s);
174
175         rte_free(obj_table);
176
177         return ret;
178 }
179
180 static int
181 test_stack_name_reuse(uint32_t flags)
182 {
183         struct rte_stack *s[2];
184
185         s[0] = rte_stack_create("test", STACK_SIZE, rte_socket_id(), flags);
186         if (s[0] == NULL) {
187                 printf("[%s():%u] Failed to create a stack\n",
188                        __func__, __LINE__);
189                 return -1;
190         }
191
192         s[1] = rte_stack_create("test", STACK_SIZE, rte_socket_id(), flags);
193         if (s[1] != NULL) {
194                 printf("[%s():%u] Failed to detect re-used name\n",
195                        __func__, __LINE__);
196                 return -1;
197         }
198
199         rte_stack_free(s[0]);
200
201         return 0;
202 }
203
204 static int
205 test_stack_name_length(uint32_t flags)
206 {
207         char name[RTE_STACK_NAMESIZE + 1];
208         struct rte_stack *s;
209
210         memset(name, 's', sizeof(name));
211         name[RTE_STACK_NAMESIZE] = '\0';
212
213         s = rte_stack_create(name, STACK_SIZE, rte_socket_id(), flags);
214         if (s != NULL) {
215                 printf("[%s():%u] Failed to prevent long name\n",
216                        __func__, __LINE__);
217                 return -1;
218         }
219
220         if (rte_errno != ENAMETOOLONG) {
221                 printf("[%s():%u] rte_stack failed to set correct errno on failed lookup\n",
222                        __func__, __LINE__);
223                 return -1;
224         }
225
226         return 0;
227 }
228
229 static int
230 test_lookup_null(void)
231 {
232         struct rte_stack *s = rte_stack_lookup("stack_not_found");
233
234         if (s != NULL) {
235                 printf("[%s():%u] rte_stack found a non-existent stack\n",
236                        __func__, __LINE__);
237                 return -1;
238         }
239
240         if (rte_errno != ENOENT) {
241                 printf("[%s():%u] rte_stack failed to set correct errno on failed lookup\n",
242                        __func__, __LINE__);
243                 return -1;
244         }
245
246         s = rte_stack_lookup(NULL);
247
248         if (s != NULL) {
249                 printf("[%s():%u] rte_stack found a non-existent stack\n",
250                        __func__, __LINE__);
251                 return -1;
252         }
253
254         if (rte_errno != EINVAL) {
255                 printf("[%s():%u] rte_stack failed to set correct errno on failed lookup\n",
256                        __func__, __LINE__);
257                 return -1;
258         }
259
260         return 0;
261 }
262
263 static int
264 test_free_null(void)
265 {
266         /* Check whether the library proper handles a NULL pointer */
267         rte_stack_free(NULL);
268
269         return 0;
270 }
271
272 #define NUM_ITERS_PER_THREAD 100000
273
274 struct test_args {
275         struct rte_stack *s;
276 };
277
278 static struct test_args thread_test_args;
279
280 static int
281 stack_thread_push_pop(__rte_unused void *args)
282 {
283         void *obj_table[MAX_BULK];
284         int i;
285
286         for (i = 0; i < NUM_ITERS_PER_THREAD; i++) {
287                 unsigned int num;
288
289                 num = rte_rand() % MAX_BULK;
290
291                 if (rte_stack_push(thread_test_args.s, obj_table, num) != num) {
292                         printf("[%s():%u] Failed to push %u pointers\n",
293                                __func__, __LINE__, num);
294                         return -1;
295                 }
296
297                 if (rte_stack_pop(thread_test_args.s, obj_table, num) != num) {
298                         printf("[%s():%u] Failed to pop %u pointers\n",
299                                __func__, __LINE__, num);
300                         return -1;
301                 }
302         }
303
304         return 0;
305 }
306
307 static int
308 test_stack_multithreaded(uint32_t flags)
309 {
310         unsigned int lcore_id;
311         struct rte_stack *s;
312         int result = 0;
313
314         if (rte_lcore_count() < 2) {
315                 printf("Not enough cores for test_stack_multithreaded, expecting at least 2\n");
316                 return TEST_SKIPPED;
317         }
318
319         printf("[%s():%u] Running with %u lcores\n",
320                __func__, __LINE__, rte_lcore_count());
321
322         s = rte_stack_create("test", MAX_BULK * rte_lcore_count(), rte_socket_id(), flags);
323         if (s == NULL) {
324                 printf("[%s():%u] Failed to create a stack\n",
325                        __func__, __LINE__);
326                 return -1;
327         }
328
329         thread_test_args.s = s;
330
331         if (rte_eal_mp_remote_launch(stack_thread_push_pop, NULL, CALL_MAIN))
332                 rte_panic("Failed to launch tests\n");
333
334         RTE_LCORE_FOREACH(lcore_id) {
335                 if (rte_eal_wait_lcore(lcore_id) < 0)
336                         result = -1;
337         }
338
339         rte_stack_free(s);
340         return result;
341 }
342
343 static int
344 __test_stack(uint32_t flags)
345 {
346         if (test_stack_basic(flags) < 0)
347                 return -1;
348
349         if (test_lookup_null() < 0)
350                 return -1;
351
352         if (test_free_null() < 0)
353                 return -1;
354
355         if (test_stack_name_reuse(flags) < 0)
356                 return -1;
357
358         if (test_stack_name_length(flags) < 0)
359                 return -1;
360
361         if (test_stack_multithreaded(flags) < 0)
362                 return -1;
363
364         return 0;
365 }
366
367 static int
368 test_stack(void)
369 {
370         return __test_stack(0);
371 }
372
373 static int
374 test_lf_stack(void)
375 {
376         return __test_stack(RTE_STACK_F_LF);
377 }
378
379 REGISTER_TEST_COMMAND(stack_autotest, test_stack);
380 REGISTER_TEST_COMMAND(stack_lf_autotest, test_lf_stack);