4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41 #include <sys/queue.h>
43 #include <rte_common.h>
45 #include <rte_debug.h>
46 #include <rte_memory.h>
47 #include <rte_memzone.h>
48 #include <rte_launch.h>
49 #include <rte_cycles.h>
51 #include <rte_per_lcore.h>
52 #include <rte_lcore.h>
53 #include <rte_atomic.h>
54 #include <rte_branch_prediction.h>
56 #include <rte_mempool.h>
57 #include <rte_spinlock.h>
58 #include <rte_malloc.h>
60 #ifdef RTE_LIBRTE_HASH
62 #include <rte_fbk_hash.h>
63 #include <rte_jhash.h>
64 #endif /* RTE_LIBRTE_HASH */
68 #endif /* RTE_LIBRTE_LPM */
70 #include <rte_string_fns.h>
74 typedef int (*case_func_t)(void* arg);
75 typedef void (*case_clean_t)(unsigned lcore_id);
77 #define MAX_STRING_SIZE (256)
78 #define MAX_ITER_TIMES (16)
79 #define MAX_LPM_ITER_TIMES (8)
81 #define MEMPOOL_ELT_SIZE (sizeof(uint32_t))
82 #define MEMPOOL_SIZE (4)
84 #define MAX_LCORES RTE_MAX_MEMZONE / (MAX_ITER_TIMES * 4U)
86 static rte_atomic32_t obj_count = RTE_ATOMIC32_INIT(0);
87 static rte_atomic32_t synchro = RTE_ATOMIC32_INIT(0);
89 #define WAIT_SYNCHRO_FOR_SLAVES() do{ \
90 if (lcore_self != rte_get_master_lcore()) \
91 while (rte_atomic32_read(&synchro) == 0); \
95 * rte_eal_init only init once
98 test_eal_init_once(__attribute__((unused)) void *arg)
100 unsigned lcore_self = rte_lcore_id();
102 WAIT_SYNCHRO_FOR_SLAVES();
104 rte_atomic32_set(&obj_count, 1); /* silent the check in the caller */
105 if (rte_eal_init(0, NULL) != -1)
112 * ring create/lookup reentrancy test
115 ring_create_lookup(__attribute__((unused)) void *arg)
117 unsigned lcore_self = rte_lcore_id();
118 struct rte_ring * rp;
119 char ring_name[MAX_STRING_SIZE];
122 WAIT_SYNCHRO_FOR_SLAVES();
124 /* create the same ring simultaneously on all threads */
125 for (i = 0; i < MAX_ITER_TIMES; i++) {
126 rp = rte_ring_create("fr_test_once", 4096, SOCKET_ID_ANY, 0);
128 rte_atomic32_inc(&obj_count);
131 /* create/lookup new ring several times */
132 for (i = 0; i < MAX_ITER_TIMES; i++) {
133 snprintf(ring_name, sizeof(ring_name), "fr_test_%d_%d", lcore_self, i);
134 rp = rte_ring_create(ring_name, 4096, SOCKET_ID_ANY, 0);
137 if (rte_ring_lookup(ring_name) != rp)
141 /* verify all ring created successful */
142 for (i = 0; i < MAX_ITER_TIMES; i++) {
143 snprintf(ring_name, sizeof(ring_name), "fr_test_%d_%d", lcore_self, i);
144 if (rte_ring_lookup(ring_name) == NULL)
152 my_obj_init(struct rte_mempool *mp, __attribute__((unused)) void *arg,
153 void *obj, unsigned i)
155 uint32_t *objnum = obj;
156 memset(obj, 0, mp->elt_size);
161 mempool_create_lookup(__attribute__((unused)) void *arg)
163 unsigned lcore_self = rte_lcore_id();
164 struct rte_mempool * mp;
165 char mempool_name[MAX_STRING_SIZE];
168 WAIT_SYNCHRO_FOR_SLAVES();
170 /* create the same mempool simultaneously on all threads */
171 for (i = 0; i < MAX_ITER_TIMES; i++) {
172 mp = rte_mempool_create("fr_test_once", MEMPOOL_SIZE,
173 MEMPOOL_ELT_SIZE, 0, 0,
178 rte_atomic32_inc(&obj_count);
181 /* create/lookup new ring several times */
182 for (i = 0; i < MAX_ITER_TIMES; i++) {
183 snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d", lcore_self, i);
184 mp = rte_mempool_create(mempool_name, MEMPOOL_SIZE,
185 MEMPOOL_ELT_SIZE, 0, 0,
191 if (rte_mempool_lookup(mempool_name) != mp)
195 /* verify all ring created successful */
196 for (i = 0; i < MAX_ITER_TIMES; i++) {
197 snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d", lcore_self, i);
198 if (rte_mempool_lookup(mempool_name) == NULL)
205 #ifdef RTE_LIBRTE_HASH
207 hash_clean(unsigned lcore_id)
209 char hash_name[MAX_STRING_SIZE];
210 struct rte_hash *handle;
213 for (i = 0; i < MAX_ITER_TIMES; i++) {
214 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_id, i);
216 if ((handle = rte_hash_find_existing(hash_name)) != NULL)
217 rte_hash_free(handle);
222 hash_create_free(__attribute__((unused)) void *arg)
224 unsigned lcore_self = rte_lcore_id();
225 struct rte_hash *handle;
226 char hash_name[MAX_STRING_SIZE];
228 struct rte_hash_parameters hash_params = {
232 .hash_func = (rte_hash_function)rte_jhash_32b,
233 .hash_func_init_val = 0,
237 WAIT_SYNCHRO_FOR_SLAVES();
239 /* create the same hash simultaneously on all threads */
240 hash_params.name = "fr_test_once";
241 for (i = 0; i < MAX_ITER_TIMES; i++) {
242 handle = rte_hash_create(&hash_params);
244 rte_atomic32_inc(&obj_count);
247 /* create mutiple times simultaneously */
248 for (i = 0; i < MAX_ITER_TIMES; i++) {
249 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_self, i);
250 hash_params.name = hash_name;
252 handle = rte_hash_create(&hash_params);
256 /* verify correct existing and then free all */
257 if (handle != rte_hash_find_existing(hash_name))
260 rte_hash_free(handle);
263 /* verify free correct */
264 for (i = 0; i < MAX_ITER_TIMES; i++) {
265 snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_self, i);
267 if (NULL != rte_hash_find_existing(hash_name))
275 fbk_clean(unsigned lcore_id)
277 char fbk_name[MAX_STRING_SIZE];
278 struct rte_fbk_hash_table *handle;
281 for (i = 0; i < MAX_ITER_TIMES; i++) {
282 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d", lcore_id, i);
284 if ((handle = rte_fbk_hash_find_existing(fbk_name)) != NULL)
285 rte_fbk_hash_free(handle);
290 fbk_create_free(__attribute__((unused)) void *arg)
292 unsigned lcore_self = rte_lcore_id();
293 struct rte_fbk_hash_table *handle;
294 char fbk_name[MAX_STRING_SIZE];
296 struct rte_fbk_hash_params fbk_params = {
299 .entries_per_bucket = 4,
301 .hash_func = rte_jhash_1word,
302 .init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT,
305 WAIT_SYNCHRO_FOR_SLAVES();
307 /* create the same fbk hash table simultaneously on all threads */
308 fbk_params.name = "fr_test_once";
309 for (i = 0; i < MAX_ITER_TIMES; i++) {
310 handle = rte_fbk_hash_create(&fbk_params);
312 rte_atomic32_inc(&obj_count);
315 /* create mutiple fbk tables simultaneously */
316 for (i = 0; i < MAX_ITER_TIMES; i++) {
317 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d", lcore_self, i);
318 fbk_params.name = fbk_name;
320 handle = rte_fbk_hash_create(&fbk_params);
324 /* verify correct existing and then free all */
325 if (handle != rte_fbk_hash_find_existing(fbk_name))
328 rte_fbk_hash_free(handle);
331 /* verify free correct */
332 for (i = 0; i < MAX_ITER_TIMES; i++) {
333 snprintf(fbk_name, sizeof(fbk_name), "fr_test_%d_%d", lcore_self, i);
335 if (NULL != rte_fbk_hash_find_existing(fbk_name))
341 #endif /* RTE_LIBRTE_HASH */
343 #ifdef RTE_LIBRTE_LPM
345 lpm_clean(unsigned lcore_id)
347 char lpm_name[MAX_STRING_SIZE];
351 for (i = 0; i < MAX_LPM_ITER_TIMES; i++) {
352 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d", lcore_id, i);
354 if ((lpm = rte_lpm_find_existing(lpm_name)) != NULL)
360 lpm_create_free(__attribute__((unused)) void *arg)
362 unsigned lcore_self = rte_lcore_id();
364 struct rte_lpm_config config;
366 config.max_rules = 4;
367 config.number_tbl8s = 256;
369 char lpm_name[MAX_STRING_SIZE];
372 WAIT_SYNCHRO_FOR_SLAVES();
374 /* create the same lpm simultaneously on all threads */
375 for (i = 0; i < MAX_ITER_TIMES; i++) {
376 lpm = rte_lpm_create("fr_test_once", SOCKET_ID_ANY, &config);
378 rte_atomic32_inc(&obj_count);
381 /* create mutiple fbk tables simultaneously */
382 for (i = 0; i < MAX_LPM_ITER_TIMES; i++) {
383 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d", lcore_self, i);
384 lpm = rte_lpm_create(lpm_name, SOCKET_ID_ANY, &config);
388 /* verify correct existing and then free all */
389 if (lpm != rte_lpm_find_existing(lpm_name))
395 /* verify free correct */
396 for (i = 0; i < MAX_LPM_ITER_TIMES; i++) {
397 snprintf(lpm_name, sizeof(lpm_name), "fr_test_%d_%d", lcore_self, i);
398 if (NULL != rte_lpm_find_existing(lpm_name))
404 #endif /* RTE_LIBRTE_LPM */
410 char name[MAX_STRING_SIZE];
413 /* All test cases in the test suite */
414 struct test_case test_cases[] = {
415 { test_eal_init_once, NULL, NULL, "eal init once" },
416 { ring_create_lookup, NULL, NULL, "ring create/lookup" },
417 { mempool_create_lookup, NULL, NULL, "mempool create/lookup" },
418 #ifdef RTE_LIBRTE_HASH
419 { hash_create_free, NULL, hash_clean, "hash create/free" },
420 { fbk_create_free, NULL, fbk_clean, "fbk create/free" },
421 #endif /* RTE_LIBRTE_HASH */
422 #ifdef RTE_LIBRTE_LPM
423 { lpm_create_free, NULL, lpm_clean, "lpm create/free" },
424 #endif /* RTE_LIBRTE_LPM */
428 * launch test case in two separate thread
431 launch_test(struct test_case *pt_case)
435 unsigned cores_save = rte_lcore_count();
436 unsigned cores = RTE_MIN(cores_save, MAX_LCORES);
439 if (pt_case->func == NULL)
442 rte_atomic32_set(&obj_count, 0);
443 rte_atomic32_set(&synchro, 0);
445 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
449 rte_eal_remote_launch(pt_case->func, pt_case->arg, lcore_id);
452 rte_atomic32_set(&synchro, 1);
454 if (pt_case->func(pt_case->arg) < 0)
458 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
462 if (rte_eal_wait_lcore(lcore_id) < 0)
465 if (pt_case->clean != NULL)
466 pt_case->clean(lcore_id);
469 count = rte_atomic32_read(&obj_count);
471 printf("%s: common object allocated %d times (should be 1)\n",
472 pt_case->name, count);
480 * Main entry of func_reentrancy test
483 test_func_reentrancy(void)
486 struct test_case *pt_case = NULL;
488 if (rte_lcore_count() <= 1) {
489 printf("Not enough lcore for testing\n");
492 else if (rte_lcore_count() > MAX_LCORES)
493 printf("Too many lcores, some cores will be disabled\n");
495 for (case_id = 0; case_id < sizeof(test_cases)/sizeof(struct test_case); case_id ++) {
496 pt_case = &test_cases[case_id];
497 if (pt_case->func == NULL)
500 if (launch_test(pt_case) < 0) {
501 printf("Func-ReEnt CASE %"PRIu32": %s FAIL\n", case_id, pt_case->name);
504 printf("Func-ReEnt CASE %"PRIu32": %s PASS\n", case_id, pt_case->name);
510 REGISTER_TEST_COMMAND(func_reentrancy_autotest, test_func_reentrancy);