app/test/test_hash_readwrite.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <inttypes.h>
   6 #include <locale.h>
   7
   8 #include <rte_cycles.h>
   9 #include <rte_hash.h>
  10 #include <rte_hash_crc.h>
  11 #include <rte_jhash.h>
  12 #include <rte_launch.h>
  13 #include <rte_malloc.h>
  14 #include <rte_random.h>
  15 #include <rte_spinlock.h>
  16
  17 #include "test.h"
  18
  19 #define RTE_RWTEST_FAIL 0
  20
  21 #define TOTAL_ENTRY (5*1024*1024)
  22 #define TOTAL_INSERT (4.5*1024*1024)
  23 #define TOTAL_INSERT_EXT (5*1024*1024)
  24
  25 #define NUM_TEST 3
  26 unsigned int core_cnt[NUM_TEST] = {2, 4, 8};
  27
  28 unsigned int worker_core_ids[RTE_MAX_LCORE];
  29 struct perf {
  30         uint32_t single_read;
  31         uint32_t single_write;
  32         uint32_t read_only[NUM_TEST];
  33         uint32_t write_only[NUM_TEST];
  34         uint32_t read_write_r[NUM_TEST];
  35         uint32_t read_write_w[NUM_TEST];
  36 };
  37
  38 static struct perf htm_results, non_htm_results;
  39
  40 struct {
  41         uint32_t *keys;
  42         uint8_t *found;
  43         uint32_t num_insert;
  44         uint32_t rounded_tot_insert;
  45         struct rte_hash *h;
  46 } tbl_rw_test_param;
  47
  48 static rte_atomic64_t gcycles;
  49 static rte_atomic64_t ginsertions;
  50
  51 static rte_atomic64_t gread_cycles;
  52 static rte_atomic64_t gwrite_cycles;
  53
  54 static rte_atomic64_t greads;
  55 static rte_atomic64_t gwrites;
  56
  57 static int
  58 test_hash_readwrite_worker(__rte_unused void *arg)
  59 {
  60         uint64_t i, offset;
  61         uint32_t lcore_id = rte_lcore_id();
  62         uint64_t begin, cycles;
  63         int *ret;
  64
  65         ret = rte_malloc(NULL, sizeof(int) *
  66                                 tbl_rw_test_param.num_insert, 0);
  67         for (i = 0; i < rte_lcore_count(); i++) {
  68                 if (worker_core_ids[i] == lcore_id)
  69                         break;
  70         }
  71         offset = tbl_rw_test_param.num_insert * i;
  72
  73         printf("Core #%d inserting and reading %d: %'"PRId64" - %'"PRId64"\n",
  74                lcore_id, tbl_rw_test_param.num_insert,
  75                offset, offset + tbl_rw_test_param.num_insert - 1);
  76
  77         begin = rte_rdtsc_precise();
  78
  79         for (i = offset; i < offset + tbl_rw_test_param.num_insert; i++) {
  80
  81                 if (rte_hash_lookup(tbl_rw_test_param.h,
  82                                 tbl_rw_test_param.keys + i) > 0)
  83                         break;
  84
  85                 ret[i - offset] = rte_hash_add_key(tbl_rw_test_param.h,
  86                                      tbl_rw_test_param.keys + i);
  87                 if (ret[i - offset] < 0)
  88                         break;
  89
  90                 /* lookup a random key */
  91                 uint32_t rand = rte_rand() % (i + 1 - offset);
  92
  93                 if (rte_hash_lookup(tbl_rw_test_param.h,
  94                                 tbl_rw_test_param.keys + rand) != ret[rand])
  95                         break;
  96
  97
  98                 if (rte_hash_del_key(tbl_rw_test_param.h,
  99                                 tbl_rw_test_param.keys + rand) != ret[rand])
 100                         break;
 101
 102                 ret[rand] = rte_hash_add_key(tbl_rw_test_param.h,
 103                                         tbl_rw_test_param.keys + rand);
 104                 if (ret[rand] < 0)
 105                         break;
 106
 107                 if (rte_hash_lookup(tbl_rw_test_param.h,
 108                         tbl_rw_test_param.keys + rand) != ret[rand])
 109                         break;
 110         }
 111
 112         cycles = rte_rdtsc_precise() - begin;
 113         rte_atomic64_add(&gcycles, cycles);
 114         rte_atomic64_add(&ginsertions, i - offset);
 115
 116         for (; i < offset + tbl_rw_test_param.num_insert; i++)
 117                 tbl_rw_test_param.keys[i] = RTE_RWTEST_FAIL;
 118
 119         rte_free(ret);
 120         return 0;
 121 }
 122
 123 static int
 124 init_params(int use_ext, int use_htm, int rw_lf, int use_jhash)
 125 {
 126         unsigned int i;
 127
 128         uint32_t *keys = NULL;
 129         uint8_t *found = NULL;
 130         struct rte_hash *handle;
 131
 132         struct rte_hash_parameters hash_params = {
 133                 .entries = TOTAL_ENTRY,
 134                 .key_len = sizeof(uint32_t),
 135                 .hash_func_init_val = 0,
 136                 .socket_id = rte_socket_id(),
 137         };
 138         if (use_jhash)
 139                 hash_params.hash_func = rte_jhash;
 140         else
 141                 hash_params.hash_func = rte_hash_crc;
 142
 143         hash_params.extra_flag = RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD;
 144         if (use_htm)
 145                 hash_params.extra_flag |=
 146                         RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT;
 147         if (rw_lf)
 148                 hash_params.extra_flag |=
 149                         RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF;
 150         else
 151                 hash_params.extra_flag |=
 152                         RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY;
 153
 154         if (use_ext)
 155                 hash_params.extra_flag |=
 156                         RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
 157         else
 158                 hash_params.extra_flag &=
 159                        ~RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
 160
 161         hash_params.name = "tests";
 162
 163         handle = rte_hash_create(&hash_params);
 164         if (handle == NULL) {
 165                 printf("hash creation failed");
 166                 return -1;
 167         }
 168
 169         tbl_rw_test_param.h = handle;
 170         keys = rte_malloc(NULL, sizeof(uint32_t) * TOTAL_ENTRY, 0);
 171
 172         if (keys == NULL) {
 173                 printf("RTE_MALLOC failed\n");
 174                 goto err;
 175         }
 176
 177         found = rte_zmalloc(NULL, sizeof(uint8_t) * TOTAL_ENTRY, 0);
 178         if (found == NULL) {
 179                 printf("RTE_ZMALLOC failed\n");
 180                 goto err;
 181         }
 182
 183         tbl_rw_test_param.keys = keys;
 184         tbl_rw_test_param.found = found;
 185
 186         for (i = 0; i < TOTAL_ENTRY; i++)
 187                 keys[i] = i;
 188
 189         return 0;
 190
 191 err:
 192         rte_free(keys);
 193         rte_hash_free(handle);
 194
 195         return -1;
 196 }
 197
 198 static int
 199 test_hash_readwrite_functional(int use_htm, int use_rw_lf, int use_ext)
 200 {
 201         unsigned int i;
 202         const void *next_key;
 203         void *next_data;
 204         uint32_t iter = 0;
 205
 206         uint32_t duplicated_keys = 0;
 207         uint32_t lost_keys = 0;
 208         int use_jhash = 1;
 209         int worker_cnt = rte_lcore_count() - 1;
 210         uint32_t tot_insert = 0;
 211
 212         rte_atomic64_init(&gcycles);
 213         rte_atomic64_clear(&gcycles);
 214
 215         rte_atomic64_init(&ginsertions);
 216         rte_atomic64_clear(&ginsertions);
 217
 218         if (init_params(use_ext, use_htm, use_rw_lf, use_jhash) != 0)
 219                 goto err;
 220
 221         if (use_ext)
 222                 tot_insert = TOTAL_INSERT_EXT;
 223         else
 224                 tot_insert = TOTAL_INSERT;
 225
 226         tbl_rw_test_param.num_insert =
 227                 tot_insert / worker_cnt;
 228
 229         tbl_rw_test_param.rounded_tot_insert =
 230                 tbl_rw_test_param.num_insert * worker_cnt;
 231
 232         printf("\nHTM = %d, RW-LF = %d, EXT-Table = %d\n",
 233                 use_htm, use_rw_lf, use_ext);
 234         printf("++++++++Start function tests:+++++++++\n");
 235
 236         /* Fire all threads. */
 237         rte_eal_mp_remote_launch(test_hash_readwrite_worker,
 238                                  NULL, SKIP_MAIN);
 239         rte_eal_mp_wait_lcore();
 240
 241         while (rte_hash_iterate(tbl_rw_test_param.h, &next_key,
 242                         &next_data, &iter) >= 0) {
 243                 /* Search for the key in the list of keys added .*/
 244                 i = *(const uint32_t *)next_key;
 245                 tbl_rw_test_param.found[i]++;
 246         }
 247
 248         for (i = 0; i < tbl_rw_test_param.rounded_tot_insert; i++) {
 249                 if (tbl_rw_test_param.keys[i] != RTE_RWTEST_FAIL) {
 250                         if (tbl_rw_test_param.found[i] > 1) {
 251                                 duplicated_keys++;
 252                                 break;
 253                         }
 254                         if (tbl_rw_test_param.found[i] == 0) {
 255                                 lost_keys++;
 256                                 printf("key %d is lost\n", i);
 257                                 break;
 258                         }
 259                 }
 260         }
 261
 262         if (duplicated_keys > 0) {
 263                 printf("%d key duplicated\n", duplicated_keys);
 264                 goto err_free;
 265         }
 266
 267         if (lost_keys > 0) {
 268                 printf("%d key lost\n", lost_keys);
 269                 goto err_free;
 270         }
 271
 272         printf("No key corrupted during read-write test.\n");
 273
 274         unsigned long long int cycles_per_insertion =
 275                 rte_atomic64_read(&gcycles) /
 276                 rte_atomic64_read(&ginsertions);
 277
 278         printf("cycles per insertion and lookup: %llu\n", cycles_per_insertion);
 279
 280         rte_free(tbl_rw_test_param.found);
 281         rte_free(tbl_rw_test_param.keys);
 282         rte_hash_free(tbl_rw_test_param.h);
 283         printf("+++++++++Complete function tests+++++++++\n");
 284         return 0;
 285
 286 err_free:
 287         rte_free(tbl_rw_test_param.found);
 288         rte_free(tbl_rw_test_param.keys);
 289         rte_hash_free(tbl_rw_test_param.h);
 290 err:
 291         return -1;
 292 }
 293
 294 static int
 295 test_rw_reader(void *arg)
 296 {
 297         uint64_t i;
 298         uint64_t begin, cycles;
 299         uint64_t read_cnt = (uint64_t)((uintptr_t)arg);
 300
 301         begin = rte_rdtsc_precise();
 302         for (i = 0; i < read_cnt; i++) {
 303                 void *data = arg;
 304                 rte_hash_lookup_data(tbl_rw_test_param.h,
 305                                 tbl_rw_test_param.keys + i,
 306                                 &data);
 307                 if (i != (uint64_t)(uintptr_t)data) {
 308                         printf("lookup find wrong value %"PRIu64","
 309                                 "%"PRIu64"\n", i,
 310                                 (uint64_t)(uintptr_t)data);
 311                         break;
 312                 }
 313         }
 314
 315         cycles = rte_rdtsc_precise() - begin;
 316         rte_atomic64_add(&gread_cycles, cycles);
 317         rte_atomic64_add(&greads, i);
 318         return 0;
 319 }
 320
 321 static int
 322 test_rw_writer(void *arg)
 323 {
 324         uint64_t i;
 325         uint32_t lcore_id = rte_lcore_id();
 326         uint64_t begin, cycles;
 327         int ret;
 328         uint64_t start_coreid = (uint64_t)(uintptr_t)arg;
 329         uint64_t offset;
 330
 331         for (i = 0; i < rte_lcore_count(); i++) {
 332                 if (worker_core_ids[i] == lcore_id)
 333                         break;
 334         }
 335
 336         offset = TOTAL_INSERT / 2 + (i - (start_coreid)) *
 337                                 tbl_rw_test_param.num_insert;
 338         begin = rte_rdtsc_precise();
 339         for (i = offset; i < offset + tbl_rw_test_param.num_insert; i++) {
 340                 ret = rte_hash_add_key_data(tbl_rw_test_param.h,
 341                                 tbl_rw_test_param.keys + i,
 342                                 (void *)((uintptr_t)i));
 343                 if (ret < 0) {
 344                         printf("writer failed %"PRIu64"\n", i);
 345                         break;
 346                 }
 347         }
 348
 349         cycles = rte_rdtsc_precise() - begin;
 350         rte_atomic64_add(&gwrite_cycles, cycles);
 351         rte_atomic64_add(&gwrites, tbl_rw_test_param.num_insert);
 352         return 0;
 353 }
 354
 355 static int
 356 test_hash_readwrite_perf(struct perf *perf_results, int use_htm,
 357                                                         int reader_faster)
 358 {
 359         unsigned int n;
 360         int ret;
 361         int start_coreid;
 362         uint64_t i, read_cnt;
 363
 364         const void *next_key;
 365         void *next_data;
 366         uint32_t iter;
 367         int use_jhash = 0;
 368
 369         uint32_t duplicated_keys = 0;
 370         uint32_t lost_keys = 0;
 371
 372         uint64_t start = 0, end = 0;
 373
 374         rte_atomic64_init(&greads);
 375         rte_atomic64_init(&gwrites);
 376         rte_atomic64_clear(&gwrites);
 377         rte_atomic64_clear(&greads);
 378
 379         rte_atomic64_init(&gread_cycles);
 380         rte_atomic64_clear(&gread_cycles);
 381         rte_atomic64_init(&gwrite_cycles);
 382         rte_atomic64_clear(&gwrite_cycles);
 383
 384         if (init_params(0, use_htm, 0, use_jhash) != 0)
 385                 goto err;
 386
 387         /*
 388          * Do a readers finish faster or writers finish faster test.
 389          * When readers finish faster, we timing the readers, and when writers
 390          * finish faster, we timing the writers.
 391          * Divided by 10 or 2 is just experimental values to vary the workload
 392          * of readers.
 393          */
 394         if (reader_faster) {
 395                 printf("++++++Start perf test: reader++++++++\n");
 396                 read_cnt = TOTAL_INSERT / 10;
 397         } else {
 398                 printf("++++++Start perf test: writer++++++++\n");
 399                 read_cnt = TOTAL_INSERT / 2;
 400         }
 401
 402         /* We first test single thread performance */
 403         start = rte_rdtsc_precise();
 404         /* Insert half of the keys */
 405         for (i = 0; i < TOTAL_INSERT / 2; i++) {
 406                 ret = rte_hash_add_key_data(tbl_rw_test_param.h,
 407                                      tbl_rw_test_param.keys + i,
 408                                         (void *)((uintptr_t)i));
 409                 if (ret < 0) {
 410                         printf("Failed to insert half of keys\n");
 411                         goto err_free;
 412                 }
 413         }
 414         end = rte_rdtsc_precise() - start;
 415         perf_results->single_write = end / i;
 416
 417         start = rte_rdtsc_precise();
 418
 419         for (i = 0; i < read_cnt; i++) {
 420                 void *data;
 421                 rte_hash_lookup_data(tbl_rw_test_param.h,
 422                                 tbl_rw_test_param.keys + i,
 423                                 &data);
 424                 if (i != (uint64_t)(uintptr_t)data) {
 425                         printf("lookup find wrong value"
 426                                         " %"PRIu64",%"PRIu64"\n", i,
 427                                         (uint64_t)(uintptr_t)data);
 428                         break;
 429                 }
 430         }
 431         end = rte_rdtsc_precise() - start;
 432         perf_results->single_read = end / i;
 433
 434         for (n = 0; n < NUM_TEST; n++) {
 435                 unsigned int tot_worker_lcore = rte_lcore_count() - 1;
 436                 if (tot_worker_lcore < core_cnt[n] * 2)
 437                         goto finish;
 438
 439                 rte_atomic64_clear(&greads);
 440                 rte_atomic64_clear(&gread_cycles);
 441                 rte_atomic64_clear(&gwrites);
 442                 rte_atomic64_clear(&gwrite_cycles);
 443
 444                 rte_hash_reset(tbl_rw_test_param.h);
 445
 446                 tbl_rw_test_param.num_insert = TOTAL_INSERT / 2 / core_cnt[n];
 447                 tbl_rw_test_param.rounded_tot_insert = TOTAL_INSERT / 2 +
 448                                                 tbl_rw_test_param.num_insert *
 449                                                 core_cnt[n];
 450
 451                 for (i = 0; i < TOTAL_INSERT / 2; i++) {
 452                         ret = rte_hash_add_key_data(tbl_rw_test_param.h,
 453                                         tbl_rw_test_param.keys + i,
 454                                         (void *)((uintptr_t)i));
 455                         if (ret < 0) {
 456                                 printf("Failed to insert half of keys\n");
 457                                 goto err_free;
 458                         }
 459                 }
 460
 461                 /* Then test multiple thread case but only all reads or
 462                  * all writes
 463                  */
 464
 465                 /* Test only reader cases */
 466                 for (i = 0; i < core_cnt[n]; i++)
 467                         rte_eal_remote_launch(test_rw_reader,
 468                                         (void *)(uintptr_t)read_cnt,
 469                                         worker_core_ids[i]);
 470
 471                 rte_eal_mp_wait_lcore();
 472
 473                 start_coreid = i;
 474                 /* Test only writer cases */
 475                 for (; i < core_cnt[n] * 2; i++)
 476                         rte_eal_remote_launch(test_rw_writer,
 477                                         (void *)((uintptr_t)start_coreid),
 478                                         worker_core_ids[i]);
 479
 480                 rte_eal_mp_wait_lcore();
 481
 482                 if (reader_faster) {
 483                         unsigned long long int cycles_per_insertion =
 484                                 rte_atomic64_read(&gread_cycles) /
 485                                 rte_atomic64_read(&greads);
 486                         perf_results->read_only[n] = cycles_per_insertion;
 487                         printf("Reader only: cycles per lookup: %llu\n",
 488                                                         cycles_per_insertion);
 489                 }
 490
 491                 else {
 492                         unsigned long long int cycles_per_insertion =
 493                                 rte_atomic64_read(&gwrite_cycles) /
 494                                 rte_atomic64_read(&gwrites);
 495                         perf_results->write_only[n] = cycles_per_insertion;
 496                         printf("Writer only: cycles per writes: %llu\n",
 497                                                         cycles_per_insertion);
 498                 }
 499
 500                 rte_atomic64_clear(&greads);
 501                 rte_atomic64_clear(&gread_cycles);
 502                 rte_atomic64_clear(&gwrites);
 503                 rte_atomic64_clear(&gwrite_cycles);
 504
 505                 rte_hash_reset(tbl_rw_test_param.h);
 506
 507                 for (i = 0; i < TOTAL_INSERT / 2; i++) {
 508                         ret = rte_hash_add_key_data(tbl_rw_test_param.h,
 509                                         tbl_rw_test_param.keys + i,
 510                                         (void *)((uintptr_t)i));
 511                         if (ret < 0) {
 512                                 printf("Failed to insert half of keys\n");
 513                                 goto err_free;
 514                         }
 515                 }
 516
 517                 start_coreid = core_cnt[n];
 518
 519                 if (reader_faster) {
 520                         for (i = core_cnt[n]; i < core_cnt[n] * 2; i++)
 521                                 rte_eal_remote_launch(test_rw_writer,
 522                                         (void *)((uintptr_t)start_coreid),
 523                                         worker_core_ids[i]);
 524                         for (i = 0; i < core_cnt[n]; i++)
 525                                 rte_eal_remote_launch(test_rw_reader,
 526                                         (void *)(uintptr_t)read_cnt,
 527                                         worker_core_ids[i]);
 528                 } else {
 529                         for (i = 0; i < core_cnt[n]; i++)
 530                                 rte_eal_remote_launch(test_rw_reader,
 531                                         (void *)(uintptr_t)read_cnt,
 532                                         worker_core_ids[i]);
 533                         for (; i < core_cnt[n] * 2; i++)
 534                                 rte_eal_remote_launch(test_rw_writer,
 535                                         (void *)((uintptr_t)start_coreid),
 536                                         worker_core_ids[i]);
 537                 }
 538
 539                 rte_eal_mp_wait_lcore();
 540
 541                 iter = 0;
 542                 memset(tbl_rw_test_param.found, 0, TOTAL_ENTRY);
 543                 while (rte_hash_iterate(tbl_rw_test_param.h,
 544                                 &next_key, &next_data, &iter) >= 0) {
 545                         /* Search for the key in the list of keys added .*/
 546                         i = *(const uint32_t *)next_key;
 547                         tbl_rw_test_param.found[i]++;
 548                 }
 549
 550                 for (i = 0; i < tbl_rw_test_param.rounded_tot_insert; i++) {
 551                         if (tbl_rw_test_param.keys[i] != RTE_RWTEST_FAIL) {
 552                                 if (tbl_rw_test_param.found[i] > 1) {
 553                                         duplicated_keys++;
 554                                         break;
 555                                 }
 556                                 if (tbl_rw_test_param.found[i] == 0) {
 557                                         lost_keys++;
 558                                         printf("key %"PRIu64" is lost\n", i);
 559                                         break;
 560                                 }
 561                         }
 562                 }
 563
 564                 if (duplicated_keys > 0) {
 565                         printf("%d key duplicated\n", duplicated_keys);
 566                         goto err_free;
 567                 }
 568
 569                 if (lost_keys > 0) {
 570                         printf("%d key lost\n", lost_keys);
 571                         goto err_free;
 572                 }
 573
 574                 printf("No key corrupted during read-write test.\n");
 575
 576                 if (reader_faster) {
 577                         unsigned long long int cycles_per_insertion =
 578                                 rte_atomic64_read(&gread_cycles) /
 579                                 rte_atomic64_read(&greads);
 580                         perf_results->read_write_r[n] = cycles_per_insertion;
 581                         printf("Read-write cycles per lookup: %llu\n",
 582                                                         cycles_per_insertion);
 583                 }
 584
 585                 else {
 586                         unsigned long long int cycles_per_insertion =
 587                                 rte_atomic64_read(&gwrite_cycles) /
 588                                 rte_atomic64_read(&gwrites);
 589                         perf_results->read_write_w[n] = cycles_per_insertion;
 590                         printf("Read-write cycles per writes: %llu\n",
 591                                                         cycles_per_insertion);
 592                 }
 593         }
 594
 595 finish:
 596         rte_free(tbl_rw_test_param.found);
 597         rte_free(tbl_rw_test_param.keys);
 598         rte_hash_free(tbl_rw_test_param.h);
 599         return 0;
 600
 601 err_free:
 602         rte_free(tbl_rw_test_param.found);
 603         rte_free(tbl_rw_test_param.keys);
 604         rte_hash_free(tbl_rw_test_param.h);
 605
 606 err:
 607         return -1;
 608 }
 609
 610 static int
 611 test_hash_rw_perf_main(void)
 612 {
 613         /*
 614          * Variables used to choose different tests.
 615          * use_htm indicates if hardware transactional memory should be used.
 616          * reader_faster indicates if the reader threads should finish earlier
 617          * than writer threads. This is to timing either reader threads or
 618          * writer threads for performance numbers.
 619          */
 620         int use_htm, reader_faster;
 621         unsigned int i = 0, core_id = 0;
 622
 623         if (rte_lcore_count() < 3) {
 624                 printf("Not enough cores for hash_readwrite_autotest, expecting at least 3\n");
 625                 return TEST_SKIPPED;
 626         }
 627
 628         RTE_LCORE_FOREACH_WORKER(core_id) {
 629                 worker_core_ids[i] = core_id;
 630                 i++;
 631         }
 632
 633         setlocale(LC_NUMERIC, "");
 634
 635         if (rte_tm_supported()) {
 636                 printf("Hardware transactional memory (lock elision) "
 637                         "is supported\n");
 638
 639                 printf("Test read-write with Hardware transactional memory\n");
 640
 641                 use_htm = 1;
 642
 643                 reader_faster = 1;
 644                 if (test_hash_readwrite_perf(&htm_results, use_htm,
 645                                                         reader_faster) < 0)
 646                         return -1;
 647
 648                 reader_faster = 0;
 649                 if (test_hash_readwrite_perf(&htm_results, use_htm,
 650                                                         reader_faster) < 0)
 651                         return -1;
 652         } else {
 653                 printf("Hardware transactional memory (lock elision) "
 654                         "is NOT supported\n");
 655         }
 656
 657         printf("Test read-write without Hardware transactional memory\n");
 658         use_htm = 0;
 659
 660         reader_faster = 1;
 661         if (test_hash_readwrite_perf(&non_htm_results, use_htm,
 662                                                         reader_faster) < 0)
 663                 return -1;
 664         reader_faster = 0;
 665         if (test_hash_readwrite_perf(&non_htm_results, use_htm,
 666                                                         reader_faster) < 0)
 667                 return -1;
 668
 669         printf("================\n");
 670         printf("Results summary:\n");
 671         printf("================\n");
 672
 673         printf("single read: %u\n", htm_results.single_read);
 674         printf("single write: %u\n", htm_results.single_write);
 675         for (i = 0; i < NUM_TEST; i++) {
 676                 printf("+++ core_cnt: %u +++\n", core_cnt[i]);
 677                 printf("HTM:\n");
 678                 printf("  read only: %u\n", htm_results.read_only[i]);
 679                 printf("  write only: %u\n", htm_results.write_only[i]);
 680                 printf("  read-write read: %u\n", htm_results.read_write_r[i]);
 681                 printf("  read-write write: %u\n", htm_results.read_write_w[i]);
 682
 683                 printf("non HTM:\n");
 684                 printf("  read only: %u\n", non_htm_results.read_only[i]);
 685                 printf("  write only: %u\n", non_htm_results.write_only[i]);
 686                 printf("  read-write read: %u\n",
 687                         non_htm_results.read_write_r[i]);
 688                 printf("  read-write write: %u\n",
 689                         non_htm_results.read_write_w[i]);
 690         }
 691
 692         return 0;
 693 }
 694
 695 static int
 696 test_hash_rw_func_main(void)
 697 {
 698         /*
 699          * Variables used to choose different tests.
 700          * use_htm indicates if hardware transactional memory should be used.
 701          * reader_faster indicates if the reader threads should finish earlier
 702          * than writer threads. This is to timing either reader threads or
 703          * writer threads for performance numbers.
 704          */
 705         unsigned int i = 0, core_id = 0;
 706
 707         if (rte_lcore_count() < 3) {
 708                 printf("Not enough cores for hash_readwrite_autotest, expecting at least 3\n");
 709                 return TEST_SKIPPED;
 710         }
 711
 712         RTE_LCORE_FOREACH_WORKER(core_id) {
 713                 worker_core_ids[i] = core_id;
 714                 i++;
 715         }
 716
 717         setlocale(LC_NUMERIC, "");
 718
 719         if (rte_tm_supported()) {
 720                 printf("Hardware transactional memory (lock elision) "
 721                         "is supported\n");
 722
 723                 printf("Test read-write with Hardware transactional memory\n");
 724
 725                 /* htm = 1, rw_lf = 0, ext = 0 */
 726                 if (test_hash_readwrite_functional(1, 0, 0) < 0)
 727                         return -1;
 728
 729                 /* htm = 1, rw_lf = 1, ext = 0 */
 730                 if (test_hash_readwrite_functional(1, 1, 0) < 0)
 731                         return -1;
 732
 733                 /* htm = 1, rw_lf = 0, ext = 1 */
 734                 if (test_hash_readwrite_functional(1, 0, 1) < 0)
 735                         return -1;
 736
 737                 /* htm = 1, rw_lf = 1, ext = 1 */
 738                 if (test_hash_readwrite_functional(1, 1, 1) < 0)
 739                         return -1;
 740         } else {
 741                 printf("Hardware transactional memory (lock elision) "
 742                         "is NOT supported\n");
 743         }
 744
 745         printf("Test read-write without Hardware transactional memory\n");
 746         /* htm = 0, rw_lf = 0, ext = 0 */
 747         if (test_hash_readwrite_functional(0, 0, 0) < 0)
 748                 return -1;
 749
 750         /* htm = 0, rw_lf = 1, ext = 0 */
 751         if (test_hash_readwrite_functional(0, 1, 0) < 0)
 752                 return -1;
 753
 754         /* htm = 0, rw_lf = 0, ext = 1 */
 755         if (test_hash_readwrite_functional(0, 0, 1) < 0)
 756                 return -1;
 757
 758         /* htm = 0, rw_lf = 1, ext = 1 */
 759         if (test_hash_readwrite_functional(0, 1, 1) < 0)
 760                 return -1;
 761
 762         return 0;
 763 }
 764
 765 REGISTER_TEST_COMMAND(hash_readwrite_func_autotest, test_hash_rw_func_main);
 766 REGISTER_TEST_COMMAND(hash_readwrite_perf_autotest, test_hash_rw_perf_main);