1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
12 #include <sys/queue.h>
14 #include <rte_common.h>
16 #include <rte_debug.h>
17 #include <rte_memory.h>
18 #include <rte_launch.h>
19 #include <rte_cycles.h>
21 #include <rte_per_lcore.h>
22 #include <rte_lcore.h>
23 #include <rte_atomic.h>
24 #include <rte_branch_prediction.h>
26 #include <rte_mempool.h>
27 #include <rte_spinlock.h>
28 #include <rte_malloc.h>
30 #ifdef RTE_LIBRTE_HASH
32 #include <rte_fbk_hash.h>
33 #include <rte_jhash.h>
34 #endif /* RTE_LIBRTE_HASH */
38 #endif /* RTE_LIBRTE_LPM */
40 #include <rte_string_fns.h>
44 typedef int (*case_func_t
)(void* arg
);
45 typedef void (*case_clean_t
)(unsigned lcore_id
);
47 #define MAX_STRING_SIZE (256)
48 #define MAX_ITER_TIMES (16)
49 #define MAX_LPM_ITER_TIMES (8)
51 #define MEMPOOL_ELT_SIZE (sizeof(uint32_t))
52 #define MEMPOOL_SIZE (4)
54 #define MAX_LCORES RTE_MAX_MEMZONE / (MAX_ITER_TIMES * 4U)
56 static rte_atomic32_t obj_count
= RTE_ATOMIC32_INIT(0);
57 static rte_atomic32_t synchro
= RTE_ATOMIC32_INIT(0);
59 #define WAIT_SYNCHRO_FOR_SLAVES() do{ \
60 if (lcore_self != rte_get_master_lcore()) \
61 while (rte_atomic32_read(&synchro) == 0); \
65 * rte_eal_init only init once
68 test_eal_init_once(__attribute__((unused
)) void *arg
)
70 unsigned lcore_self
= rte_lcore_id();
72 WAIT_SYNCHRO_FOR_SLAVES();
74 rte_atomic32_set(&obj_count
, 1); /* silent the check in the caller */
75 if (rte_eal_init(0, NULL
) != -1)
82 * ring create/lookup reentrancy test
85 ring_clean(unsigned int lcore_id
)
88 char ring_name
[MAX_STRING_SIZE
];
91 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
92 snprintf(ring_name
, sizeof(ring_name
),
93 "fr_test_%d_%d", lcore_id
, i
);
94 rp
= rte_ring_lookup(ring_name
);
101 ring_create_lookup(__attribute__((unused
)) void *arg
)
103 unsigned lcore_self
= rte_lcore_id();
104 struct rte_ring
* rp
;
105 char ring_name
[MAX_STRING_SIZE
];
108 WAIT_SYNCHRO_FOR_SLAVES();
110 /* create the same ring simultaneously on all threads */
111 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
112 rp
= rte_ring_create("fr_test_once", 4096, SOCKET_ID_ANY
, 0);
114 rte_atomic32_inc(&obj_count
);
117 /* create/lookup new ring several times */
118 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
119 snprintf(ring_name
, sizeof(ring_name
), "fr_test_%d_%d", lcore_self
, i
);
120 rp
= rte_ring_create(ring_name
, 4096, SOCKET_ID_ANY
, 0);
123 if (rte_ring_lookup(ring_name
) != rp
)
127 /* verify all ring created successful */
128 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
129 snprintf(ring_name
, sizeof(ring_name
), "fr_test_%d_%d", lcore_self
, i
);
130 if (rte_ring_lookup(ring_name
) == NULL
)
138 my_obj_init(struct rte_mempool
*mp
, __attribute__((unused
)) void *arg
,
139 void *obj
, unsigned i
)
141 uint32_t *objnum
= obj
;
142 memset(obj
, 0, mp
->elt_size
);
147 mempool_clean(unsigned int lcore_id
)
149 struct rte_mempool
*mp
;
150 char mempool_name
[MAX_STRING_SIZE
];
153 /* verify all ring created successful */
154 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
155 snprintf(mempool_name
, sizeof(mempool_name
), "fr_test_%d_%d",
157 mp
= rte_mempool_lookup(mempool_name
);
159 rte_mempool_free(mp
);
164 mempool_create_lookup(__attribute__((unused
)) void *arg
)
166 unsigned lcore_self
= rte_lcore_id();
167 struct rte_mempool
* mp
;
168 char mempool_name
[MAX_STRING_SIZE
];
171 WAIT_SYNCHRO_FOR_SLAVES();
173 /* create the same mempool simultaneously on all threads */
174 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
175 mp
= rte_mempool_create("fr_test_once", MEMPOOL_SIZE
,
176 MEMPOOL_ELT_SIZE
, 0, 0,
181 rte_atomic32_inc(&obj_count
);
184 /* create/lookup new ring several times */
185 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
186 snprintf(mempool_name
, sizeof(mempool_name
), "fr_test_%d_%d", lcore_self
, i
);
187 mp
= rte_mempool_create(mempool_name
, MEMPOOL_SIZE
,
188 MEMPOOL_ELT_SIZE
, 0, 0,
194 if (rte_mempool_lookup(mempool_name
) != mp
)
198 /* verify all ring created successful */
199 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
200 snprintf(mempool_name
, sizeof(mempool_name
), "fr_test_%d_%d", lcore_self
, i
);
201 if (rte_mempool_lookup(mempool_name
) == NULL
)
208 #ifdef RTE_LIBRTE_HASH
210 hash_clean(unsigned lcore_id
)
212 char hash_name
[MAX_STRING_SIZE
];
213 struct rte_hash
*handle
;
216 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
217 snprintf(hash_name
, sizeof(hash_name
), "fr_test_%d_%d", lcore_id
, i
);
219 if ((handle
= rte_hash_find_existing(hash_name
)) != NULL
)
220 rte_hash_free(handle
);
225 hash_create_free(__attribute__((unused
)) void *arg
)
227 unsigned lcore_self
= rte_lcore_id();
228 struct rte_hash
*handle
;
229 char hash_name
[MAX_STRING_SIZE
];
231 struct rte_hash_parameters hash_params
= {
235 .hash_func
= (rte_hash_function
)rte_jhash_32b
,
236 .hash_func_init_val
= 0,
240 WAIT_SYNCHRO_FOR_SLAVES();
242 /* create the same hash simultaneously on all threads */
243 hash_params
.name
= "fr_test_once";
244 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
245 handle
= rte_hash_create(&hash_params
);
247 rte_atomic32_inc(&obj_count
);
250 /* create mutiple times simultaneously */
251 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
252 snprintf(hash_name
, sizeof(hash_name
), "fr_test_%d_%d", lcore_self
, i
);
253 hash_params
.name
= hash_name
;
255 handle
= rte_hash_create(&hash_params
);
259 /* verify correct existing and then free all */
260 if (handle
!= rte_hash_find_existing(hash_name
))
263 rte_hash_free(handle
);
266 /* verify free correct */
267 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
268 snprintf(hash_name
, sizeof(hash_name
), "fr_test_%d_%d", lcore_self
, i
);
270 if (NULL
!= rte_hash_find_existing(hash_name
))
278 fbk_clean(unsigned lcore_id
)
280 char fbk_name
[MAX_STRING_SIZE
];
281 struct rte_fbk_hash_table
*handle
;
284 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
285 snprintf(fbk_name
, sizeof(fbk_name
), "fr_test_%d_%d", lcore_id
, i
);
287 if ((handle
= rte_fbk_hash_find_existing(fbk_name
)) != NULL
)
288 rte_fbk_hash_free(handle
);
293 fbk_create_free(__attribute__((unused
)) void *arg
)
295 unsigned lcore_self
= rte_lcore_id();
296 struct rte_fbk_hash_table
*handle
;
297 char fbk_name
[MAX_STRING_SIZE
];
299 struct rte_fbk_hash_params fbk_params
= {
302 .entries_per_bucket
= 4,
304 .hash_func
= rte_jhash_1word
,
305 .init_val
= RTE_FBK_HASH_INIT_VAL_DEFAULT
,
308 WAIT_SYNCHRO_FOR_SLAVES();
310 /* create the same fbk hash table simultaneously on all threads */
311 fbk_params
.name
= "fr_test_once";
312 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
313 handle
= rte_fbk_hash_create(&fbk_params
);
315 rte_atomic32_inc(&obj_count
);
318 /* create mutiple fbk tables simultaneously */
319 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
320 snprintf(fbk_name
, sizeof(fbk_name
), "fr_test_%d_%d", lcore_self
, i
);
321 fbk_params
.name
= fbk_name
;
323 handle
= rte_fbk_hash_create(&fbk_params
);
327 /* verify correct existing and then free all */
328 if (handle
!= rte_fbk_hash_find_existing(fbk_name
))
331 rte_fbk_hash_free(handle
);
334 /* verify free correct */
335 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
336 snprintf(fbk_name
, sizeof(fbk_name
), "fr_test_%d_%d", lcore_self
, i
);
338 if (NULL
!= rte_fbk_hash_find_existing(fbk_name
))
344 #endif /* RTE_LIBRTE_HASH */
346 #ifdef RTE_LIBRTE_LPM
348 lpm_clean(unsigned int lcore_id
)
350 char lpm_name
[MAX_STRING_SIZE
];
354 for (i
= 0; i
< MAX_LPM_ITER_TIMES
; i
++) {
355 snprintf(lpm_name
, sizeof(lpm_name
), "fr_test_%d_%d", lcore_id
, i
);
357 if ((lpm
= rte_lpm_find_existing(lpm_name
)) != NULL
)
363 lpm_create_free(__attribute__((unused
)) void *arg
)
365 unsigned lcore_self
= rte_lcore_id();
367 struct rte_lpm_config config
;
369 config
.max_rules
= 4;
370 config
.number_tbl8s
= 256;
372 char lpm_name
[MAX_STRING_SIZE
];
375 WAIT_SYNCHRO_FOR_SLAVES();
377 /* create the same lpm simultaneously on all threads */
378 for (i
= 0; i
< MAX_ITER_TIMES
; i
++) {
379 lpm
= rte_lpm_create("fr_test_once", SOCKET_ID_ANY
, &config
);
381 rte_atomic32_inc(&obj_count
);
384 /* create mutiple fbk tables simultaneously */
385 for (i
= 0; i
< MAX_LPM_ITER_TIMES
; i
++) {
386 snprintf(lpm_name
, sizeof(lpm_name
), "fr_test_%d_%d", lcore_self
, i
);
387 lpm
= rte_lpm_create(lpm_name
, SOCKET_ID_ANY
, &config
);
391 /* verify correct existing and then free all */
392 if (lpm
!= rte_lpm_find_existing(lpm_name
))
398 /* verify free correct */
399 for (i
= 0; i
< MAX_LPM_ITER_TIMES
; i
++) {
400 snprintf(lpm_name
, sizeof(lpm_name
), "fr_test_%d_%d", lcore_self
, i
);
401 if (NULL
!= rte_lpm_find_existing(lpm_name
))
407 #endif /* RTE_LIBRTE_LPM */
413 char name
[MAX_STRING_SIZE
];
416 /* All test cases in the test suite */
417 struct test_case test_cases
[] = {
418 { test_eal_init_once
, NULL
, NULL
, "eal init once" },
419 { ring_create_lookup
, NULL
, ring_clean
, "ring create/lookup" },
420 { mempool_create_lookup
, NULL
, mempool_clean
,
421 "mempool create/lookup" },
422 #ifdef RTE_LIBRTE_HASH
423 { hash_create_free
, NULL
, hash_clean
, "hash create/free" },
424 { fbk_create_free
, NULL
, fbk_clean
, "fbk create/free" },
425 #endif /* RTE_LIBRTE_HASH */
426 #ifdef RTE_LIBRTE_LPM
427 { lpm_create_free
, NULL
, lpm_clean
, "lpm create/free" },
428 #endif /* RTE_LIBRTE_LPM */
432 * launch test case in two separate thread
435 launch_test(struct test_case
*pt_case
)
439 unsigned cores_save
= rte_lcore_count();
440 unsigned cores
= RTE_MIN(cores_save
, MAX_LCORES
);
443 if (pt_case
->func
== NULL
)
446 rte_atomic32_set(&obj_count
, 0);
447 rte_atomic32_set(&synchro
, 0);
449 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
453 rte_eal_remote_launch(pt_case
->func
, pt_case
->arg
, lcore_id
);
456 rte_atomic32_set(&synchro
, 1);
458 if (pt_case
->func(pt_case
->arg
) < 0)
462 RTE_LCORE_FOREACH_SLAVE(lcore_id
) {
466 if (rte_eal_wait_lcore(lcore_id
) < 0)
469 if (pt_case
->clean
!= NULL
)
470 pt_case
->clean(lcore_id
);
473 count
= rte_atomic32_read(&obj_count
);
475 printf("%s: common object allocated %d times (should be 1)\n",
476 pt_case
->name
, count
);
484 * Main entry of func_reentrancy test
487 test_func_reentrancy(void)
490 struct test_case
*pt_case
= NULL
;
492 if (rte_lcore_count() <= 1) {
493 printf("Not enough lcore for testing\n");
496 else if (rte_lcore_count() > MAX_LCORES
)
497 printf("Too many lcores, some cores will be disabled\n");
499 for (case_id
= 0; case_id
< sizeof(test_cases
)/sizeof(struct test_case
); case_id
++) {
500 pt_case
= &test_cases
[case_id
];
501 if (pt_case
->func
== NULL
)
504 if (launch_test(pt_case
) < 0) {
505 printf("Func-ReEnt CASE %"PRIu32
": %s FAIL\n", case_id
, pt_case
->name
);
508 printf("Func-ReEnt CASE %"PRIu32
": %s PASS\n", case_id
, pt_case
->name
);
514 REGISTER_TEST_COMMAND(func_reentrancy_autotest
, test_func_reentrancy
);