app/test/test_hash.c

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