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 } __rte_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 = RTE_IPV4(0x03, 0x02, 0x01, 0x00), 45 .ip_dst = RTE_IPV4(0x07, 0x06, 0x05, 0x04), 46 .port_src = 0x0908, 47 .port_dst = 0x0b0a, 48 .proto = 0x0c, 49 }, 50 { 51 .ip_src = RTE_IPV4(0x13, 0x12, 0x11, 0x10), 52 .ip_dst = RTE_IPV4(0x17, 0x16, 0x15, 0x14), 53 .port_src = 0x1918, 54 .port_dst = 0x1b1a, 55 .proto = 0x1c, 56 }, 57 { 58 .ip_src = RTE_IPV4(0x23, 0x22, 0x21, 0x20), 59 .ip_dst = RTE_IPV4(0x27, 0x26, 0x25, 0x24), 60 .port_src = 0x2928, 61 .port_dst = 0x2b2a, 62 .proto = 0x2c, 63 }, 64 { 65 .ip_src = RTE_IPV4(0x33, 0x32, 0x31, 0x30), 66 .ip_dst = RTE_IPV4(0x37, 0x36, 0x35, 0x34), 67 .port_src = 0x3938, 68 .port_dst = 0x3b3a, 69 .proto = 0x3c, 70 }, 71 { 72 .ip_src = RTE_IPV4(0x43, 0x42, 0x41, 0x40), 73 .ip_dst = RTE_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(¶ms); 243 244 params.name = "test_member_cache"; 245 params.is_cache = 1; 246 setsum_cache = rte_member_create(¶ms); 247 248 params.name = "test_member_vbf"; 249 params.type = RTE_MEMBER_TYPE_VBF; 250 setsum_vbf = rte_member_create(¶ms); 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(¶ms); 607 608 params.name = "test_member_cache"; 609 params.is_cache = 1; 610 setsum_cache = rte_member_create(¶ms); 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); 716