mk: optimize directory dependencies
[dpdk.git] / test / test / test_hash.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2015 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 <stdio.h>
35 #include <stdint.h>
36 #include <string.h>
37 #include <stdlib.h>
38 #include <stdarg.h>
39 #include <errno.h>
40 #include <sys/queue.h>
41
42 #include <rte_common.h>
43 #include <rte_malloc.h>
44 #include <rte_cycles.h>
45 #include <rte_random.h>
46 #include <rte_memory.h>
47 #include <rte_memzone.h>
48 #include <rte_eal.h>
49 #include <rte_ip.h>
50 #include <rte_string_fns.h>
51
52 #include "test.h"
53
54 #include <rte_hash.h>
55 #include <rte_fbk_hash.h>
56 #include <rte_jhash.h>
57 #include <rte_hash_crc.h>
58
59 /*******************************************************************************
60  * Hash function performance test configuration section. Each performance test
61  * will be performed HASHTEST_ITERATIONS times.
62  *
63  * The five arrays below control what tests are performed. Every combination
64  * from the array entries is tested.
65  */
66 static rte_hash_function hashtest_funcs[] = {rte_jhash, rte_hash_crc};
67 static uint32_t hashtest_initvals[] = {0};
68 static uint32_t hashtest_key_lens[] = {0, 2, 4, 5, 6, 7, 8, 10, 11, 15, 16, 21, 31, 32, 33, 63, 64};
69 #define MAX_KEYSIZE 64
70 /******************************************************************************/
71 #define LOCAL_FBK_HASH_ENTRIES_MAX (1 << 15)
72
73 /*
74  * Check condition and return an error if true. Assumes that "handle" is the
75  * name of the hash structure pointer to be freed.
76  */
77 #define RETURN_IF_ERROR(cond, str, ...) do {                            \
78         if (cond) {                                                     \
79                 printf("ERROR line %d: " str "\n", __LINE__, ##__VA_ARGS__); \
80                 if (handle) rte_hash_free(handle);                      \
81                 return -1;                                              \
82         }                                                               \
83 } while(0)
84
85 #define RETURN_IF_ERROR_FBK(cond, str, ...) do {                                \
86         if (cond) {                                                     \
87                 printf("ERROR line %d: " str "\n", __LINE__, ##__VA_ARGS__); \
88                 if (handle) rte_fbk_hash_free(handle);                  \
89                 return -1;                                              \
90         }                                                               \
91 } while(0)
92
93 /* 5-tuple key type */
94 struct flow_key {
95         uint32_t ip_src;
96         uint32_t ip_dst;
97         uint16_t port_src;
98         uint16_t port_dst;
99         uint8_t proto;
100 } __attribute__((packed));
101
102 /*
103  * Hash function that always returns the same value, to easily test what
104  * happens when a bucket is full.
105  */
106 static uint32_t pseudo_hash(__attribute__((unused)) const void *keys,
107                             __attribute__((unused)) uint32_t key_len,
108                             __attribute__((unused)) uint32_t init_val)
109 {
110         return 3;
111 }
112
113 /*
114  * Print out result of unit test hash operation.
115  */
116 #if defined(UNIT_TEST_HASH_VERBOSE)
117 static void print_key_info(const char *msg, const struct flow_key *key,
118                                                                 int32_t pos)
119 {
120         uint8_t *p = (uint8_t *)key;
121         unsigned i;
122
123         printf("%s key:0x", msg);
124         for (i = 0; i < sizeof(struct flow_key); i++) {
125                 printf("%02X", p[i]);
126         }
127         printf(" @ pos %d\n", pos);
128 }
129 #else
130 static void print_key_info(__attribute__((unused)) const char *msg,
131                 __attribute__((unused)) const struct flow_key *key,
132                 __attribute__((unused)) int32_t pos)
133 {
134 }
135 #endif
136
137 /* Keys used by unit test functions */
138 static struct flow_key keys[5] = { {
139         .ip_src = IPv4(0x03, 0x02, 0x01, 0x00),
140         .ip_dst = IPv4(0x07, 0x06, 0x05, 0x04),
141         .port_src = 0x0908,
142         .port_dst = 0x0b0a,
143         .proto = 0x0c,
144 }, {
145         .ip_src = IPv4(0x13, 0x12, 0x11, 0x10),
146         .ip_dst = IPv4(0x17, 0x16, 0x15, 0x14),
147         .port_src = 0x1918,
148         .port_dst = 0x1b1a,
149         .proto = 0x1c,
150 }, {
151         .ip_src = IPv4(0x23, 0x22, 0x21, 0x20),
152         .ip_dst = IPv4(0x27, 0x26, 0x25, 0x24),
153         .port_src = 0x2928,
154         .port_dst = 0x2b2a,
155         .proto = 0x2c,
156 }, {
157         .ip_src = IPv4(0x33, 0x32, 0x31, 0x30),
158         .ip_dst = IPv4(0x37, 0x36, 0x35, 0x34),
159         .port_src = 0x3938,
160         .port_dst = 0x3b3a,
161         .proto = 0x3c,
162 }, {
163         .ip_src = IPv4(0x43, 0x42, 0x41, 0x40),
164         .ip_dst = IPv4(0x47, 0x46, 0x45, 0x44),
165         .port_src = 0x4948,
166         .port_dst = 0x4b4a,
167         .proto = 0x4c,
168 } };
169
170 /* Parameters used for hash table in unit test functions. Name set later. */
171 static struct rte_hash_parameters ut_params = {
172         .entries = 64,
173         .key_len = sizeof(struct flow_key), /* 13 */
174         .hash_func = rte_jhash,
175         .hash_func_init_val = 0,
176         .socket_id = 0,
177 };
178
179 #define CRC32_ITERATIONS (1U << 10)
180 #define CRC32_DWORDS (1U << 6)
181 /*
182  * Test if all CRC32 implementations yield the same hash value
183  */
184 static int
185 test_crc32_hash_alg_equiv(void)
186 {
187         uint32_t hash_val;
188         uint32_t init_val;
189         uint64_t data64[CRC32_DWORDS];
190         unsigned i, j;
191         size_t data_len;
192
193         printf("\n# CRC32 implementations equivalence test\n");
194         for (i = 0; i < CRC32_ITERATIONS; i++) {
195                 /* Randomizing data_len of data set */
196                 data_len = (size_t) ((rte_rand() % sizeof(data64)) + 1);
197                 init_val = (uint32_t) rte_rand();
198
199                 /* Fill the data set */
200                 for (j = 0; j < CRC32_DWORDS; j++)
201                         data64[j] = rte_rand();
202
203                 /* Calculate software CRC32 */
204                 rte_hash_crc_set_alg(CRC32_SW);
205                 hash_val = rte_hash_crc(data64, data_len, init_val);
206
207                 /* Check against 4-byte-operand sse4.2 CRC32 if available */
208                 rte_hash_crc_set_alg(CRC32_SSE42);
209                 if (hash_val != rte_hash_crc(data64, data_len, init_val)) {
210                         printf("Failed checking CRC32_SW against CRC32_SSE42\n");
211                         break;
212                 }
213
214                 /* Check against 8-byte-operand sse4.2 CRC32 if available */
215                 rte_hash_crc_set_alg(CRC32_SSE42_x64);
216                 if (hash_val != rte_hash_crc(data64, data_len, init_val)) {
217                         printf("Failed checking CRC32_SW against CRC32_SSE42_x64\n");
218                         break;
219                 }
220
221                 /* Check against 8-byte-operand ARM64 CRC32 if available */
222                 rte_hash_crc_set_alg(CRC32_ARM64);
223                 if (hash_val != rte_hash_crc(data64, data_len, init_val)) {
224                         printf("Failed checking CRC32_SW against CRC32_ARM64\n");
225                         break;
226                 }
227         }
228
229         /* Resetting to best available algorithm */
230         rte_hash_crc_set_alg(CRC32_SSE42_x64);
231
232         if (i == CRC32_ITERATIONS)
233                 return 0;
234
235         printf("Failed test data (hex, %zu bytes total):\n", data_len);
236         for (j = 0; j < data_len; j++)
237                 printf("%02X%c", ((uint8_t *)data64)[j],
238                                 ((j+1) % 16 == 0 || j == data_len - 1) ? '\n' : ' ');
239
240         return -1;
241 }
242
243 /*
244  * Test a hash function.
245  */
246 static void run_hash_func_test(rte_hash_function f, uint32_t init_val,
247                 uint32_t key_len)
248 {
249         static uint8_t key[MAX_KEYSIZE];
250         unsigned i;
251
252
253         for (i = 0; i < key_len; i++)
254                 key[i] = (uint8_t) rte_rand();
255
256         /* just to be on the safe side */
257         if (!f)
258                 return;
259
260         f(key, key_len, init_val);
261 }
262
263 /*
264  * Test all hash functions.
265  */
266 static void run_hash_func_tests(void)
267 {
268         unsigned i, j, k;
269
270         for (i = 0;
271              i < sizeof(hashtest_funcs) / sizeof(rte_hash_function);
272              i++) {
273                 for (j = 0;
274                      j < sizeof(hashtest_initvals) / sizeof(uint32_t);
275                      j++) {
276                         for (k = 0;
277                              k < sizeof(hashtest_key_lens) / sizeof(uint32_t);
278                              k++) {
279                                 run_hash_func_test(hashtest_funcs[i],
280                                                 hashtest_initvals[j],
281                                                 hashtest_key_lens[k]);
282                         }
283                 }
284         }
285 }
286
287 /*
288  * Basic sequence of operations for a single key:
289  *      - add
290  *      - lookup (hit)
291  *      - delete
292  *      - lookup (miss)
293  */
294 static int test_add_delete(void)
295 {
296         struct rte_hash *handle;
297         /* test with standard add/lookup/delete functions */
298         int pos0, expectedPos0;
299
300         ut_params.name = "test1";
301         handle = rte_hash_create(&ut_params);
302         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
303
304         pos0 = rte_hash_add_key(handle, &keys[0]);
305         print_key_info("Add", &keys[0], pos0);
306         RETURN_IF_ERROR(pos0 < 0, "failed to add key (pos0=%d)", pos0);
307         expectedPos0 = pos0;
308
309         pos0 = rte_hash_lookup(handle, &keys[0]);
310         print_key_info("Lkp", &keys[0], pos0);
311         RETURN_IF_ERROR(pos0 != expectedPos0,
312                         "failed to find key (pos0=%d)", pos0);
313
314         pos0 = rte_hash_del_key(handle, &keys[0]);
315         print_key_info("Del", &keys[0], pos0);
316         RETURN_IF_ERROR(pos0 != expectedPos0,
317                         "failed to delete key (pos0=%d)", pos0);
318
319         pos0 = rte_hash_lookup(handle, &keys[0]);
320         print_key_info("Lkp", &keys[0], pos0);
321         RETURN_IF_ERROR(pos0 != -ENOENT,
322                         "fail: found key after deleting! (pos0=%d)", pos0);
323
324         rte_hash_free(handle);
325
326         /* repeat test with precomputed hash functions */
327         hash_sig_t hash_value;
328         int pos1, expectedPos1;
329
330         handle = rte_hash_create(&ut_params);
331         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
332
333         hash_value = rte_hash_hash(handle, &keys[0]);
334         pos1 = rte_hash_add_key_with_hash(handle, &keys[0], hash_value);
335         print_key_info("Add", &keys[0], pos1);
336         RETURN_IF_ERROR(pos1 < 0, "failed to add key (pos1=%d)", pos1);
337         expectedPos1 = pos1;
338
339         pos1 = rte_hash_lookup_with_hash(handle, &keys[0], hash_value);
340         print_key_info("Lkp", &keys[0], pos1);
341         RETURN_IF_ERROR(pos1 != expectedPos1,
342                         "failed to find key (pos1=%d)", pos1);
343
344         pos1 = rte_hash_del_key_with_hash(handle, &keys[0], hash_value);
345         print_key_info("Del", &keys[0], pos1);
346         RETURN_IF_ERROR(pos1 != expectedPos1,
347                         "failed to delete key (pos1=%d)", pos1);
348
349         pos1 = rte_hash_lookup_with_hash(handle, &keys[0], hash_value);
350         print_key_info("Lkp", &keys[0], pos1);
351         RETURN_IF_ERROR(pos1 != -ENOENT,
352                         "fail: found key after deleting! (pos1=%d)", pos1);
353
354         rte_hash_free(handle);
355
356         return 0;
357 }
358
359 /*
360  * Sequence of operations for a single key:
361  *      - delete: miss
362  *      - add
363  *      - lookup: hit
364  *      - add: update
365  *      - lookup: hit (updated data)
366  *      - delete: hit
367  *      - delete: miss
368  *      - lookup: miss
369  */
370 static int test_add_update_delete(void)
371 {
372         struct rte_hash *handle;
373         int pos0, expectedPos0;
374
375         ut_params.name = "test2";
376         handle = rte_hash_create(&ut_params);
377         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
378
379         pos0 = rte_hash_del_key(handle, &keys[0]);
380         print_key_info("Del", &keys[0], pos0);
381         RETURN_IF_ERROR(pos0 != -ENOENT,
382                         "fail: found non-existent key (pos0=%d)", pos0);
383
384         pos0 = rte_hash_add_key(handle, &keys[0]);
385         print_key_info("Add", &keys[0], pos0);
386         RETURN_IF_ERROR(pos0 < 0, "failed to add key (pos0=%d)", pos0);
387         expectedPos0 = pos0;
388
389         pos0 = rte_hash_lookup(handle, &keys[0]);
390         print_key_info("Lkp", &keys[0], pos0);
391         RETURN_IF_ERROR(pos0 != expectedPos0,
392                         "failed to find key (pos0=%d)", pos0);
393
394         pos0 = rte_hash_add_key(handle, &keys[0]);
395         print_key_info("Add", &keys[0], pos0);
396         RETURN_IF_ERROR(pos0 != expectedPos0,
397                         "failed to re-add key (pos0=%d)", pos0);
398
399         pos0 = rte_hash_lookup(handle, &keys[0]);
400         print_key_info("Lkp", &keys[0], pos0);
401         RETURN_IF_ERROR(pos0 != expectedPos0,
402                         "failed to find key (pos0=%d)", pos0);
403
404         pos0 = rte_hash_del_key(handle, &keys[0]);
405         print_key_info("Del", &keys[0], pos0);
406         RETURN_IF_ERROR(pos0 != expectedPos0,
407                         "failed to delete key (pos0=%d)", pos0);
408
409         pos0 = rte_hash_del_key(handle, &keys[0]);
410         print_key_info("Del", &keys[0], pos0);
411         RETURN_IF_ERROR(pos0 != -ENOENT,
412                         "fail: deleted already deleted key (pos0=%d)", pos0);
413
414         pos0 = rte_hash_lookup(handle, &keys[0]);
415         print_key_info("Lkp", &keys[0], pos0);
416         RETURN_IF_ERROR(pos0 != -ENOENT,
417                         "fail: found key after deleting! (pos0=%d)", pos0);
418
419         rte_hash_free(handle);
420         return 0;
421 }
422
423 /*
424  * Sequence of operations for retrieving a key with its position
425  *
426  *  - create table
427  *  - add key
428  *  - get the key with its position: hit
429  *  - delete key
430  *  - try to get the deleted key: miss
431  *
432  */
433 static int test_hash_get_key_with_position(void)
434 {
435         struct rte_hash *handle = NULL;
436         int pos, expectedPos, result;
437         void *key;
438
439         ut_params.name = "hash_get_key_w_pos";
440         handle = rte_hash_create(&ut_params);
441         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
442
443         pos = rte_hash_add_key(handle, &keys[0]);
444         print_key_info("Add", &keys[0], pos);
445         RETURN_IF_ERROR(pos < 0, "failed to add key (pos0=%d)", pos);
446         expectedPos = pos;
447
448         result = rte_hash_get_key_with_position(handle, pos, &key);
449         RETURN_IF_ERROR(result != 0, "error retrieving a key");
450
451         pos = rte_hash_del_key(handle, &keys[0]);
452         print_key_info("Del", &keys[0], pos);
453         RETURN_IF_ERROR(pos != expectedPos,
454                         "failed to delete key (pos0=%d)", pos);
455
456         result = rte_hash_get_key_with_position(handle, pos, &key);
457         RETURN_IF_ERROR(result != -ENOENT, "non valid key retrieved");
458
459         rte_hash_free(handle);
460         return 0;
461 }
462
463 /*
464  * Sequence of operations for find existing hash table
465  *
466  *  - create table
467  *  - find existing table: hit
468  *  - find non-existing table: miss
469  *
470  */
471 static int test_hash_find_existing(void)
472 {
473         struct rte_hash *handle = NULL, *result = NULL;
474
475         /* Create hash table. */
476         ut_params.name = "hash_find_existing";
477         handle = rte_hash_create(&ut_params);
478         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
479
480         /* Try to find existing hash table */
481         result = rte_hash_find_existing("hash_find_existing");
482         RETURN_IF_ERROR(result != handle, "could not find existing hash table");
483
484         /* Try to find non-existing hash table */
485         result = rte_hash_find_existing("hash_find_non_existing");
486         RETURN_IF_ERROR(!(result == NULL), "found table that shouldn't exist");
487
488         /* Cleanup. */
489         rte_hash_free(handle);
490
491         return 0;
492 }
493
494 /*
495  * Sequence of operations for 5 keys
496  *      - add keys
497  *      - lookup keys: hit
498  *      - add keys (update)
499  *      - lookup keys: hit (updated data)
500  *      - delete keys : hit
501  *      - lookup keys: miss
502  */
503 static int test_five_keys(void)
504 {
505         struct rte_hash *handle;
506         const void *key_array[5] = {0};
507         int pos[5];
508         int expected_pos[5];
509         unsigned i;
510         int ret;
511
512         ut_params.name = "test3";
513         handle = rte_hash_create(&ut_params);
514         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
515
516         /* Add */
517         for (i = 0; i < 5; i++) {
518                 pos[i] = rte_hash_add_key(handle, &keys[i]);
519                 print_key_info("Add", &keys[i], pos[i]);
520                 RETURN_IF_ERROR(pos[i] < 0,
521                                 "failed to add key (pos[%u]=%d)", i, pos[i]);
522                 expected_pos[i] = pos[i];
523         }
524
525         /* Lookup */
526         for(i = 0; i < 5; i++)
527                 key_array[i] = &keys[i];
528
529         ret = rte_hash_lookup_bulk(handle, &key_array[0], 5, (int32_t *)pos);
530         if(ret == 0)
531                 for(i = 0; i < 5; i++) {
532                         print_key_info("Lkp", key_array[i], pos[i]);
533                         RETURN_IF_ERROR(pos[i] != expected_pos[i],
534                                         "failed to find key (pos[%u]=%d)", i, pos[i]);
535                 }
536
537         /* Add - update */
538         for (i = 0; i < 5; i++) {
539                 pos[i] = rte_hash_add_key(handle, &keys[i]);
540                 print_key_info("Add", &keys[i], pos[i]);
541                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
542                                 "failed to add key (pos[%u]=%d)", i, pos[i]);
543         }
544
545         /* Lookup */
546         for (i = 0; i < 5; i++) {
547                 pos[i] = rte_hash_lookup(handle, &keys[i]);
548                 print_key_info("Lkp", &keys[i], pos[i]);
549                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
550                                 "failed to find key (pos[%u]=%d)", i, pos[i]);
551         }
552
553         /* Delete */
554         for (i = 0; i < 5; i++) {
555                 pos[i] = rte_hash_del_key(handle, &keys[i]);
556                 print_key_info("Del", &keys[i], pos[i]);
557                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
558                                 "failed to delete key (pos[%u]=%d)", i, pos[i]);
559         }
560
561         /* Lookup */
562         for (i = 0; i < 5; i++) {
563                 pos[i] = rte_hash_lookup(handle, &keys[i]);
564                 print_key_info("Lkp", &keys[i], pos[i]);
565                 RETURN_IF_ERROR(pos[i] != -ENOENT,
566                                 "found non-existent key (pos[%u]=%d)", i, pos[i]);
567         }
568
569         /* Lookup multi */
570         ret = rte_hash_lookup_bulk(handle, &key_array[0], 5, (int32_t *)pos);
571         if (ret == 0)
572                 for (i = 0; i < 5; i++) {
573                         print_key_info("Lkp", key_array[i], pos[i]);
574                         RETURN_IF_ERROR(pos[i] != -ENOENT,
575                                         "found not-existent key (pos[%u]=%d)", i, pos[i]);
576                 }
577
578         rte_hash_free(handle);
579
580         return 0;
581 }
582
583 /*
584  * Add keys to the same bucket until bucket full.
585  *      - add 5 keys to the same bucket (hash created with 4 keys per bucket):
586  *        first 4 successful, 5th successful, pushing existing item in bucket
587  *      - lookup the 5 keys: 5 hits
588  *      - add the 5 keys again: 5 OK
589  *      - lookup the 5 keys: 5 hits (updated data)
590  *      - delete the 5 keys: 5 OK
591  *      - lookup the 5 keys: 5 misses
592  */
593 static int test_full_bucket(void)
594 {
595         struct rte_hash_parameters params_pseudo_hash = {
596                 .name = "test4",
597                 .entries = 64,
598                 .key_len = sizeof(struct flow_key), /* 13 */
599                 .hash_func = pseudo_hash,
600                 .hash_func_init_val = 0,
601                 .socket_id = 0,
602         };
603         struct rte_hash *handle;
604         int pos[5];
605         int expected_pos[5];
606         unsigned i;
607
608         handle = rte_hash_create(&params_pseudo_hash);
609         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
610
611         /* Fill bucket */
612         for (i = 0; i < 4; i++) {
613                 pos[i] = rte_hash_add_key(handle, &keys[i]);
614                 print_key_info("Add", &keys[i], pos[i]);
615                 RETURN_IF_ERROR(pos[i] < 0,
616                         "failed to add key (pos[%u]=%d)", i, pos[i]);
617                 expected_pos[i] = pos[i];
618         }
619         /*
620          * This should work and will push one of the items
621          * in the bucket because it is full
622          */
623         pos[4] = rte_hash_add_key(handle, &keys[4]);
624         print_key_info("Add", &keys[4], pos[4]);
625         RETURN_IF_ERROR(pos[4] < 0,
626                         "failed to add key (pos[4]=%d)", pos[4]);
627         expected_pos[4] = pos[4];
628
629         /* Lookup */
630         for (i = 0; i < 5; i++) {
631                 pos[i] = rte_hash_lookup(handle, &keys[i]);
632                 print_key_info("Lkp", &keys[i], pos[i]);
633                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
634                         "failed to find key (pos[%u]=%d)", i, pos[i]);
635         }
636
637         /* Add - update */
638         for (i = 0; i < 5; i++) {
639                 pos[i] = rte_hash_add_key(handle, &keys[i]);
640                 print_key_info("Add", &keys[i], pos[i]);
641                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
642                         "failed to add key (pos[%u]=%d)", i, pos[i]);
643         }
644
645         /* Lookup */
646         for (i = 0; i < 5; i++) {
647                 pos[i] = rte_hash_lookup(handle, &keys[i]);
648                 print_key_info("Lkp", &keys[i], pos[i]);
649                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
650                         "failed to find key (pos[%u]=%d)", i, pos[i]);
651         }
652
653         /* Delete 1 key, check other keys are still found */
654         pos[1] = rte_hash_del_key(handle, &keys[1]);
655         print_key_info("Del", &keys[1], pos[1]);
656         RETURN_IF_ERROR(pos[1] != expected_pos[1],
657                         "failed to delete key (pos[1]=%d)", pos[1]);
658         pos[3] = rte_hash_lookup(handle, &keys[3]);
659         print_key_info("Lkp", &keys[3], pos[3]);
660         RETURN_IF_ERROR(pos[3] != expected_pos[3],
661                         "failed lookup after deleting key from same bucket "
662                         "(pos[3]=%d)", pos[3]);
663
664         /* Go back to previous state */
665         pos[1] = rte_hash_add_key(handle, &keys[1]);
666         print_key_info("Add", &keys[1], pos[1]);
667         expected_pos[1] = pos[1];
668         RETURN_IF_ERROR(pos[1] < 0, "failed to add key (pos[1]=%d)", pos[1]);
669
670         /* Delete */
671         for (i = 0; i < 5; i++) {
672                 pos[i] = rte_hash_del_key(handle, &keys[i]);
673                 print_key_info("Del", &keys[i], pos[i]);
674                 RETURN_IF_ERROR(pos[i] != expected_pos[i],
675                         "failed to delete key (pos[%u]=%d)", i, pos[i]);
676         }
677
678         /* Lookup */
679         for (i = 0; i < 5; i++) {
680                 pos[i] = rte_hash_lookup(handle, &keys[i]);
681                 print_key_info("Lkp", &keys[i], pos[i]);
682                 RETURN_IF_ERROR(pos[i] != -ENOENT,
683                         "fail: found non-existent key (pos[%u]=%d)", i, pos[i]);
684         }
685
686         rte_hash_free(handle);
687
688         /* Cover the NULL case. */
689         rte_hash_free(0);
690         return 0;
691 }
692
693 /******************************************************************************/
694 static int
695 fbk_hash_unit_test(void)
696 {
697         struct rte_fbk_hash_params params = {
698                 .name = "fbk_hash_test",
699                 .entries = LOCAL_FBK_HASH_ENTRIES_MAX,
700                 .entries_per_bucket = 4,
701                 .socket_id = 0,
702         };
703
704         struct rte_fbk_hash_params invalid_params_1 = {
705                 .name = "invalid_1",
706                 .entries = LOCAL_FBK_HASH_ENTRIES_MAX + 1, /* Not power of 2 */
707                 .entries_per_bucket = 4,
708                 .socket_id = 0,
709         };
710
711         struct rte_fbk_hash_params invalid_params_2 = {
712                 .name = "invalid_2",
713                 .entries = 4,
714                 .entries_per_bucket = 3,         /* Not power of 2 */
715                 .socket_id = 0,
716         };
717
718         struct rte_fbk_hash_params invalid_params_3 = {
719                 .name = "invalid_3",
720                 .entries = 0,                    /* Entries is 0 */
721                 .entries_per_bucket = 4,
722                 .socket_id = 0,
723         };
724
725         struct rte_fbk_hash_params invalid_params_4 = {
726                 .name = "invalid_4",
727                 .entries = LOCAL_FBK_HASH_ENTRIES_MAX,
728                 .entries_per_bucket = 0,         /* Entries per bucket is 0 */
729                 .socket_id = 0,
730         };
731
732         struct rte_fbk_hash_params invalid_params_5 = {
733                 .name = "invalid_5",
734                 .entries = 4,
735                 .entries_per_bucket = 8,         /* Entries per bucket > entries */
736                 .socket_id = 0,
737         };
738
739         struct rte_fbk_hash_params invalid_params_6 = {
740                 .name = "invalid_6",
741                 .entries = RTE_FBK_HASH_ENTRIES_MAX * 2,   /* Entries > max allowed */
742                 .entries_per_bucket = 4,
743                 .socket_id = 0,
744         };
745
746         struct rte_fbk_hash_params invalid_params_7 = {
747                 .name = "invalid_7",
748                 .entries = RTE_FBK_HASH_ENTRIES_MAX,
749                 .entries_per_bucket = RTE_FBK_HASH_ENTRIES_PER_BUCKET_MAX * 2,  /* Entries > max allowed */
750                 .socket_id = 0,
751         };
752
753         struct rte_fbk_hash_params invalid_params_8 = {
754                 .name = "invalid_7",
755                 .entries = RTE_FBK_HASH_ENTRIES_MAX,
756                 .entries_per_bucket = 4,
757                 .socket_id = RTE_MAX_NUMA_NODES + 1, /* invalid socket */
758         };
759
760         /* try to create two hashes with identical names
761          * in this case, trying to create a second one will not
762          * fail but will simply return pointer to the existing
763          * hash with that name. sort of like a "find hash by name" :-)
764          */
765         struct rte_fbk_hash_params invalid_params_same_name_1 = {
766                 .name = "same_name",                            /* hash with identical name */
767                 .entries = 4,
768                 .entries_per_bucket = 2,
769                 .socket_id = 0,
770         };
771
772         /* trying to create this hash should return a pointer to an existing hash */
773         struct rte_fbk_hash_params invalid_params_same_name_2 = {
774                 .name = "same_name",                            /* hash with identical name */
775                 .entries = RTE_FBK_HASH_ENTRIES_MAX,
776                 .entries_per_bucket = 4,
777                 .socket_id = 0,
778         };
779
780         /* this is a sanity check for "same name" test
781          * creating this hash will check if we are actually able to create
782          * multiple hashes with different names (instead of having just one).
783          */
784         struct rte_fbk_hash_params different_name = {
785                 .name = "different_name",                       /* different name */
786                 .entries = LOCAL_FBK_HASH_ENTRIES_MAX,
787                 .entries_per_bucket = 4,
788                 .socket_id = 0,
789         };
790
791         struct rte_fbk_hash_params params_jhash = {
792                 .name = "valid",
793                 .entries = LOCAL_FBK_HASH_ENTRIES_MAX,
794                 .entries_per_bucket = 4,
795                 .socket_id = 0,
796                 .hash_func = rte_jhash_1word,              /* Tests for different hash_func */
797                 .init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT,
798         };
799
800         struct rte_fbk_hash_params params_nohash = {
801                 .name = "valid nohash",
802                 .entries = LOCAL_FBK_HASH_ENTRIES_MAX,
803                 .entries_per_bucket = 4,
804                 .socket_id = 0,
805                 .hash_func = NULL,                            /* Tests for null hash_func */
806                 .init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT,
807         };
808
809         struct rte_fbk_hash_table *handle, *tmp;
810         uint32_t keys[5] =
811                 {0xc6e18639, 0xe67c201c, 0xd4c8cffd, 0x44728691, 0xd5430fa9};
812         uint16_t vals[5] = {28108, 5699, 38490, 2166, 61571};
813         int status;
814         unsigned i;
815         double used_entries;
816
817         /* Try creating hashes with invalid parameters */
818         printf("# Testing hash creation with invalid parameters "
819                         "- expect error msgs\n");
820         handle = rte_fbk_hash_create(&invalid_params_1);
821         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
822
823         handle = rte_fbk_hash_create(&invalid_params_2);
824         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
825
826         handle = rte_fbk_hash_create(&invalid_params_3);
827         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
828
829         handle = rte_fbk_hash_create(&invalid_params_4);
830         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
831
832         handle = rte_fbk_hash_create(&invalid_params_5);
833         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
834
835         handle = rte_fbk_hash_create(&invalid_params_6);
836         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
837
838         handle = rte_fbk_hash_create(&invalid_params_7);
839         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
840
841         handle = rte_fbk_hash_create(&invalid_params_8);
842         RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
843
844         handle = rte_fbk_hash_create(&invalid_params_same_name_1);
845         RETURN_IF_ERROR_FBK(handle == NULL, "fbk hash creation should have succeeded");
846
847         tmp = rte_fbk_hash_create(&invalid_params_same_name_2);
848         if (tmp != NULL)
849                 rte_fbk_hash_free(tmp);
850         RETURN_IF_ERROR_FBK(tmp != NULL, "fbk hash creation should have failed");
851
852         /* we are not freeing  handle here because we need a hash list
853          * to be not empty for the next test */
854
855         /* create a hash in non-empty list - good for coverage */
856         tmp = rte_fbk_hash_create(&different_name);
857         RETURN_IF_ERROR_FBK(tmp == NULL, "fbk hash creation should have succeeded");
858
859         /* free both hashes */
860         rte_fbk_hash_free(handle);
861         rte_fbk_hash_free(tmp);
862
863         /* Create empty jhash hash. */
864         handle = rte_fbk_hash_create(&params_jhash);
865         RETURN_IF_ERROR_FBK(handle == NULL, "fbk jhash hash creation failed");
866
867         /* Cleanup. */
868         rte_fbk_hash_free(handle);
869
870         /* Create empty jhash hash. */
871         handle = rte_fbk_hash_create(&params_nohash);
872         RETURN_IF_ERROR_FBK(handle == NULL, "fbk nohash hash creation failed");
873
874         /* Cleanup. */
875         rte_fbk_hash_free(handle);
876
877         /* Create empty hash. */
878         handle = rte_fbk_hash_create(&params);
879         RETURN_IF_ERROR_FBK(handle == NULL, "fbk hash creation failed");
880
881         used_entries = rte_fbk_hash_get_load_factor(handle) * LOCAL_FBK_HASH_ENTRIES_MAX;
882         RETURN_IF_ERROR_FBK((unsigned)used_entries != 0, \
883                                 "load factor right after creation is not zero but it should be");
884         /* Add keys. */
885         for (i = 0; i < 5; i++) {
886                 status = rte_fbk_hash_add_key(handle, keys[i], vals[i]);
887                 RETURN_IF_ERROR_FBK(status != 0, "fbk hash add failed");
888         }
889
890         used_entries = rte_fbk_hash_get_load_factor(handle) * LOCAL_FBK_HASH_ENTRIES_MAX;
891         RETURN_IF_ERROR_FBK((unsigned)used_entries != (unsigned)((((double)5)/LOCAL_FBK_HASH_ENTRIES_MAX)*LOCAL_FBK_HASH_ENTRIES_MAX), \
892                                 "load factor now is not as expected");
893         /* Find value of added keys. */
894         for (i = 0; i < 5; i++) {
895                 status = rte_fbk_hash_lookup(handle, keys[i]);
896                 RETURN_IF_ERROR_FBK(status != vals[i],
897                                 "fbk hash lookup failed");
898         }
899
900         /* Change value of added keys. */
901         for (i = 0; i < 5; i++) {
902                 status = rte_fbk_hash_add_key(handle, keys[i], vals[4 - i]);
903                 RETURN_IF_ERROR_FBK(status != 0, "fbk hash update failed");
904         }
905
906         /* Find new values. */
907         for (i = 0; i < 5; i++) {
908                 status = rte_fbk_hash_lookup(handle, keys[i]);
909                 RETURN_IF_ERROR_FBK(status != vals[4-i],
910                                 "fbk hash lookup failed");
911         }
912
913         /* Delete keys individually. */
914         for (i = 0; i < 5; i++) {
915                 status = rte_fbk_hash_delete_key(handle, keys[i]);
916                 RETURN_IF_ERROR_FBK(status != 0, "fbk hash delete failed");
917         }
918
919         used_entries = rte_fbk_hash_get_load_factor(handle) * LOCAL_FBK_HASH_ENTRIES_MAX;
920         RETURN_IF_ERROR_FBK((unsigned)used_entries != 0, \
921                                 "load factor right after deletion is not zero but it should be");
922         /* Lookup should now fail. */
923         for (i = 0; i < 5; i++) {
924                 status = rte_fbk_hash_lookup(handle, keys[i]);
925                 RETURN_IF_ERROR_FBK(status == 0,
926                                 "fbk hash lookup should have failed");
927         }
928
929         /* Add keys again. */
930         for (i = 0; i < 5; i++) {
931                 status = rte_fbk_hash_add_key(handle, keys[i], vals[i]);
932                 RETURN_IF_ERROR_FBK(status != 0, "fbk hash add failed");
933         }
934
935         /* Make sure they were added. */
936         for (i = 0; i < 5; i++) {
937                 status = rte_fbk_hash_lookup(handle, keys[i]);
938                 RETURN_IF_ERROR_FBK(status != vals[i],
939                                 "fbk hash lookup failed");
940         }
941
942         /* Clear all entries. */
943         rte_fbk_hash_clear_all(handle);
944
945         /* Lookup should fail. */
946         for (i = 0; i < 5; i++) {
947                 status = rte_fbk_hash_lookup(handle, keys[i]);
948                 RETURN_IF_ERROR_FBK(status == 0,
949                                 "fbk hash lookup should have failed");
950         }
951
952         /* coverage */
953
954         /* fill up the hash_table */
955         for (i = 0; i < RTE_FBK_HASH_ENTRIES_MAX + 1; i++)
956                 rte_fbk_hash_add_key(handle, i, (uint16_t) i);
957
958         /* Find non-existent key in a full hashtable */
959         status = rte_fbk_hash_lookup(handle, RTE_FBK_HASH_ENTRIES_MAX + 1);
960         RETURN_IF_ERROR_FBK(status != -ENOENT,
961                         "fbk hash lookup succeeded");
962
963         /* Delete non-existent key in a full hashtable */
964         status = rte_fbk_hash_delete_key(handle, RTE_FBK_HASH_ENTRIES_MAX + 1);
965         RETURN_IF_ERROR_FBK(status != -ENOENT,
966                         "fbk hash delete succeeded");
967
968         /* Delete one key from a full hashtable */
969         status = rte_fbk_hash_delete_key(handle, 1);
970         RETURN_IF_ERROR_FBK(status != 0,
971                         "fbk hash delete failed");
972
973         /* Clear all entries. */
974         rte_fbk_hash_clear_all(handle);
975
976         /* Cleanup. */
977         rte_fbk_hash_free(handle);
978
979         /* Cover the NULL case. */
980         rte_fbk_hash_free(0);
981
982         return 0;
983 }
984
985 /*
986  * Sequence of operations for find existing fbk hash table
987  *
988  *  - create table
989  *  - find existing table: hit
990  *  - find non-existing table: miss
991  *
992  */
993 static int test_fbk_hash_find_existing(void)
994 {
995         struct rte_fbk_hash_params params = {
996                         .name = "fbk_hash_find_existing",
997                         .entries = LOCAL_FBK_HASH_ENTRIES_MAX,
998                         .entries_per_bucket = 4,
999                         .socket_id = 0,
1000         };
1001         struct rte_fbk_hash_table *handle = NULL, *result = NULL;
1002
1003         /* Create hash table. */
1004         handle = rte_fbk_hash_create(&params);
1005         RETURN_IF_ERROR_FBK(handle == NULL, "fbk hash creation failed");
1006
1007         /* Try to find existing fbk hash table */
1008         result = rte_fbk_hash_find_existing("fbk_hash_find_existing");
1009         RETURN_IF_ERROR_FBK(result != handle, "could not find existing fbk hash table");
1010
1011         /* Try to find non-existing fbk hash table */
1012         result = rte_fbk_hash_find_existing("fbk_hash_find_non_existing");
1013         RETURN_IF_ERROR_FBK(!(result == NULL), "found fbk table that shouldn't exist");
1014
1015         /* Cleanup. */
1016         rte_fbk_hash_free(handle);
1017
1018         return 0;
1019 }
1020
1021 #define BUCKET_ENTRIES 4
1022 /*
1023  * Do tests for hash creation with bad parameters.
1024  */
1025 static int test_hash_creation_with_bad_parameters(void)
1026 {
1027         struct rte_hash *handle, *tmp;
1028         struct rte_hash_parameters params;
1029
1030         handle = rte_hash_create(NULL);
1031         if (handle != NULL) {
1032                 rte_hash_free(handle);
1033                 printf("Impossible creating hash sucessfully without any parameter\n");
1034                 return -1;
1035         }
1036
1037         memcpy(&params, &ut_params, sizeof(params));
1038         params.name = "creation_with_bad_parameters_0";
1039         params.entries = RTE_HASH_ENTRIES_MAX + 1;
1040         handle = rte_hash_create(&params);
1041         if (handle != NULL) {
1042                 rte_hash_free(handle);
1043                 printf("Impossible creating hash sucessfully with entries in parameter exceeded\n");
1044                 return -1;
1045         }
1046
1047         memcpy(&params, &ut_params, sizeof(params));
1048         params.name = "creation_with_bad_parameters_2";
1049         params.entries = BUCKET_ENTRIES - 1;
1050         handle = rte_hash_create(&params);
1051         if (handle != NULL) {
1052                 rte_hash_free(handle);
1053                 printf("Impossible creating hash sucessfully if entries less than bucket_entries in parameter\n");
1054                 return -1;
1055         }
1056
1057         memcpy(&params, &ut_params, sizeof(params));
1058         params.name = "creation_with_bad_parameters_3";
1059         params.key_len = 0;
1060         handle = rte_hash_create(&params);
1061         if (handle != NULL) {
1062                 rte_hash_free(handle);
1063                 printf("Impossible creating hash sucessfully if key_len in parameter is zero\n");
1064                 return -1;
1065         }
1066
1067         memcpy(&params, &ut_params, sizeof(params));
1068         params.name = "creation_with_bad_parameters_4";
1069         params.socket_id = RTE_MAX_NUMA_NODES + 1;
1070         handle = rte_hash_create(&params);
1071         if (handle != NULL) {
1072                 rte_hash_free(handle);
1073                 printf("Impossible creating hash sucessfully with invalid socket\n");
1074                 return -1;
1075         }
1076
1077         /* test with same name should fail */
1078         memcpy(&params, &ut_params, sizeof(params));
1079         params.name = "same_name";
1080         handle = rte_hash_create(&params);
1081         if (handle == NULL) {
1082                 printf("Cannot create first hash table with 'same_name'\n");
1083                 return -1;
1084         }
1085         tmp = rte_hash_create(&params);
1086         if (tmp != NULL) {
1087                 printf("Creation of hash table with same name should fail\n");
1088                 rte_hash_free(handle);
1089                 rte_hash_free(tmp);
1090                 return -1;
1091         }
1092         rte_hash_free(handle);
1093
1094         printf("# Test successful. No more errors expected\n");
1095
1096         return 0;
1097 }
1098
1099 /*
1100  * Do tests for hash creation with parameters that look incorrect
1101  * but are actually valid.
1102  */
1103 static int
1104 test_hash_creation_with_good_parameters(void)
1105 {
1106         struct rte_hash *handle;
1107         struct rte_hash_parameters params;
1108
1109         /* create with null hash function - should choose DEFAULT_HASH_FUNC */
1110         memcpy(&params, &ut_params, sizeof(params));
1111         params.name = "name";
1112         params.hash_func = NULL;
1113         handle = rte_hash_create(&params);
1114         if (handle == NULL) {
1115                 printf("Creating hash with null hash_func failed\n");
1116                 return -1;
1117         }
1118
1119         rte_hash_free(handle);
1120
1121         return 0;
1122 }
1123
1124 #define ITERATIONS 3
1125 /*
1126  * Test to see the average table utilization (entries added/max entries)
1127  * before hitting a random entry that cannot be added
1128  */
1129 static int test_average_table_utilization(void)
1130 {
1131         struct rte_hash *handle;
1132         uint8_t simple_key[MAX_KEYSIZE];
1133         unsigned i, j;
1134         unsigned added_keys, average_keys_added = 0;
1135         int ret;
1136
1137         printf("\n# Running test to determine average utilization"
1138                "\n  before adding elements begins to fail\n");
1139         printf("Measuring performance, please wait");
1140         fflush(stdout);
1141         ut_params.entries = 1 << 16;
1142         ut_params.name = "test_average_utilization";
1143         ut_params.hash_func = rte_jhash;
1144         handle = rte_hash_create(&ut_params);
1145         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
1146
1147         for (j = 0; j < ITERATIONS; j++) {
1148                 ret = 0;
1149                 /* Add random entries until key cannot be added */
1150                 for (added_keys = 0; ret >= 0; added_keys++) {
1151                         for (i = 0; i < ut_params.key_len; i++)
1152                                 simple_key[i] = rte_rand() % 255;
1153                         ret = rte_hash_add_key(handle, simple_key);
1154                 }
1155                 if (ret != -ENOSPC) {
1156                         printf("Unexpected error when adding keys\n");
1157                         rte_hash_free(handle);
1158                         return -1;
1159                 }
1160
1161                 average_keys_added += added_keys;
1162
1163                 /* Reset the table */
1164                 rte_hash_reset(handle);
1165
1166                 /* Print a dot to show progress on operations */
1167                 printf(".");
1168                 fflush(stdout);
1169         }
1170
1171         average_keys_added /= ITERATIONS;
1172
1173         printf("\nAverage table utilization = %.2f%% (%u/%u)\n",
1174                 ((double) average_keys_added / ut_params.entries * 100),
1175                 average_keys_added, ut_params.entries);
1176         rte_hash_free(handle);
1177
1178         return 0;
1179 }
1180
1181 #define NUM_ENTRIES 256
1182 static int test_hash_iteration(void)
1183 {
1184         struct rte_hash *handle;
1185         unsigned i;
1186         uint8_t keys[NUM_ENTRIES][MAX_KEYSIZE];
1187         const void *next_key;
1188         void *next_data;
1189         void *data[NUM_ENTRIES];
1190         unsigned added_keys;
1191         uint32_t iter = 0;
1192         int ret = 0;
1193
1194         ut_params.entries = NUM_ENTRIES;
1195         ut_params.name = "test_hash_iteration";
1196         ut_params.hash_func = rte_jhash;
1197         ut_params.key_len = 16;
1198         handle = rte_hash_create(&ut_params);
1199         RETURN_IF_ERROR(handle == NULL, "hash creation failed");
1200
1201         /* Add random entries until key cannot be added */
1202         for (added_keys = 0; added_keys < NUM_ENTRIES; added_keys++) {
1203                 data[added_keys] = (void *) ((uintptr_t) rte_rand());
1204                 for (i = 0; i < ut_params.key_len; i++)
1205                         keys[added_keys][i] = rte_rand() % 255;
1206                 ret = rte_hash_add_key_data(handle, keys[added_keys], data[added_keys]);
1207                 if (ret < 0)
1208                         break;
1209         }
1210
1211         /* Iterate through the hash table */
1212         while (rte_hash_iterate(handle, &next_key, &next_data, &iter) >= 0) {
1213                 /* Search for the key in the list of keys added */
1214                 for (i = 0; i < NUM_ENTRIES; i++) {
1215                         if (memcmp(next_key, keys[i], ut_params.key_len) == 0) {
1216                                 if (next_data != data[i]) {
1217                                         printf("Data found in the hash table is"
1218                                                "not the data added with the key\n");
1219                                         goto err;
1220                                 }
1221                                 added_keys--;
1222                                 break;
1223                         }
1224                 }
1225                 if (i == NUM_ENTRIES) {
1226                         printf("Key found in the hash table was not added\n");
1227                         goto err;
1228                 }
1229         }
1230
1231         /* Check if all keys have been iterated */
1232         if (added_keys != 0) {
1233                 printf("There were still %u keys to iterate\n", added_keys);
1234                 goto err;
1235         }
1236
1237         rte_hash_free(handle);
1238         return 0;
1239
1240 err:
1241         rte_hash_free(handle);
1242         return -1;
1243 }
1244
1245 static uint8_t key[16] = {0x00, 0x01, 0x02, 0x03,
1246                         0x04, 0x05, 0x06, 0x07,
1247                         0x08, 0x09, 0x0a, 0x0b,
1248                         0x0c, 0x0d, 0x0e, 0x0f};
1249 static struct rte_hash_parameters hash_params_ex = {
1250         .name = NULL,
1251         .entries = 64,
1252         .key_len = 0,
1253         .hash_func = NULL,
1254         .hash_func_init_val = 0,
1255         .socket_id = 0,
1256 };
1257
1258 /*
1259  * add/delete key with jhash2
1260  */
1261 static int
1262 test_hash_add_delete_jhash2(void)
1263 {
1264         int ret = -1;
1265         struct rte_hash *handle;
1266         int32_t pos1, pos2;
1267
1268         hash_params_ex.name = "hash_test_jhash2";
1269         hash_params_ex.key_len = 4;
1270         hash_params_ex.hash_func = (rte_hash_function)rte_jhash_32b;
1271
1272         handle = rte_hash_create(&hash_params_ex);
1273         if (handle == NULL) {
1274                 printf("test_hash_add_delete_jhash2 fail to create hash\n");
1275                 goto fail_jhash2;
1276         }
1277         pos1 = rte_hash_add_key(handle, (void *)&key[0]);
1278         if (pos1 < 0) {
1279                 printf("test_hash_add_delete_jhash2 fail to add hash key\n");
1280                 goto fail_jhash2;
1281         }
1282
1283         pos2 = rte_hash_del_key(handle, (void *)&key[0]);
1284         if (pos2 < 0 || pos1 != pos2) {
1285                 printf("test_hash_add_delete_jhash2 delete different key from being added\n");
1286                 goto fail_jhash2;
1287         }
1288         ret = 0;
1289
1290 fail_jhash2:
1291         if (handle != NULL)
1292                 rte_hash_free(handle);
1293
1294         return ret;
1295 }
1296
1297 /*
1298  * add/delete (2) key with jhash2
1299  */
1300 static int
1301 test_hash_add_delete_2_jhash2(void)
1302 {
1303         int ret = -1;
1304         struct rte_hash *handle;
1305         int32_t pos1, pos2;
1306
1307         hash_params_ex.name = "hash_test_2_jhash2";
1308         hash_params_ex.key_len = 8;
1309         hash_params_ex.hash_func = (rte_hash_function)rte_jhash_32b;
1310
1311         handle = rte_hash_create(&hash_params_ex);
1312         if (handle == NULL)
1313                 goto fail_2_jhash2;
1314
1315         pos1 = rte_hash_add_key(handle, (void *)&key[0]);
1316         if (pos1 < 0)
1317                 goto fail_2_jhash2;
1318
1319         pos2 = rte_hash_del_key(handle, (void *)&key[0]);
1320         if (pos2 < 0 || pos1 != pos2)
1321                 goto fail_2_jhash2;
1322
1323         ret = 0;
1324
1325 fail_2_jhash2:
1326         if (handle != NULL)
1327                 rte_hash_free(handle);
1328
1329         return ret;
1330 }
1331
1332 static uint32_t
1333 test_hash_jhash_1word(const void *key, uint32_t length, uint32_t initval)
1334 {
1335         const uint32_t *k = key;
1336
1337         RTE_SET_USED(length);
1338
1339         return rte_jhash_1word(k[0], initval);
1340 }
1341
1342 static uint32_t
1343 test_hash_jhash_2word(const void *key, uint32_t length, uint32_t initval)
1344 {
1345         const uint32_t *k = key;
1346
1347         RTE_SET_USED(length);
1348
1349         return rte_jhash_2words(k[0], k[1], initval);
1350 }
1351
1352 static uint32_t
1353 test_hash_jhash_3word(const void *key, uint32_t length, uint32_t initval)
1354 {
1355         const uint32_t *k = key;
1356
1357         RTE_SET_USED(length);
1358
1359         return rte_jhash_3words(k[0], k[1], k[2], initval);
1360 }
1361
1362 /*
1363  * add/delete key with jhash 1word
1364  */
1365 static int
1366 test_hash_add_delete_jhash_1word(void)
1367 {
1368         int ret = -1;
1369         struct rte_hash *handle;
1370         int32_t pos1, pos2;
1371
1372         hash_params_ex.name = "hash_test_jhash_1word";
1373         hash_params_ex.key_len = 4;
1374         hash_params_ex.hash_func = test_hash_jhash_1word;
1375
1376         handle = rte_hash_create(&hash_params_ex);
1377         if (handle == NULL)
1378                 goto fail_jhash_1word;
1379
1380         pos1 = rte_hash_add_key(handle, (void *)&key[0]);
1381         if (pos1 < 0)
1382                 goto fail_jhash_1word;
1383
1384         pos2 = rte_hash_del_key(handle, (void *)&key[0]);
1385         if (pos2 < 0 || pos1 != pos2)
1386                 goto fail_jhash_1word;
1387
1388         ret = 0;
1389
1390 fail_jhash_1word:
1391         if (handle != NULL)
1392                 rte_hash_free(handle);
1393
1394         return ret;
1395 }
1396
1397 /*
1398  * add/delete key with jhash 2word
1399  */
1400 static int
1401 test_hash_add_delete_jhash_2word(void)
1402 {
1403         int ret = -1;
1404         struct rte_hash *handle;
1405         int32_t pos1, pos2;
1406
1407         hash_params_ex.name = "hash_test_jhash_2word";
1408         hash_params_ex.key_len = 8;
1409         hash_params_ex.hash_func = test_hash_jhash_2word;
1410
1411         handle = rte_hash_create(&hash_params_ex);
1412         if (handle == NULL)
1413                 goto fail_jhash_2word;
1414
1415         pos1 = rte_hash_add_key(handle, (void *)&key[0]);
1416         if (pos1 < 0)
1417                 goto fail_jhash_2word;
1418
1419         pos2 = rte_hash_del_key(handle, (void *)&key[0]);
1420         if (pos2 < 0 || pos1 != pos2)
1421                 goto fail_jhash_2word;
1422
1423         ret = 0;
1424
1425 fail_jhash_2word:
1426         if (handle != NULL)
1427                 rte_hash_free(handle);
1428
1429         return ret;
1430 }
1431
1432 /*
1433  * add/delete key with jhash 3word
1434  */
1435 static int
1436 test_hash_add_delete_jhash_3word(void)
1437 {
1438         int ret = -1;
1439         struct rte_hash *handle;
1440         int32_t pos1, pos2;
1441
1442         hash_params_ex.name = "hash_test_jhash_3word";
1443         hash_params_ex.key_len = 12;
1444         hash_params_ex.hash_func = test_hash_jhash_3word;
1445
1446         handle = rte_hash_create(&hash_params_ex);
1447         if (handle == NULL)
1448                 goto fail_jhash_3word;
1449
1450         pos1 = rte_hash_add_key(handle, (void *)&key[0]);
1451         if (pos1 < 0)
1452                 goto fail_jhash_3word;
1453
1454         pos2 = rte_hash_del_key(handle, (void *)&key[0]);
1455         if (pos2 < 0 || pos1 != pos2)
1456                 goto fail_jhash_3word;
1457
1458         ret = 0;
1459
1460 fail_jhash_3word:
1461         if (handle != NULL)
1462                 rte_hash_free(handle);
1463
1464         return ret;
1465 }
1466
1467 /*
1468  * Do all unit and performance tests.
1469  */
1470 static int
1471 test_hash(void)
1472 {
1473         if (test_add_delete() < 0)
1474                 return -1;
1475         if (test_hash_add_delete_jhash2() < 0)
1476                 return -1;
1477         if (test_hash_add_delete_2_jhash2() < 0)
1478                 return -1;
1479         if (test_hash_add_delete_jhash_1word() < 0)
1480                 return -1;
1481         if (test_hash_add_delete_jhash_2word() < 0)
1482                 return -1;
1483         if (test_hash_add_delete_jhash_3word() < 0)
1484                 return -1;
1485         if (test_hash_get_key_with_position() < 0)
1486                 return -1;
1487         if (test_hash_find_existing() < 0)
1488                 return -1;
1489         if (test_add_update_delete() < 0)
1490                 return -1;
1491         if (test_five_keys() < 0)
1492                 return -1;
1493         if (test_full_bucket() < 0)
1494                 return -1;
1495
1496         if (test_fbk_hash_find_existing() < 0)
1497                 return -1;
1498         if (fbk_hash_unit_test() < 0)
1499                 return -1;
1500         if (test_hash_creation_with_bad_parameters() < 0)
1501                 return -1;
1502         if (test_hash_creation_with_good_parameters() < 0)
1503                 return -1;
1504         if (test_average_table_utilization() < 0)
1505                 return -1;
1506         if (test_hash_iteration() < 0)
1507                 return -1;
1508
1509         run_hash_func_tests();
1510
1511         if (test_crc32_hash_alg_equiv() < 0)
1512                 return -1;
1513
1514         return 0;
1515 }
1516
1517 REGISTER_TEST_COMMAND(hash_autotest, test_hash);