bpf: allow self-xor operation
[dpdk.git] / app / test / test_func_reentrancy.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #include <string.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <stdint.h>
9 #include <inttypes.h>
10 #include <stdarg.h>
11 #include <errno.h>
12 #include <sys/queue.h>
13
14 #include <rte_common.h>
15 #include <rte_log.h>
16 #include <rte_debug.h>
17 #include <rte_memory.h>
18 #include <rte_launch.h>
19 #include <rte_cycles.h>
20 #include <rte_eal.h>
21 #include <rte_per_lcore.h>
22 #include <rte_lcore.h>
23 #include <rte_atomic.h>
24 #include <rte_branch_prediction.h>
25 #include <rte_ring.h>
26 #include <rte_mempool.h>
27 #include <rte_spinlock.h>
28 #include <rte_malloc.h>
29
30 #ifdef RTE_LIB_HASH
31 #include <rte_hash.h>
32 #include <rte_fbk_hash.h>
33 #include <rte_jhash.h>
34 #endif /* RTE_LIB_HASH */
35
36 #ifdef RTE_LIB_LPM
37 #include <rte_lpm.h>
38 #endif /* RTE_LIB_LPM */
39
40 #include <rte_string_fns.h>
41
42 #include "test.h"
43
44 typedef int (*case_func_t)(void* arg);
45 typedef void (*case_clean_t)(unsigned lcore_id);
46
47 #define MAX_STRING_SIZE                     (256)
48 #define MAX_ITER_MULTI                      (16)
49 #define MAX_ITER_ONCE                       (4)
50 #define MAX_LPM_ITER_TIMES                  (6)
51
52 #define MEMPOOL_ELT_SIZE                    (sizeof(uint32_t))
53 #define MEMPOOL_SIZE                        (4)
54
55 #define MAX_LCORES      (RTE_MAX_MEMZONE / (MAX_ITER_MULTI * 4U))
56
57 static rte_atomic32_t obj_count = RTE_ATOMIC32_INIT(0);
58 static rte_atomic32_t synchro = RTE_ATOMIC32_INIT(0);
59
60 #define WAIT_SYNCHRO_FOR_WORKERS()   do { \
61         if (lcore_self != rte_get_main_lcore())                  \
62                 while (rte_atomic32_read(&synchro) == 0);        \
63 } while(0)
64
65 /*
66  * rte_eal_init only init once
67  */
68 static int
69 test_eal_init_once(__rte_unused void *arg)
70 {
71         unsigned lcore_self =  rte_lcore_id();
72
73         WAIT_SYNCHRO_FOR_WORKERS();
74
75         rte_atomic32_set(&obj_count, 1); /* silent the check in the caller */
76         if (rte_eal_init(0, NULL) != -1)
77                 return -1;
78
79         return 0;
80 }
81
82 /*
83  * ring create/lookup reentrancy test
84  */
85 static void
86 ring_clean(unsigned int lcore_id)
87 {
88         struct rte_ring *rp;
89         char ring_name[MAX_STRING_SIZE];
90         int i;
91
92         rp = rte_ring_lookup("fr_test_once");
93         if (rp != NULL)
94                 rte_ring_free(rp);
95
96         for (i = 0; i < MAX_ITER_MULTI; i++) {
97                 snprintf(ring_name, sizeof(ring_name),
98                                 "fr_test_%d_%d", lcore_id, i);
99                 rp = rte_ring_lookup(ring_name);
100                 if (rp != NULL)
101                         rte_ring_free(rp);
102         }
103 }
104
105 static int
106 ring_create_lookup(__rte_unused void *arg)
107 {
108         unsigned lcore_self = rte_lcore_id();
109         struct rte_ring * rp;
110         char ring_name[MAX_STRING_SIZE];
111         int i;
112
113         WAIT_SYNCHRO_FOR_WORKERS();
114
115         /* create the same ring simultaneously on all threads */
116         for (i = 0; i < MAX_ITER_ONCE; i++) {
117                 rp = rte_ring_create("fr_test_once", 4096, SOCKET_ID_ANY, 0);
118                 if (rp != NULL)
119                         rte_atomic32_inc(&obj_count);
120         }
121
122         /* create/lookup new ring several times */
123         for (i = 0; i < MAX_ITER_MULTI; i++) {
124                 snprintf(ring_name, sizeof(ring_name), "fr_test_%d_%d", lcore_self, i);
125                 rp = rte_ring_create(ring_name, 4096, SOCKET_ID_ANY, 0);
126                 if (NULL == rp)
127                         return -1;
128                 if (rte_ring_lookup(ring_name) != rp)
129                         return -1;
130
131                 /* verify all ring created successful */
132                 if (rte_ring_lookup(ring_name) == NULL)
133                         return -1;
134         }
135
136         return 0;
137 }
138
139 static void
140 my_obj_init(struct rte_mempool *mp, __rte_unused void *arg,
141             void *obj, unsigned i)
142 {
143         uint32_t *objnum = obj;
144         memset(obj, 0, mp->elt_size);
145         *objnum = i;
146 }
147
148 static void
149 mempool_clean(unsigned int lcore_id)
150 {
151         struct rte_mempool *mp;
152         char mempool_name[MAX_STRING_SIZE];
153         int i;
154
155         mp = rte_mempool_lookup("fr_test_once");
156         if (mp != NULL)
157                 rte_mempool_free(mp);
158
159         for (i = 0; i < MAX_ITER_MULTI; i++) {
160                 snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d",
161                          lcore_id, i);
162                 mp = rte_mempool_lookup(mempool_name);
163                 if (mp != NULL)
164                         rte_mempool_free(mp);
165         }
166 }
167
168 static int
169 mempool_create_lookup(__rte_unused void *arg)
170 {
171         unsigned lcore_self = rte_lcore_id();
172         struct rte_mempool * mp;
173         char mempool_name[MAX_STRING_SIZE];
174         int i;
175
176         WAIT_SYNCHRO_FOR_WORKERS();
177
178         /* create the same mempool simultaneously on all threads */
179         for (i = 0; i < MAX_ITER_ONCE; i++) {
180                 mp = rte_mempool_create("fr_test_once",  MEMPOOL_SIZE,
181                                         MEMPOOL_ELT_SIZE, 0, 0,
182                                         NULL, NULL,
183                                         my_obj_init, NULL,
184                                         SOCKET_ID_ANY, 0);
185                 if (mp != NULL)
186                         rte_atomic32_inc(&obj_count);
187         }
188
189         /* create/lookup new ring several times */
190         for (i = 0; i < MAX_ITER_MULTI; i++) {
191                 snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d", lcore_self, i);
192                 mp = rte_mempool_create(mempool_name, MEMPOOL_SIZE,
193                                                 MEMPOOL_ELT_SIZE, 0, 0,
194                                                 NULL, NULL,
195                                                 my_obj_init, NULL,
196                                                 SOCKET_ID_ANY, 0);
197                 if (NULL == mp)
198                         return -1;
199                 if (rte_mempool_lookup(mempool_name) != mp)
200                         return -1;
201
202                 /* verify all ring created successful */
203                 if (rte_mempool_lookup(mempool_name) == NULL)
204                         return -1;
205         }
206
207         return 0;
208 }
209
210 #ifdef RTE_LIB_HASH
211 static void
212 hash_clean(unsigned lcore_id)
213 {
214         char hash_name[MAX_STRING_SIZE];
215         struct rte_hash *handle;
216         int i;
217
218         handle = rte_hash_find_existing("fr_test_once");
219         if (handle != NULL)
220                 rte_hash_free(handle);
221
222         for (i = 0; i < MAX_ITER_MULTI; i++) {
223                 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d",  lcore_id, i);
224
225                 if ((handle = rte_hash_find_existing(hash_name)) != NULL)
226                         rte_hash_free(handle);
227         }
228 }
229
230 static int
231 hash_create_free(__rte_unused void *arg)
232 {
233         unsigned lcore_self = rte_lcore_id();
234         struct rte_hash *handle;
235         char hash_name[MAX_STRING_SIZE];
236         int i;
237         struct rte_hash_parameters hash_params = {
238                 .name = NULL,
239                 .entries = 16,
240                 .key_len = 4,
241                 .hash_func = (rte_hash_function)rte_jhash_32b,
242                 .hash_func_init_val = 0,
243                 .socket_id = 0,
244         };
245
246         WAIT_SYNCHRO_FOR_WORKERS();
247
248         /* create the same hash simultaneously on all threads */
249         hash_params.name = "fr_test_once";
250         for (i = 0; i < MAX_ITER_ONCE; i++) {
251                 handle = rte_hash_create(&hash_params);
252                 if (handle != NULL)
253                         rte_atomic32_inc(&obj_count);
254         }
255
256         /* create mutiple times simultaneously */
257         for (i = 0; i < MAX_ITER_MULTI; i++) {
258                 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_self, i);
259                 hash_params.name = hash_name;
260
261                 handle = rte_hash_create(&hash_params);
262                 if (NULL == handle)
263                         return -1;
264
265                 /* verify correct existing and then free all */
266                 if (handle != rte_hash_find_existing(hash_name))
267                         return -1;
268
269                 rte_hash_free(handle);
270
271                 /* verify free correct */
272                 if (NULL != rte_hash_find_existing(hash_name))
273                         return -1;
274         }
275
276         return 0;
277 }
278
279 static void
280 fbk_clean(unsigned lcore_id)
281 {
282         char fbk_name[MAX_STRING_SIZE];
283         struct rte_fbk_hash_table *handle;
284         int i;
285
286         handle = rte_fbk_hash_find_existing("fr_test_once");
287         if (handle != NULL)
288                 rte_fbk_hash_free(handle);
289
290         for (i = 0; i < MAX_ITER_MULTI; i++) {
291                 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d",  lcore_id, i);
292
293                 if ((handle = rte_fbk_hash_find_existing(fbk_name)) != NULL)
294                         rte_fbk_hash_free(handle);
295         }
296 }
297
298 static int
299 fbk_create_free(__rte_unused void *arg)
300 {
301         unsigned lcore_self = rte_lcore_id();
302         struct rte_fbk_hash_table *handle;
303         char fbk_name[MAX_STRING_SIZE];
304         int i;
305         struct rte_fbk_hash_params fbk_params = {
306                 .name = NULL,
307                 .entries = 4,
308                 .entries_per_bucket = 4,
309                 .socket_id = 0,
310                 .hash_func = rte_jhash_1word,
311                 .init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT,
312         };
313
314         WAIT_SYNCHRO_FOR_WORKERS();
315
316         /* create the same fbk hash table simultaneously on all threads */
317         fbk_params.name = "fr_test_once";
318         for (i = 0; i < MAX_ITER_ONCE; i++) {
319                 handle = rte_fbk_hash_create(&fbk_params);
320                 if (handle != NULL)
321                         rte_atomic32_inc(&obj_count);
322         }
323
324         /* create mutiple fbk tables simultaneously */
325         for (i = 0; i < MAX_ITER_MULTI; i++) {
326                 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d", lcore_self, i);
327                 fbk_params.name = fbk_name;
328
329                 handle = rte_fbk_hash_create(&fbk_params);
330                 if (NULL == handle)
331                         return -1;
332
333                 /* verify correct existing and then free all */
334                 if (handle != rte_fbk_hash_find_existing(fbk_name))
335                         return -1;
336
337                 rte_fbk_hash_free(handle);
338
339                 /* verify free correct */
340                 if (NULL != rte_fbk_hash_find_existing(fbk_name))
341                         return -1;
342         }
343
344         return 0;
345 }
346 #endif /* RTE_LIB_HASH */
347
348 #ifdef RTE_LIB_LPM
349 static void
350 lpm_clean(unsigned int lcore_id)
351 {
352         char lpm_name[MAX_STRING_SIZE];
353         struct rte_lpm *lpm;
354         int i;
355
356         lpm = rte_lpm_find_existing("fr_test_once");
357         if (lpm != NULL)
358                 rte_lpm_free(lpm);
359
360         for (i = 0; i < MAX_LPM_ITER_TIMES; i++) {
361                 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d",  lcore_id, i);
362
363                 if ((lpm = rte_lpm_find_existing(lpm_name)) != NULL)
364                         rte_lpm_free(lpm);
365         }
366 }
367
368 static int
369 lpm_create_free(__rte_unused void *arg)
370 {
371         unsigned lcore_self = rte_lcore_id();
372         struct rte_lpm *lpm;
373         struct rte_lpm_config config;
374
375         config.max_rules = 4;
376         config.number_tbl8s = 256;
377         config.flags = 0;
378         char lpm_name[MAX_STRING_SIZE];
379         int i;
380
381         WAIT_SYNCHRO_FOR_WORKERS();
382
383         /* create the same lpm simultaneously on all threads */
384         for (i = 0; i < MAX_ITER_ONCE; i++) {
385                 lpm = rte_lpm_create("fr_test_once",  SOCKET_ID_ANY, &config);
386                 if (lpm != NULL)
387                         rte_atomic32_inc(&obj_count);
388         }
389
390         /* create mutiple fbk tables simultaneously */
391         for (i = 0; i < MAX_LPM_ITER_TIMES; i++) {
392                 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d", lcore_self, i);
393                 lpm = rte_lpm_create(lpm_name, SOCKET_ID_ANY, &config);
394                 if (NULL == lpm)
395                         return -1;
396
397                 /* verify correct existing and then free all */
398                 if (lpm != rte_lpm_find_existing(lpm_name))
399                         return -1;
400
401                 rte_lpm_free(lpm);
402
403                 /* verify free correct */
404                 if (NULL != rte_lpm_find_existing(lpm_name))
405                         return -1;
406         }
407
408         return 0;
409 }
410 #endif /* RTE_LIB_LPM */
411
412 struct test_case{
413         case_func_t    func;
414         void*          arg;
415         case_clean_t   clean;
416         char           name[MAX_STRING_SIZE];
417 };
418
419 /* All test cases in the test suite */
420 struct test_case test_cases[] = {
421         { test_eal_init_once,     NULL,  NULL,         "eal init once" },
422         { ring_create_lookup,     NULL,  ring_clean,   "ring create/lookup" },
423         { mempool_create_lookup,  NULL,  mempool_clean,
424                         "mempool create/lookup" },
425 #ifdef RTE_LIB_HASH
426         { hash_create_free,       NULL,  hash_clean,   "hash create/free" },
427         { fbk_create_free,        NULL,  fbk_clean,    "fbk create/free" },
428 #endif /* RTE_LIB_HASH */
429 #ifdef RTE_LIB_LPM
430         { lpm_create_free,        NULL,  lpm_clean,    "lpm create/free" },
431 #endif /* RTE_LIB_LPM */
432 };
433
434 /**
435  * launch test case in two separate thread
436  */
437 static int
438 launch_test(struct test_case *pt_case)
439 {
440         unsigned int lcore_id;
441         unsigned int cores;
442         unsigned int count;
443         int ret = 0;
444
445         if (pt_case->func == NULL)
446                 return -1;
447
448         rte_atomic32_set(&obj_count, 0);
449         rte_atomic32_set(&synchro, 0);
450
451         cores = RTE_MIN(rte_lcore_count(), MAX_LCORES);
452         RTE_LCORE_FOREACH_WORKER(lcore_id) {
453                 if (cores == 1)
454                         break;
455                 cores--;
456                 rte_eal_remote_launch(pt_case->func, pt_case->arg, lcore_id);
457         }
458
459         rte_atomic32_set(&synchro, 1);
460
461         if (pt_case->func(pt_case->arg) < 0)
462                 ret = -1;
463
464         RTE_LCORE_FOREACH_WORKER(lcore_id) {
465                 if (rte_eal_wait_lcore(lcore_id) < 0)
466                         ret = -1;
467         }
468
469         RTE_LCORE_FOREACH(lcore_id) {
470                 if (pt_case->clean != NULL)
471                         pt_case->clean(lcore_id);
472         }
473
474         count = rte_atomic32_read(&obj_count);
475         if (count != 1) {
476                 printf("%s: common object allocated %d times (should be 1)\n",
477                         pt_case->name, count);
478                 ret = -1;
479         }
480
481         return ret;
482 }
483
484 /**
485  * Main entry of func_reentrancy test
486  */
487 static int
488 test_func_reentrancy(void)
489 {
490         uint32_t case_id;
491         struct test_case *pt_case = NULL;
492
493         if (rte_lcore_count() < 2) {
494                 printf("Not enough cores for func_reentrancy_autotest, expecting at least 2\n");
495                 return TEST_SKIPPED;
496         }
497         else if (rte_lcore_count() > MAX_LCORES)
498                 printf("Too many lcores, some cores will be disabled\n");
499
500         for (case_id = 0; case_id < RTE_DIM(test_cases); case_id++) {
501                 pt_case = &test_cases[case_id];
502                 if (pt_case->func == NULL)
503                         continue;
504
505                 if (launch_test(pt_case) < 0) {
506                         printf("Func-ReEnt CASE %"PRIu32": %s FAIL\n", case_id, pt_case->name);
507                         return -1;
508                 }
509                 printf("Func-ReEnt CASE %"PRIu32": %s PASS\n", case_id, pt_case->name);
510         }
511
512         return 0;
513 }
514
515 REGISTER_TEST_COMMAND(func_reentrancy_autotest, test_func_reentrancy);