app/test/test_hash_perf.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2015 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <inttypes.h>
   7
   8 #include <rte_lcore.h>
   9 #include <rte_cycles.h>
  10 #include <rte_malloc.h>
  11 #include <rte_hash.h>
  12 #include <rte_hash_crc.h>
  13 #include <rte_jhash.h>
  14 #include <rte_fbk_hash.h>
  15 #include <rte_random.h>
  16 #include <rte_string_fns.h>
  17
  18 #include "test.h"
  19
  20 #define MAX_ENTRIES (1 << 19)
  21 #define KEYS_TO_ADD (MAX_ENTRIES)
  22 #define ADD_PERCENT 0.75 /* 75% table utilization */
  23 #define NUM_LOOKUPS (KEYS_TO_ADD * 5) /* Loop among keys added, several times */
  24 /* BUCKET_SIZE should be same as RTE_HASH_BUCKET_ENTRIES in rte_hash library */
  25 #define BUCKET_SIZE 8
  26 #define NUM_BUCKETS (MAX_ENTRIES / BUCKET_SIZE)
  27 #define MAX_KEYSIZE 64
  28 #define NUM_KEYSIZES 10
  29 #define NUM_SHUFFLES 10
  30 #define BURST_SIZE 16
  31
  32 enum operations {
  33         OP_ADD = 0,
  34         OP_LOOKUP,
  35         OP_LOOKUP_MULTI,
  36         OP_DELETE,
  37         NUM_OPERATIONS
  38 };
  39
  40 static uint32_t hashtest_key_lens[] = {
  41         /* standard key sizes */
  42         4, 8, 16, 32, 48, 64,
  43         /* IPv4 SRC + DST + protocol, unpadded */
  44         9,
  45         /* IPv4 5-tuple, unpadded */
  46         13,
  47         /* IPv6 5-tuple, unpadded */
  48         37,
  49         /* IPv6 5-tuple, padded to 8-byte boundary */
  50         40
  51 };
  52
  53 struct rte_hash *h[NUM_KEYSIZES];
  54
  55 /* Array that stores if a slot is full */
  56 static uint8_t slot_taken[MAX_ENTRIES];
  57
  58 /* Array to store number of cycles per operation */
  59 static uint64_t cycles[NUM_KEYSIZES][NUM_OPERATIONS][2][2];
  60
  61 /* Array to store all input keys */
  62 static uint8_t keys[KEYS_TO_ADD][MAX_KEYSIZE];
  63
  64 /* Array to store the precomputed hash for 'keys' */
  65 static hash_sig_t signatures[KEYS_TO_ADD];
  66
  67 /* Array to store how many busy entries have each bucket */
  68 static uint8_t buckets[NUM_BUCKETS];
  69
  70 /* Array to store the positions where keys are added */
  71 static int32_t positions[KEYS_TO_ADD];
  72
  73 /* Parameters used for hash table in unit test functions. */
  74 static struct rte_hash_parameters ut_params = {
  75         .entries = MAX_ENTRIES,
  76         .hash_func = rte_jhash,
  77         .hash_func_init_val = 0,
  78 };
  79
  80 static int
  81 create_table(unsigned int with_data, unsigned int table_index,
  82                 unsigned int with_locks, unsigned int ext)
  83 {
  84         char name[RTE_HASH_NAMESIZE];
  85
  86         if (with_data)
  87                 /* Table will store 8-byte data */
  88                 snprintf(name, sizeof(name), "test_hash%u_data",
  89                                 hashtest_key_lens[table_index]);
  90         else
  91                 snprintf(name, sizeof(name), "test_hash%u",
  92                                 hashtest_key_lens[table_index]);
  93
  94
  95         if (with_locks)
  96                 ut_params.extra_flag =
  97                         RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT
  98                                 | RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY;
  99         else
 100                 ut_params.extra_flag = 0;
 101
 102         if (ext)
 103                 ut_params.extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
 104
 105         ut_params.name = name;
 106         ut_params.key_len = hashtest_key_lens[table_index];
 107         ut_params.socket_id = rte_socket_id();
 108         h[table_index] = rte_hash_find_existing(name);
 109         rte_hash_free(h[table_index]);
 110         h[table_index] = rte_hash_create(&ut_params);
 111         if (h[table_index] == NULL) {
 112                 printf("Error creating table\n");
 113                 return -1;
 114         }
 115         return 0;
 116
 117 }
 118
 119 /* Shuffle the keys that have been added, so lookups will be totally random */
 120 static void
 121 shuffle_input_keys(unsigned int table_index, unsigned int ext)
 122 {
 123         unsigned i;
 124         uint32_t swap_idx;
 125         uint8_t temp_key[MAX_KEYSIZE];
 126         hash_sig_t temp_signature;
 127         int32_t temp_position;
 128         unsigned int keys_to_add;
 129
 130         if (!ext)
 131                 keys_to_add = KEYS_TO_ADD * ADD_PERCENT;
 132         else
 133                 keys_to_add = KEYS_TO_ADD;
 134
 135         for (i = keys_to_add - 1; i > 0; i--) {
 136                 swap_idx = rte_rand() % i;
 137
 138                 memcpy(temp_key, keys[i], hashtest_key_lens[table_index]);
 139                 temp_signature = signatures[i];
 140                 temp_position = positions[i];
 141
 142                 memcpy(keys[i], keys[swap_idx], hashtest_key_lens[table_index]);
 143                 signatures[i] = signatures[swap_idx];
 144                 positions[i] = positions[swap_idx];
 145
 146                 memcpy(keys[swap_idx], temp_key, hashtest_key_lens[table_index]);
 147                 signatures[swap_idx] = temp_signature;
 148                 positions[swap_idx] = temp_position;
 149         }
 150 }
 151
 152 /*
 153  * Looks for random keys which
 154  * ALL can fit in hash table (no errors)
 155  */
 156 static int
 157 get_input_keys(unsigned int with_pushes, unsigned int table_index,
 158                                                         unsigned int ext)
 159 {
 160         unsigned i, j;
 161         unsigned bucket_idx, incr, success = 1;
 162         uint8_t k = 0;
 163         int32_t ret;
 164         const uint32_t bucket_bitmask = NUM_BUCKETS - 1;
 165         unsigned int keys_to_add;
 166
 167         if (!ext)
 168                 keys_to_add = KEYS_TO_ADD * ADD_PERCENT;
 169         else
 170                 keys_to_add = KEYS_TO_ADD;
 171         /* Reset all arrays */
 172         for (i = 0; i < MAX_ENTRIES; i++)
 173                 slot_taken[i] = 0;
 174
 175         for (i = 0; i < NUM_BUCKETS; i++)
 176                 buckets[i] = 0;
 177
 178         for (j = 0; j < hashtest_key_lens[table_index]; j++)
 179                 keys[0][j] = 0;
 180
 181         /*
 182          * Add only entries that are not duplicated and that fits in the table
 183          * (cannot store more than BUCKET_SIZE entries in a bucket).
 184          * Regardless a key has been added correctly or not (success),
 185          * the next one to try will be increased by 1.
 186          */
 187         for (i = 0; i < keys_to_add;) {
 188                 incr = 0;
 189                 if (i != 0) {
 190                         keys[i][0] = ++k;
 191                         /* Overflow, need to increment the next byte */
 192                         if (keys[i][0] == 0)
 193                                 incr = 1;
 194                         for (j = 1; j < hashtest_key_lens[table_index]; j++) {
 195                                 /* Do not increase next byte */
 196                                 if (incr == 0)
 197                                         if (success == 1)
 198                                                 keys[i][j] = keys[i - 1][j];
 199                                         else
 200                                                 keys[i][j] = keys[i][j];
 201                                 /* Increase next byte by one */
 202                                 else {
 203                                         if (success == 1)
 204                                                 keys[i][j] = keys[i-1][j] + 1;
 205                                         else
 206                                                 keys[i][j] = keys[i][j] + 1;
 207                                         if (keys[i][j] == 0)
 208                                                 incr = 1;
 209                                         else
 210                                                 incr = 0;
 211                                 }
 212                         }
 213                 }
 214                 success = 0;
 215                 signatures[i] = rte_hash_hash(h[table_index], keys[i]);
 216                 bucket_idx = signatures[i] & bucket_bitmask;
 217                 /*
 218                  * If we are not inserting keys in secondary location,
 219                  * when bucket is full, do not try to insert the key
 220                  */
 221                 if (with_pushes == 0)
 222                         if (buckets[bucket_idx] == BUCKET_SIZE)
 223                                 continue;
 224
 225                 /* If key can be added, leave in successful key arrays "keys" */
 226                 ret = rte_hash_add_key_with_hash(h[table_index], keys[i],
 227                                                 signatures[i]);
 228                 if (ret >= 0) {
 229                         /* If key is already added, ignore the entry and do not store */
 230                         if (slot_taken[ret])
 231                                 continue;
 232                         else {
 233                                 /* Store the returned position and mark slot as taken */
 234                                 slot_taken[ret] = 1;
 235                                 positions[i] = ret;
 236                                 buckets[bucket_idx]++;
 237                                 success = 1;
 238                                 i++;
 239                         }
 240                 }
 241         }
 242
 243         /* Reset the table, so we can measure the time to add all the entries */
 244         rte_hash_free(h[table_index]);
 245         h[table_index] = rte_hash_create(&ut_params);
 246
 247         return 0;
 248 }
 249
 250 static int
 251 timed_adds(unsigned int with_hash, unsigned int with_data,
 252                                 unsigned int table_index, unsigned int ext)
 253 {
 254         unsigned i;
 255         const uint64_t start_tsc = rte_rdtsc();
 256         void *data;
 257         int32_t ret;
 258         unsigned int keys_to_add;
 259         if (!ext)
 260                 keys_to_add = KEYS_TO_ADD * ADD_PERCENT;
 261         else
 262                 keys_to_add = KEYS_TO_ADD;
 263
 264         for (i = 0; i < keys_to_add; i++) {
 265                 data = (void *) ((uintptr_t) signatures[i]);
 266                 if (with_hash && with_data) {
 267                         ret = rte_hash_add_key_with_hash_data(h[table_index],
 268                                                 (const void *) keys[i],
 269                                                 signatures[i], data);
 270                         if (ret < 0) {
 271                                 printf("H+D: Failed to add key number %u\n", i);
 272                                 return -1;
 273                         }
 274                 } else if (with_hash && !with_data) {
 275                         ret = rte_hash_add_key_with_hash(h[table_index],
 276                                                 (const void *) keys[i],
 277                                                 signatures[i]);
 278                         if (ret >= 0)
 279                                 positions[i] = ret;
 280                         else {
 281                                 printf("H: Failed to add key number %u\n", i);
 282                                 return -1;
 283                         }
 284                 } else if (!with_hash && with_data) {
 285                         ret = rte_hash_add_key_data(h[table_index],
 286                                                 (const void *) keys[i],
 287                                                 data);
 288                         if (ret < 0) {
 289                                 printf("D: Failed to add key number %u\n", i);
 290                                 return -1;
 291                         }
 292                 } else {
 293                         ret = rte_hash_add_key(h[table_index], keys[i]);
 294                         if (ret >= 0)
 295                                 positions[i] = ret;
 296                         else {
 297                                 printf("Failed to add key number %u\n", i);
 298                                 return -1;
 299                         }
 300                 }
 301         }
 302
 303         const uint64_t end_tsc = rte_rdtsc();
 304         const uint64_t time_taken = end_tsc - start_tsc;
 305
 306         cycles[table_index][OP_ADD][with_hash][with_data] = time_taken/keys_to_add;
 307
 308         return 0;
 309 }
 310
 311 static int
 312 timed_lookups(unsigned int with_hash, unsigned int with_data,
 313                                 unsigned int table_index, unsigned int ext)
 314 {
 315         unsigned i, j;
 316         const uint64_t start_tsc = rte_rdtsc();
 317         void *ret_data;
 318         void *expected_data;
 319         int32_t ret;
 320         unsigned int keys_to_add, num_lookups;
 321
 322         if (!ext) {
 323                 keys_to_add = KEYS_TO_ADD * ADD_PERCENT;
 324                 num_lookups = NUM_LOOKUPS * ADD_PERCENT;
 325         } else {
 326                 keys_to_add = KEYS_TO_ADD;
 327                 num_lookups = NUM_LOOKUPS;
 328         }
 329         for (i = 0; i < num_lookups / keys_to_add; i++) {
 330                 for (j = 0; j < keys_to_add; j++) {
 331                         if (with_hash && with_data) {
 332                                 ret = rte_hash_lookup_with_hash_data(h[table_index],
 333                                                         (const void *) keys[j],
 334                                                         signatures[j], &ret_data);
 335                                 if (ret < 0) {
 336                                         printf("Key number %u was not found\n", j);
 337                                         return -1;
 338                                 }
 339                                 expected_data = (void *) ((uintptr_t) signatures[j]);
 340                                 if (ret_data != expected_data) {
 341                                         printf("Data returned for key number %u is %p,"
 342                                                " but should be %p\n", j, ret_data,
 343                                                 expected_data);
 344                                         return -1;
 345                                 }
 346                         } else if (with_hash && !with_data) {
 347                                 ret = rte_hash_lookup_with_hash(h[table_index],
 348                                                         (const void *) keys[j],
 349                                                         signatures[j]);
 350                                 if (ret < 0 || ret != positions[j]) {
 351                                         printf("Key looked up in %d, should be in %d\n",
 352                                                 ret, positions[j]);
 353                                         return -1;
 354                                 }
 355                         } else if (!with_hash && with_data) {
 356                                 ret = rte_hash_lookup_data(h[table_index],
 357                                                         (const void *) keys[j], &ret_data);
 358                                 if (ret < 0) {
 359                                         printf("Key number %u was not found\n", j);
 360                                         return -1;
 361                                 }
 362                                 expected_data = (void *) ((uintptr_t) signatures[j]);
 363                                 if (ret_data != expected_data) {
 364                                         printf("Data returned for key number %u is %p,"
 365                                                " but should be %p\n", j, ret_data,
 366                                                 expected_data);
 367                                         return -1;
 368                                 }
 369                         } else {
 370                                 ret = rte_hash_lookup(h[table_index], keys[j]);
 371                                 if (ret < 0 || ret != positions[j]) {
 372                                         printf("Key looked up in %d, should be in %d\n",
 373                                                 ret, positions[j]);
 374                                         return -1;
 375                                 }
 376                         }
 377                 }
 378         }
 379
 380         const uint64_t end_tsc = rte_rdtsc();
 381         const uint64_t time_taken = end_tsc - start_tsc;
 382
 383         cycles[table_index][OP_LOOKUP][with_hash][with_data] = time_taken/num_lookups;
 384
 385         return 0;
 386 }
 387
 388 static int
 389 timed_lookups_multi(unsigned int with_hash, unsigned int with_data,
 390                 unsigned int table_index, unsigned int ext)
 391 {
 392         unsigned i, j, k;
 393         int32_t positions_burst[BURST_SIZE];
 394         const void *keys_burst[BURST_SIZE];
 395         void *expected_data[BURST_SIZE];
 396         void *ret_data[BURST_SIZE];
 397         uint64_t hit_mask;
 398         int ret;
 399         unsigned int keys_to_add, num_lookups;
 400
 401         if (!ext) {
 402                 keys_to_add = KEYS_TO_ADD * ADD_PERCENT;
 403                 num_lookups = NUM_LOOKUPS * ADD_PERCENT;
 404         } else {
 405                 keys_to_add = KEYS_TO_ADD;
 406                 num_lookups = NUM_LOOKUPS;
 407         }
 408
 409         const uint64_t start_tsc = rte_rdtsc();
 410
 411         for (i = 0; i < num_lookups/keys_to_add; i++) {
 412                 for (j = 0; j < keys_to_add/BURST_SIZE; j++) {
 413                         for (k = 0; k < BURST_SIZE; k++)
 414                                 keys_burst[k] = keys[j * BURST_SIZE + k];
 415                         if (!with_hash && with_data) {
 416                                 ret = rte_hash_lookup_bulk_data(h[table_index],
 417                                         (const void **) keys_burst,
 418                                         BURST_SIZE,
 419                                         &hit_mask,
 420                                         ret_data);
 421                                 if (ret != BURST_SIZE) {
 422                                         printf("Expect to find %u keys,"
 423                                                " but found %d\n", BURST_SIZE, ret);
 424                                         return -1;
 425                                 }
 426                                 for (k = 0; k < BURST_SIZE; k++) {
 427                                         if ((hit_mask & (1ULL << k))  == 0) {
 428                                                 printf("Key number %u not found\n",
 429                                                         j * BURST_SIZE + k);
 430                                                 return -1;
 431                                         }
 432                                         expected_data[k] = (void *) ((uintptr_t) signatures[j * BURST_SIZE + k]);
 433                                         if (ret_data[k] != expected_data[k]) {
 434                                                 printf("Data returned for key number %u is %p,"
 435                                                        " but should be %p\n", j * BURST_SIZE + k,
 436                                                         ret_data[k], expected_data[k]);
 437                                                 return -1;
 438                                         }
 439                                 }
 440                         } else if (with_hash && with_data) {
 441                                 ret = rte_hash_lookup_with_hash_bulk_data(
 442                                         h[table_index],
 443                                         (const void **)keys_burst,
 444                                         &signatures[j * BURST_SIZE],
 445                                         BURST_SIZE, &hit_mask, ret_data);
 446                                 if (ret != BURST_SIZE) {
 447                                         printf("Expect to find %u keys,"
 448                                                " but found %d\n",
 449                                                 BURST_SIZE, ret);
 450                                         return -1;
 451                                 }
 452                                 for (k = 0; k < BURST_SIZE; k++) {
 453                                         if ((hit_mask & (1ULL << k))  == 0) {
 454                                                 printf("Key number %u"
 455                                                         " not found\n",
 456                                                         j * BURST_SIZE + k);
 457                                                 return -1;
 458                                         }
 459                                         expected_data[k] =
 460                                                 (void *)((uintptr_t)signatures[
 461                                                 j * BURST_SIZE + k]);
 462                                         if (ret_data[k] != expected_data[k]) {
 463                                                 printf("Data returned for key"
 464                                                         " number %u is %p,"
 465                                                         " but should be %p\n",
 466                                                         j * BURST_SIZE + k,
 467                                                         ret_data[k],
 468                                                         expected_data[k]);
 469                                                 return -1;
 470                                         }
 471                                 }
 472                         } else if (with_hash && !with_data) {
 473                                 ret = rte_hash_lookup_with_hash_bulk(
 474                                         h[table_index],
 475                                         (const void **)keys_burst,
 476                                         &signatures[j * BURST_SIZE],
 477                                         BURST_SIZE, positions_burst);
 478                                 for (k = 0; k < BURST_SIZE; k++) {
 479                                         if (positions_burst[k] !=
 480                                                         positions[j *
 481                                                         BURST_SIZE + k]) {
 482                                                 printf("Key looked up in %d, should be in %d\n",
 483                                                         positions_burst[k],
 484                                                         positions[j *
 485                                                         BURST_SIZE + k]);
 486                                                 return -1;
 487                                         }
 488                                 }
 489                         } else {
 490                                 rte_hash_lookup_bulk(h[table_index],
 491                                                 (const void **) keys_burst,
 492                                                 BURST_SIZE,
 493                                                 positions_burst);
 494                                 for (k = 0; k < BURST_SIZE; k++) {
 495                                         if (positions_burst[k] != positions[j * BURST_SIZE + k]) {
 496                                                 printf("Key looked up in %d, should be in %d\n",
 497                                                         positions_burst[k],
 498                                                         positions[j * BURST_SIZE + k]);
 499                                                 return -1;
 500                                         }
 501                                 }
 502                         }
 503                 }
 504         }
 505
 506         const uint64_t end_tsc = rte_rdtsc();
 507         const uint64_t time_taken = end_tsc - start_tsc;
 508
 509         cycles[table_index][OP_LOOKUP_MULTI][with_hash][with_data] =
 510                 time_taken/num_lookups;
 511
 512         return 0;
 513 }
 514
 515 static int
 516 timed_deletes(unsigned int with_hash, unsigned int with_data,
 517                                 unsigned int table_index, unsigned int ext)
 518 {
 519         unsigned i;
 520         const uint64_t start_tsc = rte_rdtsc();
 521         int32_t ret;
 522         unsigned int keys_to_add;
 523         if (!ext)
 524                 keys_to_add = KEYS_TO_ADD * ADD_PERCENT;
 525         else
 526                 keys_to_add = KEYS_TO_ADD;
 527
 528         for (i = 0; i < keys_to_add; i++) {
 529                 /* There are no delete functions with data, so just call two functions */
 530                 if (with_hash)
 531                         ret = rte_hash_del_key_with_hash(h[table_index],
 532                                                         (const void *) keys[i],
 533                                                         signatures[i]);
 534                 else
 535                         ret = rte_hash_del_key(h[table_index],
 536                                                         (const void *) keys[i]);
 537                 if (ret >= 0)
 538                         positions[i] = ret;
 539                 else {
 540                         printf("Failed to delete key number %u\n", i);
 541                         return -1;
 542                 }
 543         }
 544
 545         const uint64_t end_tsc = rte_rdtsc();
 546         const uint64_t time_taken = end_tsc - start_tsc;
 547
 548         cycles[table_index][OP_DELETE][with_hash][with_data] = time_taken/keys_to_add;
 549
 550         return 0;
 551 }
 552
 553 static void
 554 free_table(unsigned table_index)
 555 {
 556         rte_hash_free(h[table_index]);
 557 }
 558
 559 static void
 560 reset_table(unsigned table_index)
 561 {
 562         rte_hash_reset(h[table_index]);
 563 }
 564
 565 static int
 566 run_all_tbl_perf_tests(unsigned int with_pushes, unsigned int with_locks,
 567                                                 unsigned int ext)
 568 {
 569         unsigned i, j, with_data, with_hash;
 570
 571         printf("Measuring performance, please wait");
 572         fflush(stdout);
 573
 574         for (with_data = 0; with_data <= 1; with_data++) {
 575                 for (i = 0; i < NUM_KEYSIZES; i++) {
 576                         if (create_table(with_data, i, with_locks, ext) < 0)
 577                                 return -1;
 578
 579                         if (get_input_keys(with_pushes, i, ext) < 0)
 580                                 return -1;
 581                         for (with_hash = 0; with_hash <= 1; with_hash++) {
 582                                 if (timed_adds(with_hash, with_data, i, ext) < 0)
 583                                         return -1;
 584
 585                                 for (j = 0; j < NUM_SHUFFLES; j++)
 586                                         shuffle_input_keys(i, ext);
 587
 588                                 if (timed_lookups(with_hash, with_data, i, ext) < 0)
 589                                         return -1;
 590
 591                                 if (timed_lookups_multi(with_hash, with_data,
 592                                                 i, ext) < 0)
 593                                         return -1;
 594
 595                                 if (timed_deletes(with_hash, with_data, i, ext) < 0)
 596                                         return -1;
 597
 598                                 /* Print a dot to show progress on operations */
 599                                 printf(".");
 600                                 fflush(stdout);
 601
 602                                 reset_table(i);
 603                         }
 604                         free_table(i);
 605                 }
 606         }
 607
 608         printf("\nResults (in CPU cycles/operation)\n");
 609         printf("-----------------------------------\n");
 610         for (with_data = 0; with_data <= 1; with_data++) {
 611                 if (with_data)
 612                         printf("\n Operations with 8-byte data\n");
 613                 else
 614                         printf("\n Operations without data\n");
 615                 for (with_hash = 0; with_hash <= 1; with_hash++) {
 616                         if (with_hash)
 617                                 printf("\nWith pre-computed hash values\n");
 618                         else
 619                                 printf("\nWithout pre-computed hash values\n");
 620
 621                         printf("\n%-18s%-18s%-18s%-18s%-18s\n",
 622                         "Keysize", "Add", "Lookup", "Lookup_bulk", "Delete");
 623                         for (i = 0; i < NUM_KEYSIZES; i++) {
 624                                 printf("%-18d", hashtest_key_lens[i]);
 625                                 for (j = 0; j < NUM_OPERATIONS; j++)
 626                                         printf("%-18"PRIu64, cycles[i][j][with_hash][with_data]);
 627                                 printf("\n");
 628                         }
 629                 }
 630         }
 631         return 0;
 632 }
 633
 634 /* Control operation of performance testing of fbk hash. */
 635 #define LOAD_FACTOR 0.667       /* How full to make the hash table. */
 636 #define TEST_SIZE 1000000       /* How many operations to time. */
 637 #define TEST_ITERATIONS 30      /* How many measurements to take. */
 638 #define ENTRIES (1 << 15)       /* How many entries. */
 639
 640 static int
 641 fbk_hash_perf_test(void)
 642 {
 643         struct rte_fbk_hash_params params = {
 644                 .name = "fbk_hash_test",
 645                 .entries = ENTRIES,
 646                 .entries_per_bucket = 4,
 647                 .socket_id = rte_socket_id(),
 648         };
 649         struct rte_fbk_hash_table *handle = NULL;
 650         uint32_t *keys = NULL;
 651         unsigned indexes[TEST_SIZE];
 652         uint64_t lookup_time = 0;
 653         unsigned added = 0;
 654         unsigned value = 0;
 655         uint32_t key;
 656         uint16_t val;
 657         unsigned i, j;
 658
 659         handle = rte_fbk_hash_create(&params);
 660         if (handle == NULL) {
 661                 printf("Error creating table\n");
 662                 return -1;
 663         }
 664
 665         keys = rte_zmalloc(NULL, ENTRIES * sizeof(*keys), 0);
 666         if (keys == NULL) {
 667                 printf("fbk hash: memory allocation for key store failed\n");
 668                 return -1;
 669         }
 670
 671         /* Generate random keys and values. */
 672         for (i = 0; i < ENTRIES; i++) {
 673                 key = (uint32_t)rte_rand();
 674                 key = ((uint64_t)key << 32) | (uint64_t)rte_rand();
 675                 val = (uint16_t)rte_rand();
 676
 677                 if (rte_fbk_hash_add_key(handle, key, val) == 0) {
 678                         keys[added] = key;
 679                         added++;
 680                 }
 681                 if (added > (LOAD_FACTOR * ENTRIES))
 682                         break;
 683         }
 684
 685         for (i = 0; i < TEST_ITERATIONS; i++) {
 686                 uint64_t begin;
 687                 uint64_t end;
 688
 689                 /* Generate random indexes into keys[] array. */
 690                 for (j = 0; j < TEST_SIZE; j++)
 691                         indexes[j] = rte_rand() % added;
 692
 693                 begin = rte_rdtsc();
 694                 /* Do lookups */
 695                 for (j = 0; j < TEST_SIZE; j++)
 696                         value += rte_fbk_hash_lookup(handle, keys[indexes[j]]);
 697
 698                 end = rte_rdtsc();
 699                 lookup_time += (double)(end - begin);
 700         }
 701
 702         printf("\n\n *** FBK Hash function performance test results ***\n");
 703         /*
 704          * The use of the 'value' variable ensures that the hash lookup is not
 705          * being optimised out by the compiler.
 706          */
 707         if (value != 0)
 708                 printf("Number of ticks per lookup = %g\n",
 709                         (double)lookup_time /
 710                         ((double)TEST_ITERATIONS * (double)TEST_SIZE));
 711
 712         rte_fbk_hash_free(handle);
 713
 714         return 0;
 715 }
 716
 717 static int
 718 test_hash_perf(void)
 719 {
 720         unsigned int with_pushes, with_locks;
 721
 722         if (RTE_EXEC_ENV_IS_WINDOWS)
 723                 return TEST_SKIPPED;
 724
 725         for (with_locks = 0; with_locks <= 1; with_locks++) {
 726                 if (with_locks)
 727                         printf("\nWith locks in the code\n");
 728                 else
 729                         printf("\nWithout locks in the code\n");
 730                 for (with_pushes = 0; with_pushes <= 1; with_pushes++) {
 731                         if (with_pushes == 0)
 732                                 printf("\nALL ELEMENTS IN PRIMARY LOCATION\n");
 733                         else
 734                                 printf("\nELEMENTS IN PRIMARY OR SECONDARY LOCATION\n");
 735                         if (run_all_tbl_perf_tests(with_pushes, with_locks, 0) < 0)
 736                                 return -1;
 737                 }
 738         }
 739
 740         printf("\n EXTENDABLE BUCKETS PERFORMANCE\n");
 741
 742         if (run_all_tbl_perf_tests(1, 0, 1) < 0)
 743                 return -1;
 744
 745         if (fbk_hash_perf_test() < 0)
 746                 return -1;
 747
 748         return 0;
 749 }
 750
 751 REGISTER_TEST_COMMAND(hash_perf_autotest, test_hash_perf);