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