ceph/src/spdk/dpdk/test/test/test_member.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 /* This test is for membership library's simple feature test */
   6
   7 #include <rte_memcpy.h>
   8 #include <rte_malloc.h>
   9 #include <rte_member.h>
  10 #include <rte_byteorder.h>
  11 #include <rte_random.h>
  12 #include <rte_debug.h>
  13 #include <rte_ip.h>
  14
  15 #include "test.h"
  16
  17 struct rte_member_setsum *setsum_ht;
  18 struct rte_member_setsum *setsum_cache;
  19 struct rte_member_setsum *setsum_vbf;
  20
  21 /* 5-tuple key type */
  22 struct flow_key {
  23         uint32_t ip_src;
  24         uint32_t ip_dst;
  25         uint16_t port_src;
  26         uint16_t port_dst;
  27         uint8_t proto;
  28 } __attribute__((packed));
  29
  30 /* Set ID Macros for multimatch test usage */
  31 #define M_MATCH_S 1     /* Not start with 0 since by default 0 means no match */
  32 #define M_MATCH_E 15
  33 #define M_MATCH_STEP 2
  34 #define M_MATCH_CNT \
  35         (1 + (M_MATCH_E - M_MATCH_S) / M_MATCH_STEP)
  36
  37
  38 #define NUM_SAMPLES 5
  39 #define MAX_MATCH 32
  40
  41 /* Keys used by unit test functions */
  42 static struct flow_key keys[NUM_SAMPLES] = {
  43         {
  44                 .ip_src = IPv4(0x03, 0x02, 0x01, 0x00),
  45                 .ip_dst = IPv4(0x07, 0x06, 0x05, 0x04),
  46                 .port_src = 0x0908,
  47                 .port_dst = 0x0b0a,
  48                 .proto = 0x0c,
  49         },
  50         {
  51                 .ip_src = IPv4(0x13, 0x12, 0x11, 0x10),
  52                 .ip_dst = IPv4(0x17, 0x16, 0x15, 0x14),
  53                 .port_src = 0x1918,
  54                 .port_dst = 0x1b1a,
  55                 .proto = 0x1c,
  56         },
  57         {
  58                 .ip_src = IPv4(0x23, 0x22, 0x21, 0x20),
  59                 .ip_dst = IPv4(0x27, 0x26, 0x25, 0x24),
  60                 .port_src = 0x2928,
  61                 .port_dst = 0x2b2a,
  62                 .proto = 0x2c,
  63         },
  64         {
  65                 .ip_src = IPv4(0x33, 0x32, 0x31, 0x30),
  66                 .ip_dst = IPv4(0x37, 0x36, 0x35, 0x34),
  67                 .port_src = 0x3938,
  68                 .port_dst = 0x3b3a,
  69                 .proto = 0x3c,
  70         },
  71         {
  72                 .ip_src = IPv4(0x43, 0x42, 0x41, 0x40),
  73                 .ip_dst = IPv4(0x47, 0x46, 0x45, 0x44),
  74                 .port_src = 0x4948,
  75                 .port_dst = 0x4b4a,
  76                 .proto = 0x4c,
  77         }
  78 };
  79
  80 uint32_t test_set[NUM_SAMPLES] = {1, 2, 3, 4, 5};
  81
  82 #define ITERATIONS  3
  83 #define KEY_SIZE  4
  84
  85 #define MAX_ENTRIES (1 << 16)
  86 uint8_t generated_keys[MAX_ENTRIES][KEY_SIZE];
  87
  88 static struct rte_member_parameters params = {
  89                 .num_keys = MAX_ENTRIES,        /* Total hash table entries. */
  90                 .key_len = KEY_SIZE,            /* Length of hash key. */
  91
  92                 /* num_set and false_positive_rate only relevant to vBF */
  93                 .num_set = 16,
  94                 .false_positive_rate = 0.03,
  95                 .prim_hash_seed = 1,
  96                 .sec_hash_seed = 11,
  97                 .socket_id = 0                  /* NUMA Socket ID for memory. */
  98 };
  99
 100 /*
 101  * Sequence of operations for find existing setsummary
 102  *
 103  *  - create setsum
 104  *  - find existing setsum: hit
 105  *  - find non-existing setsum: miss
 106  *
 107  */
 108 static int
 109 test_member_find_existing(void)
 110 {
 111         struct rte_member_setsum *tmp_setsum = NULL, *result = NULL;
 112         struct rte_member_parameters tmp_params = {
 113                 .name = "member_find_existing",
 114                 .num_keys = MAX_ENTRIES,        /* Total hash table entries. */
 115                 .key_len = KEY_SIZE,            /* Length of hash key. */
 116                 .type = RTE_MEMBER_TYPE_HT,
 117                 .num_set = 32,
 118                 .false_positive_rate = 0.03,
 119                 .prim_hash_seed = 1,
 120                 .sec_hash_seed = 11,
 121                 .socket_id = 0                  /* NUMA Socket ID for memory. */
 122         };
 123
 124         /* Create */
 125         tmp_setsum = rte_member_create(&tmp_params);
 126         TEST_ASSERT(tmp_setsum != NULL, "setsum creation failed");
 127
 128         /* Try to find existing hash table */
 129         result = rte_member_find_existing("member_find_existing");
 130         TEST_ASSERT(result == tmp_setsum, "could not find existing setsum");
 131
 132         /* Try to find non-existing hash table */
 133         result = rte_member_find_existing("member_find_non_existing");
 134         TEST_ASSERT(result == NULL, "found setsum that shouldn't exist");
 135
 136         /* Cleanup. */
 137         rte_member_free(tmp_setsum);
 138
 139         return 0;
 140 }
 141
 142 /*
 143  * Test for bad creating parameters
 144  */
 145 static int
 146 test_member_create_bad_param(void)
 147 {
 148         struct rte_member_setsum *bad_setsum = NULL;
 149         struct rte_member_parameters bad_params = {
 150                 .num_keys = MAX_ENTRIES,        /* Total hash table entries. */
 151                 .key_len = KEY_SIZE,            /* Length of hash key. */
 152                 .type = RTE_MEMBER_TYPE_HT,
 153                 .num_set = 32,
 154                 .false_positive_rate = 0.03,
 155                 .prim_hash_seed = 1,
 156                 .sec_hash_seed = 11,
 157                 .socket_id = 0                  /* NUMA Socket ID for memory. */
 158         };
 159
 160         printf("Expected error section begin...\n");
 161         bad_params.name = "bad_param1";
 162         bad_params.num_set = 0;
 163         bad_params.type = RTE_MEMBER_TYPE_VBF;
 164         /* Test with 0 set for vBF should fail */
 165         bad_setsum = rte_member_create(&bad_params);
 166         if (bad_setsum != NULL) {
 167                 rte_member_free(bad_setsum);
 168                 printf("Impossible creating setsum successfully with invalid "
 169                         "number of set for vBF\n");
 170                 return -1;
 171         }
 172
 173         bad_params.name = "bad_param2";
 174         bad_params.false_positive_rate = 0;
 175         bad_params.num_set = 32;
 176         /* Test with 0 false positive for vBF should fail */
 177         bad_setsum = rte_member_create(&bad_params);
 178         if (bad_setsum != NULL) {
 179                 rte_member_free(bad_setsum);
 180                 printf("Impossible creating setsum successfully with invalid "
 181                         "false positive rate for vBF\n");
 182                 return -1;
 183         }
 184
 185         bad_params.name = "bad_param3";
 186         bad_params.false_positive_rate = 0.03;
 187         bad_params.num_keys = 0;
 188         /* Test with 0 key per BF for vBF should fail */
 189         bad_setsum = rte_member_create(&bad_params);
 190         if (bad_setsum != NULL) {
 191                 rte_member_free(bad_setsum);
 192                 printf("Impossible creating setsum successfully with invalid "
 193                         "num_keys for vBF\n");
 194                 return -1;
 195         }
 196
 197         bad_params.name = "bad_param4";
 198         bad_params.type = RTE_MEMBER_TYPE_HT;
 199         bad_params.num_keys = RTE_MEMBER_BUCKET_ENTRIES / 2;
 200         /* Test with less than 1 bucket for HTSS should fail */
 201         bad_setsum = rte_member_create(&bad_params);
 202         if (bad_setsum != NULL) {
 203                 rte_member_free(bad_setsum);
 204                 printf("Impossible creating setsum successfully with too few "
 205                         "number of keys(entries) for HT\n");
 206                 return -1;
 207         }
 208
 209         bad_params.name = "bad_param5";
 210         bad_params.num_keys = RTE_MEMBER_ENTRIES_MAX + 1;
 211         /* Test with more than maximum entries for HTSS should fail */
 212         bad_setsum = rte_member_create(&bad_params);
 213         if (bad_setsum != NULL) {
 214                 rte_member_free(bad_setsum);
 215                 printf("Impossible creating setsum successfully with to many "
 216                         "number of keys(entries) for HT\n");
 217                 return -1;
 218         }
 219
 220         bad_params.name = "bad_param5";
 221         /* Test with same name should fail */
 222         bad_setsum = rte_member_create(&bad_params);
 223         if (bad_setsum != NULL) {
 224                 rte_member_free(bad_setsum);
 225                 printf("Impossible creating setsum successfully with existed "
 226                         "name\n");
 227                 return -1;
 228         }
 229         printf("Expected error section end...\n");
 230         rte_member_free(bad_setsum);
 231         return 0;
 232 }
 233
 234 /* Create test setsummaries. */
 235 static int test_member_create(void)
 236 {
 237         params.key_len = sizeof(struct flow_key);
 238
 239         params.name = "test_member_ht";
 240         params.is_cache = 0;
 241         params.type = RTE_MEMBER_TYPE_HT;
 242         setsum_ht = rte_member_create(&params);
 243
 244         params.name = "test_member_cache";
 245         params.is_cache = 1;
 246         setsum_cache = rte_member_create(&params);
 247
 248         params.name = "test_member_vbf";
 249         params.type = RTE_MEMBER_TYPE_VBF;
 250         setsum_vbf = rte_member_create(&params);
 251
 252         if (setsum_ht == NULL || setsum_cache == NULL || setsum_vbf == NULL) {
 253                 printf("Creation of setsums fail\n");
 254                 return -1;
 255         }
 256         printf("Creation of setsums success\n");
 257         return 0;
 258 }
 259
 260 static int test_member_insert(void)
 261 {
 262         int ret_ht, ret_cache, ret_vbf, i;
 263
 264         for (i = 0; i < NUM_SAMPLES; i++) {
 265                 ret_ht = rte_member_add(setsum_ht, &keys[i], test_set[i]);
 266                 ret_cache = rte_member_add(setsum_cache, &keys[i],
 267                                                 test_set[i]);
 268                 ret_vbf = rte_member_add(setsum_vbf, &keys[i], test_set[i]);
 269                 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
 270                                 "insert error");
 271         }
 272         printf("insert key success\n");
 273         return 0;
 274 }
 275
 276 static int test_member_lookup(void)
 277 {
 278         int ret_ht, ret_cache, ret_vbf, i;
 279         uint16_t set_ht, set_cache, set_vbf;
 280         member_set_t set_ids_ht[NUM_SAMPLES] = {0};
 281         member_set_t set_ids_cache[NUM_SAMPLES] = {0};
 282         member_set_t set_ids_vbf[NUM_SAMPLES] = {0};
 283
 284         uint32_t num_key_ht = NUM_SAMPLES;
 285         uint32_t num_key_cache = NUM_SAMPLES;
 286         uint32_t num_key_vbf = NUM_SAMPLES;
 287
 288         const void *key_array[NUM_SAMPLES];
 289
 290         /* Single lookup test */
 291         for (i = 0; i < NUM_SAMPLES; i++) {
 292                 ret_ht = rte_member_lookup(setsum_ht, &keys[i], &set_ht);
 293                 ret_cache = rte_member_lookup(setsum_cache, &keys[i],
 294                                                         &set_cache);
 295                 ret_vbf = rte_member_lookup(setsum_vbf, &keys[i], &set_vbf);
 296                 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
 297                                 "single lookup function error");
 298
 299                 TEST_ASSERT(set_ht == test_set[i] &&
 300                                 set_cache == test_set[i] &&
 301                                 set_vbf == test_set[i],
 302                                 "single lookup set value error");
 303         }
 304         printf("lookup single key success\n");
 305
 306         /* Bulk lookup test */
 307         for (i = 0; i < NUM_SAMPLES; i++)
 308                 key_array[i] = &keys[i];
 309
 310         ret_ht = rte_member_lookup_bulk(setsum_ht, key_array,
 311                         num_key_ht, set_ids_ht);
 312
 313         ret_cache = rte_member_lookup_bulk(setsum_cache, key_array,
 314                         num_key_cache, set_ids_cache);
 315
 316         ret_vbf = rte_member_lookup_bulk(setsum_vbf, key_array,
 317                         num_key_vbf, set_ids_vbf);
 318
 319         TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
 320                         "bulk lookup function error");
 321
 322         for (i = 0; i < NUM_SAMPLES; i++) {
 323                 TEST_ASSERT((set_ids_ht[i] == test_set[i]) &&
 324                                 (set_ids_cache[i] == test_set[i]) &&
 325                                 (set_ids_vbf[i] == test_set[i]),
 326                                 "bulk lookup result error");
 327         }
 328
 329         return 0;
 330 }
 331
 332 static int test_member_delete(void)
 333 {
 334         int ret_ht, ret_cache, ret_vbf, i;
 335         uint16_t set_ht, set_cache, set_vbf;
 336         const void *key_array[NUM_SAMPLES];
 337         member_set_t set_ids_ht[NUM_SAMPLES] = {0};
 338         member_set_t set_ids_cache[NUM_SAMPLES] = {0};
 339         member_set_t set_ids_vbf[NUM_SAMPLES] = {0};
 340         uint32_t num_key_ht = NUM_SAMPLES;
 341         uint32_t num_key_cache = NUM_SAMPLES;
 342         uint32_t num_key_vbf = NUM_SAMPLES;
 343
 344         /* Delete part of all inserted keys */
 345         for (i = 0; i < NUM_SAMPLES / 2; i++) {
 346                 ret_ht = rte_member_delete(setsum_ht, &keys[i], test_set[i]);
 347                 ret_cache = rte_member_delete(setsum_cache, &keys[i],
 348                                                 test_set[i]);
 349                 ret_vbf = rte_member_delete(setsum_vbf, &keys[i], test_set[i]);
 350                 /* VBF does not support delete yet, so return error code */
 351                 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0,
 352                                 "key deletion function error");
 353                 TEST_ASSERT(ret_vbf < 0,
 354                                 "vbf does not support deletion, error");
 355         }
 356
 357         for (i = 0; i < NUM_SAMPLES; i++)
 358                 key_array[i] = &keys[i];
 359
 360         ret_ht = rte_member_lookup_bulk(setsum_ht, key_array,
 361                         num_key_ht, set_ids_ht);
 362
 363         ret_cache = rte_member_lookup_bulk(setsum_cache, key_array,
 364                         num_key_cache, set_ids_cache);
 365
 366         ret_vbf = rte_member_lookup_bulk(setsum_vbf, key_array,
 367                         num_key_vbf, set_ids_vbf);
 368
 369         TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
 370                         "bulk lookup function error");
 371
 372         for (i = 0; i < NUM_SAMPLES / 2; i++) {
 373                 TEST_ASSERT((set_ids_ht[i] == RTE_MEMBER_NO_MATCH) &&
 374                                 (set_ids_cache[i] == RTE_MEMBER_NO_MATCH),
 375                                 "bulk lookup result error");
 376         }
 377
 378         for (i = NUM_SAMPLES / 2; i < NUM_SAMPLES; i++) {
 379                 TEST_ASSERT((set_ids_ht[i] == test_set[i]) &&
 380                                 (set_ids_cache[i] == test_set[i]) &&
 381                                 (set_ids_vbf[i] == test_set[i]),
 382                                 "bulk lookup result error");
 383         }
 384
 385         /* Delete the left of inserted keys */
 386         for (i = NUM_SAMPLES / 2; i < NUM_SAMPLES; i++) {
 387                 ret_ht = rte_member_delete(setsum_ht, &keys[i], test_set[i]);
 388                 ret_cache = rte_member_delete(setsum_cache, &keys[i],
 389                                                 test_set[i]);
 390                 ret_vbf = rte_member_delete(setsum_vbf, &keys[i], test_set[i]);
 391                 /* VBF does not support delete yet, so return error code */
 392                 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0,
 393                                 "key deletion function error");
 394                 TEST_ASSERT(ret_vbf < 0,
 395                                 "vbf does not support deletion, error");
 396         }
 397
 398         for (i = 0; i < NUM_SAMPLES; i++) {
 399                 ret_ht = rte_member_lookup(setsum_ht, &keys[i], &set_ht);
 400                 ret_cache = rte_member_lookup(setsum_cache, &keys[i],
 401                                                 &set_cache);
 402                 ret_vbf = rte_member_lookup(setsum_vbf, &keys[i], &set_vbf);
 403                 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0,
 404                                 "key lookup function error");
 405                 TEST_ASSERT(set_ht == RTE_MEMBER_NO_MATCH &&
 406                                 ret_cache == RTE_MEMBER_NO_MATCH,
 407                                 "key deletion failed");
 408         }
 409         /* Reset vbf for other following tests */
 410         rte_member_reset(setsum_vbf);
 411
 412         printf("delete success\n");
 413         return 0;
 414 }
 415
 416 static int test_member_multimatch(void)
 417 {
 418         int ret_ht, ret_vbf, ret_cache;
 419         member_set_t set_ids_ht[MAX_MATCH] = {0};
 420         member_set_t set_ids_vbf[MAX_MATCH] = {0};
 421         member_set_t set_ids_cache[MAX_MATCH] = {0};
 422
 423         member_set_t set_ids_ht_m[NUM_SAMPLES][MAX_MATCH] = {{0} };
 424         member_set_t set_ids_vbf_m[NUM_SAMPLES][MAX_MATCH] = {{0} };
 425         member_set_t set_ids_cache_m[NUM_SAMPLES][MAX_MATCH] = {{0} };
 426
 427         uint32_t match_count_ht[NUM_SAMPLES];
 428         uint32_t match_count_vbf[NUM_SAMPLES];
 429         uint32_t match_count_cache[NUM_SAMPLES];
 430
 431         uint32_t num_key_ht = NUM_SAMPLES;
 432         uint32_t num_key_vbf = NUM_SAMPLES;
 433         uint32_t num_key_cache = NUM_SAMPLES;
 434
 435         const void *key_array[NUM_SAMPLES];
 436
 437         uint32_t i, j;
 438
 439         /* Same key at most inserted 2*entry_per_bucket times for HT mode */
 440         for (i = M_MATCH_S; i <= M_MATCH_E; i += M_MATCH_STEP) {
 441                 for (j = 0; j < NUM_SAMPLES; j++) {
 442                         ret_ht = rte_member_add(setsum_ht, &keys[j], i);
 443                         ret_vbf = rte_member_add(setsum_vbf, &keys[j], i);
 444                         ret_cache = rte_member_add(setsum_cache, &keys[j], i);
 445
 446                         TEST_ASSERT(ret_ht >= 0 && ret_vbf >= 0 &&
 447                                         ret_cache >= 0,
 448                                         "insert function error");
 449                 }
 450         }
 451
 452         /* Single multimatch test */
 453         for (i = 0; i < NUM_SAMPLES; i++) {
 454                 ret_vbf = rte_member_lookup_multi(setsum_vbf, &keys[i],
 455                                                         MAX_MATCH, set_ids_vbf);
 456                 ret_ht = rte_member_lookup_multi(setsum_ht, &keys[i],
 457                                                         MAX_MATCH, set_ids_ht);
 458                 ret_cache = rte_member_lookup_multi(setsum_cache, &keys[i],
 459                                                 MAX_MATCH, set_ids_cache);
 460                 /*
 461                  * For cache mode, keys overwrite when signature same.
 462                  * the mutimatch should work like single match.
 463                  */
 464                 TEST_ASSERT(ret_ht == M_MATCH_CNT && ret_vbf == M_MATCH_CNT &&
 465                                 ret_cache == 1,
 466                                 "single lookup_multi error");
 467                 TEST_ASSERT(set_ids_cache[0] == M_MATCH_E,
 468                                 "single lookup_multi cache error");
 469
 470                 for (j = 1; j <= M_MATCH_CNT; j++) {
 471                         TEST_ASSERT(set_ids_ht[j-1] == j * M_MATCH_STEP - 1 &&
 472                                         set_ids_vbf[j-1] ==
 473                                                         j * M_MATCH_STEP - 1,
 474                                         "single multimatch lookup error");
 475                 }
 476         }
 477         printf("lookup single key for multimatch success\n");
 478
 479         /* Bulk multimatch test */
 480         for (i = 0; i < NUM_SAMPLES; i++)
 481                 key_array[i] = &keys[i];
 482         ret_vbf = rte_member_lookup_multi_bulk(setsum_vbf,
 483                         &key_array[0], num_key_ht, MAX_MATCH, match_count_vbf,
 484                         (member_set_t *)set_ids_vbf_m);
 485
 486         ret_ht = rte_member_lookup_multi_bulk(setsum_ht,
 487                         &key_array[0], num_key_vbf, MAX_MATCH, match_count_ht,
 488                         (member_set_t *)set_ids_ht_m);
 489
 490         ret_cache = rte_member_lookup_multi_bulk(setsum_cache,
 491                         &key_array[0], num_key_cache, MAX_MATCH,
 492                         match_count_cache, (member_set_t *)set_ids_cache_m);
 493
 494
 495         for (j = 0; j < NUM_SAMPLES; j++) {
 496                 TEST_ASSERT(match_count_ht[j] == M_MATCH_CNT,
 497                         "bulk multimatch lookup HT match count error");
 498                 TEST_ASSERT(match_count_vbf[j] == M_MATCH_CNT,
 499                         "bulk multimatch lookup vBF match count error");
 500                 TEST_ASSERT(match_count_cache[j] == 1,
 501                         "bulk multimatch lookup CACHE match count error");
 502                 TEST_ASSERT(set_ids_cache_m[j][0] == M_MATCH_E,
 503                         "bulk multimatch lookup CACHE set value error");
 504
 505                 for (i = 1; i <= M_MATCH_CNT; i++) {
 506                         TEST_ASSERT(set_ids_ht_m[j][i-1] ==
 507                                                         i * M_MATCH_STEP - 1,
 508                                 "bulk multimatch lookup HT set value error");
 509                         TEST_ASSERT(set_ids_vbf_m[j][i-1] ==
 510                                                         i * M_MATCH_STEP - 1,
 511                                 "bulk multimatch lookup vBF set value error");
 512                 }
 513         }
 514
 515         printf("lookup for bulk multimatch success\n");
 516
 517         return 0;
 518 }
 519
 520 static int key_compare(const void *key1, const void *key2)
 521 {
 522         return memcmp(key1, key2, KEY_SIZE);
 523 }
 524
 525 static void
 526 setup_keys_and_data(void)
 527 {
 528         unsigned int i, j;
 529         int num_duplicates;
 530
 531         /* Reset all arrays */
 532         for (i = 0; i < KEY_SIZE; i++)
 533                 generated_keys[0][i] = 0;
 534
 535         /* Generate a list of keys, some of which may be duplicates */
 536         for (i = 0; i < MAX_ENTRIES; i++) {
 537                 for (j = 0; j < KEY_SIZE; j++)
 538                         generated_keys[i][j] = rte_rand() & 0xFF;
 539         }
 540
 541         /* Remove duplicates from the keys array */
 542         do {
 543                 num_duplicates = 0;
 544                 /* Sort the list of keys to make it easier to find duplicates */
 545                 qsort(generated_keys, MAX_ENTRIES, KEY_SIZE, key_compare);
 546
 547                 /* Sift through the list of keys and look for duplicates */
 548                 int num_duplicates = 0;
 549                 for (i = 0; i < MAX_ENTRIES - 1; i++) {
 550                         if (memcmp(generated_keys[i], generated_keys[i + 1],
 551                                         KEY_SIZE) == 0) {
 552                                 /* This key already exists, try again */
 553                                 num_duplicates++;
 554                                 for (j = 0; j < KEY_SIZE; j++)
 555                                         generated_keys[i][j] =
 556                                                         rte_rand() & 0xFF;
 557                         }
 558                 }
 559         } while (num_duplicates != 0);
 560 }
 561
 562 static inline int
 563 add_generated_keys(struct rte_member_setsum *setsum, unsigned int *added_keys)
 564 {
 565         int ret = 0;
 566
 567         for (*added_keys = 0; ret >= 0 && *added_keys < MAX_ENTRIES;
 568                         (*added_keys)++) {
 569                 uint16_t set = (rte_rand() & 0xf) + 1;
 570                 ret = rte_member_add(setsum, &generated_keys[*added_keys], set);
 571         }
 572         return ret;
 573 }
 574
 575 static inline int
 576 add_generated_keys_cache(struct rte_member_setsum *setsum,
 577                                 unsigned int *added_keys)
 578 {
 579         int ret = 0;
 580
 581         for (*added_keys = 0; ret == 0 && *added_keys < MAX_ENTRIES;
 582                         (*added_keys)++) {
 583                 uint16_t set = (rte_rand() & 0xf) + 1;
 584                 ret = rte_member_add(setsum, &generated_keys[*added_keys], set);
 585         }
 586         return ret;
 587 }
 588
 589 static int
 590 test_member_loadfactor(void)
 591 {
 592         unsigned  int j;
 593         unsigned int added_keys, average_keys_added = 0;
 594         int ret;
 595
 596         setup_keys_and_data();
 597
 598         rte_member_free(setsum_ht);
 599         rte_member_free(setsum_cache);
 600         rte_member_free(setsum_vbf);
 601
 602         params.key_len = KEY_SIZE;
 603         params.name = "test_member_ht";
 604         params.is_cache = 0;
 605         params.type = RTE_MEMBER_TYPE_HT;
 606         setsum_ht = rte_member_create(&params);
 607
 608         params.name = "test_member_cache";
 609         params.is_cache = 1;
 610         setsum_cache = rte_member_create(&params);
 611
 612
 613         if (setsum_ht == NULL || setsum_cache == NULL) {
 614                 printf("Creation of setsums fail\n");
 615                 return -1;
 616         }
 617         /* Test HT non-cache mode */
 618         for (j = 0; j < ITERATIONS; j++) {
 619                 /* Add random entries until key cannot be added */
 620                 ret = add_generated_keys(setsum_ht, &added_keys);
 621                 if (ret != -ENOSPC) {
 622                         printf("Unexpected error when adding keys\n");
 623                         return -1;
 624                 }
 625                 average_keys_added += added_keys;
 626
 627                 /* Reset the table */
 628                 rte_member_reset(setsum_ht);
 629
 630                 /* Print a dot to show progress on operations */
 631                 printf(".");
 632                 fflush(stdout);
 633         }
 634
 635         average_keys_added /= ITERATIONS;
 636
 637         printf("\nKeys inserted when no space(non-cache) = %.2f%% (%u/%u)\n",
 638                 ((double) average_keys_added / params.num_keys * 100),
 639                 average_keys_added, params.num_keys);
 640
 641         /* Test cache mode */
 642         added_keys = average_keys_added = 0;
 643         for (j = 0; j < ITERATIONS; j++) {
 644                 /* Add random entries until key cannot be added */
 645                 ret = add_generated_keys_cache(setsum_cache, &added_keys);
 646                 if (ret != 1) {
 647                         printf("Unexpected error when adding keys\n");
 648                         return -1;
 649                 }
 650                 average_keys_added += added_keys;
 651
 652                 /* Reset the table */
 653                 rte_member_reset(setsum_cache);
 654
 655                 /* Print a dot to show progress on operations */
 656                 printf(".");
 657                 fflush(stdout);
 658         }
 659
 660         average_keys_added /= ITERATIONS;
 661
 662         printf("\nKeys inserted when eviction happens(cache)= %.2f%% (%u/%u)\n",
 663                 ((double) average_keys_added / params.num_keys * 100),
 664                 average_keys_added, params.num_keys);
 665         return 0;
 666 }
 667
 668 static void
 669 perform_free(void)
 670 {
 671         rte_member_free(setsum_ht);
 672         rte_member_free(setsum_cache);
 673         rte_member_free(setsum_vbf);
 674 }
 675
 676 static int
 677 test_member(void)
 678 {
 679         if (test_member_create_bad_param() < 0)
 680                 return -1;
 681
 682         if (test_member_find_existing() < 0)
 683                 return -1;
 684
 685         if (test_member_create() < 0) {
 686                 perform_free();
 687                 return -1;
 688         }
 689         if (test_member_insert() < 0) {
 690                 perform_free();
 691                 return -1;
 692         }
 693         if (test_member_lookup() < 0) {
 694                 perform_free();
 695                 return -1;
 696         }
 697         if (test_member_delete() < 0) {
 698                 perform_free();
 699                 return -1;
 700         }
 701         if (test_member_multimatch() < 0) {
 702                 perform_free();
 703                 return -1;
 704         }
 705         if (test_member_loadfactor() < 0) {
 706                 rte_member_free(setsum_ht);
 707                 rte_member_free(setsum_cache);
 708                 return -1;
 709         }
 710
 711         perform_free();
 712         return 0;
 713 }
 714
 715 REGISTER_TEST_COMMAND(member_autotest, test_member);