1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
5 /* This test is for membership library's simple feature test */
9 #include <rte_memcpy.h>
10 #include <rte_malloc.h>
12 #ifdef RTE_EXEC_ENV_WINDOWS
16 printf("member not supported on Windows, skipping test\n");
22 #include <rte_member.h>
23 #include <rte_byteorder.h>
24 #include <rte_random.h>
25 #include <rte_debug.h>
28 struct rte_member_setsum *setsum_ht;
29 struct rte_member_setsum *setsum_cache;
30 struct rte_member_setsum *setsum_vbf;
32 /* 5-tuple key type */
41 /* Set ID Macros for multimatch test usage */
42 #define M_MATCH_S 1 /* Not start with 0 since by default 0 means no match */
44 #define M_MATCH_STEP 2
46 (1 + (M_MATCH_E - M_MATCH_S) / M_MATCH_STEP)
52 /* Keys used by unit test functions */
53 static struct flow_key keys[NUM_SAMPLES] = {
55 .ip_src = RTE_IPV4(0x03, 0x02, 0x01, 0x00),
56 .ip_dst = RTE_IPV4(0x07, 0x06, 0x05, 0x04),
62 .ip_src = RTE_IPV4(0x13, 0x12, 0x11, 0x10),
63 .ip_dst = RTE_IPV4(0x17, 0x16, 0x15, 0x14),
69 .ip_src = RTE_IPV4(0x23, 0x22, 0x21, 0x20),
70 .ip_dst = RTE_IPV4(0x27, 0x26, 0x25, 0x24),
76 .ip_src = RTE_IPV4(0x33, 0x32, 0x31, 0x30),
77 .ip_dst = RTE_IPV4(0x37, 0x36, 0x35, 0x34),
83 .ip_src = RTE_IPV4(0x43, 0x42, 0x41, 0x40),
84 .ip_dst = RTE_IPV4(0x47, 0x46, 0x45, 0x44),
91 uint32_t test_set[NUM_SAMPLES] = {1, 2, 3, 4, 5};
96 #define MAX_ENTRIES (1 << 16)
97 uint8_t generated_keys[MAX_ENTRIES][KEY_SIZE];
99 static struct rte_member_parameters params = {
100 .num_keys = MAX_ENTRIES, /* Total hash table entries. */
101 .key_len = KEY_SIZE, /* Length of hash key. */
103 /* num_set and false_positive_rate only relevant to vBF */
105 .false_positive_rate = 0.03,
108 .socket_id = 0 /* NUMA Socket ID for memory. */
112 * Sequence of operations for find existing setsummary
115 * - find existing setsum: hit
116 * - find non-existing setsum: miss
120 test_member_find_existing(void)
122 struct rte_member_setsum *tmp_setsum = NULL, *result = NULL;
123 struct rte_member_parameters tmp_params = {
124 .name = "member_find_existing",
125 .num_keys = MAX_ENTRIES, /* Total hash table entries. */
126 .key_len = KEY_SIZE, /* Length of hash key. */
127 .type = RTE_MEMBER_TYPE_HT,
129 .false_positive_rate = 0.03,
132 .socket_id = 0 /* NUMA Socket ID for memory. */
136 tmp_setsum = rte_member_create(&tmp_params);
137 TEST_ASSERT(tmp_setsum != NULL, "setsum creation failed");
139 /* Try to find existing hash table */
140 result = rte_member_find_existing("member_find_existing");
141 TEST_ASSERT(result == tmp_setsum, "could not find existing setsum");
143 /* Try to find non-existing hash table */
144 result = rte_member_find_existing("member_find_non_existing");
145 TEST_ASSERT(result == NULL, "found setsum that shouldn't exist");
148 rte_member_free(tmp_setsum);
154 * Test for bad creating parameters
157 test_member_create_bad_param(void)
159 struct rte_member_setsum *bad_setsum = NULL;
160 struct rte_member_parameters bad_params = {
161 .num_keys = MAX_ENTRIES, /* Total hash table entries. */
162 .key_len = KEY_SIZE, /* Length of hash key. */
163 .type = RTE_MEMBER_TYPE_HT,
165 .false_positive_rate = 0.03,
168 .socket_id = 0 /* NUMA Socket ID for memory. */
171 printf("Expected error section begin...\n");
172 bad_params.name = "bad_param1";
173 bad_params.num_set = 0;
174 bad_params.type = RTE_MEMBER_TYPE_VBF;
175 /* Test with 0 set for vBF should fail */
176 bad_setsum = rte_member_create(&bad_params);
177 if (bad_setsum != NULL) {
178 rte_member_free(bad_setsum);
179 printf("Impossible creating setsum successfully with invalid "
180 "number of set for vBF\n");
184 bad_params.name = "bad_param2";
185 bad_params.false_positive_rate = 0;
186 bad_params.num_set = 32;
187 /* Test with 0 false positive for vBF should fail */
188 bad_setsum = rte_member_create(&bad_params);
189 if (bad_setsum != NULL) {
190 rte_member_free(bad_setsum);
191 printf("Impossible creating setsum successfully with invalid "
192 "false positive rate for vBF\n");
196 bad_params.name = "bad_param3";
197 bad_params.false_positive_rate = 0.03;
198 bad_params.num_keys = 0;
199 /* Test with 0 key per BF for vBF should fail */
200 bad_setsum = rte_member_create(&bad_params);
201 if (bad_setsum != NULL) {
202 rte_member_free(bad_setsum);
203 printf("Impossible creating setsum successfully with invalid "
204 "num_keys for vBF\n");
208 bad_params.name = "bad_param4";
209 bad_params.type = RTE_MEMBER_TYPE_HT;
210 bad_params.num_keys = RTE_MEMBER_BUCKET_ENTRIES / 2;
211 /* Test with less than 1 bucket 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 too few "
216 "number of keys(entries) for HT\n");
220 bad_params.name = "bad_param5";
221 bad_params.num_keys = RTE_MEMBER_ENTRIES_MAX + 1;
222 /* Test with more than maximum entries for HTSS should fail */
223 bad_setsum = rte_member_create(&bad_params);
224 if (bad_setsum != NULL) {
225 rte_member_free(bad_setsum);
226 printf("Impossible creating setsum successfully with to many "
227 "number of keys(entries) for HT\n");
231 bad_params.name = "bad_param5";
232 /* Test with same name should fail */
233 bad_setsum = rte_member_create(&bad_params);
234 if (bad_setsum != NULL) {
235 rte_member_free(bad_setsum);
236 printf("Impossible creating setsum successfully with existed "
240 printf("Expected error section end...\n");
241 rte_member_free(bad_setsum);
245 /* Create test setsummaries. */
246 static int test_member_create(void)
248 params.key_len = sizeof(struct flow_key);
250 params.name = "test_member_ht";
252 params.type = RTE_MEMBER_TYPE_HT;
253 setsum_ht = rte_member_create(¶ms);
255 params.name = "test_member_cache";
257 setsum_cache = rte_member_create(¶ms);
259 params.name = "test_member_vbf";
260 params.type = RTE_MEMBER_TYPE_VBF;
261 setsum_vbf = rte_member_create(¶ms);
263 if (setsum_ht == NULL || setsum_cache == NULL || setsum_vbf == NULL) {
264 printf("Creation of setsums fail\n");
267 printf("Creation of setsums success\n");
271 static int test_member_insert(void)
273 int ret_ht, ret_cache, ret_vbf, i;
275 for (i = 0; i < NUM_SAMPLES; i++) {
276 ret_ht = rte_member_add(setsum_ht, &keys[i], test_set[i]);
277 ret_cache = rte_member_add(setsum_cache, &keys[i],
279 ret_vbf = rte_member_add(setsum_vbf, &keys[i], test_set[i]);
280 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
283 printf("insert key success\n");
287 static int test_member_lookup(void)
289 int ret_ht, ret_cache, ret_vbf, i;
290 uint16_t set_ht, set_cache, set_vbf;
291 member_set_t set_ids_ht[NUM_SAMPLES] = {0};
292 member_set_t set_ids_cache[NUM_SAMPLES] = {0};
293 member_set_t set_ids_vbf[NUM_SAMPLES] = {0};
295 uint32_t num_key_ht = NUM_SAMPLES;
296 uint32_t num_key_cache = NUM_SAMPLES;
297 uint32_t num_key_vbf = NUM_SAMPLES;
299 const void *key_array[NUM_SAMPLES];
301 /* Single lookup test */
302 for (i = 0; i < NUM_SAMPLES; i++) {
303 ret_ht = rte_member_lookup(setsum_ht, &keys[i], &set_ht);
304 ret_cache = rte_member_lookup(setsum_cache, &keys[i],
306 ret_vbf = rte_member_lookup(setsum_vbf, &keys[i], &set_vbf);
307 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
308 "single lookup function error");
310 TEST_ASSERT(set_ht == test_set[i] &&
311 set_cache == test_set[i] &&
312 set_vbf == test_set[i],
313 "single lookup set value error");
315 printf("lookup single key success\n");
317 /* Bulk lookup test */
318 for (i = 0; i < NUM_SAMPLES; i++)
319 key_array[i] = &keys[i];
321 ret_ht = rte_member_lookup_bulk(setsum_ht, key_array,
322 num_key_ht, set_ids_ht);
324 ret_cache = rte_member_lookup_bulk(setsum_cache, key_array,
325 num_key_cache, set_ids_cache);
327 ret_vbf = rte_member_lookup_bulk(setsum_vbf, key_array,
328 num_key_vbf, set_ids_vbf);
330 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
331 "bulk lookup function error");
333 for (i = 0; i < NUM_SAMPLES; i++) {
334 TEST_ASSERT((set_ids_ht[i] == test_set[i]) &&
335 (set_ids_cache[i] == test_set[i]) &&
336 (set_ids_vbf[i] == test_set[i]),
337 "bulk lookup result error");
343 static int test_member_delete(void)
345 int ret_ht, ret_cache, ret_vbf, i;
346 uint16_t set_ht, set_cache, set_vbf;
347 const void *key_array[NUM_SAMPLES];
348 member_set_t set_ids_ht[NUM_SAMPLES] = {0};
349 member_set_t set_ids_cache[NUM_SAMPLES] = {0};
350 member_set_t set_ids_vbf[NUM_SAMPLES] = {0};
351 uint32_t num_key_ht = NUM_SAMPLES;
352 uint32_t num_key_cache = NUM_SAMPLES;
353 uint32_t num_key_vbf = NUM_SAMPLES;
355 /* Delete part of all inserted keys */
356 for (i = 0; i < NUM_SAMPLES / 2; i++) {
357 ret_ht = rte_member_delete(setsum_ht, &keys[i], test_set[i]);
358 ret_cache = rte_member_delete(setsum_cache, &keys[i],
360 ret_vbf = rte_member_delete(setsum_vbf, &keys[i], test_set[i]);
361 /* VBF does not support delete yet, so return error code */
362 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0,
363 "key deletion function error");
364 TEST_ASSERT(ret_vbf < 0,
365 "vbf does not support deletion, error");
368 for (i = 0; i < NUM_SAMPLES; i++)
369 key_array[i] = &keys[i];
371 ret_ht = rte_member_lookup_bulk(setsum_ht, key_array,
372 num_key_ht, set_ids_ht);
374 ret_cache = rte_member_lookup_bulk(setsum_cache, key_array,
375 num_key_cache, set_ids_cache);
377 ret_vbf = rte_member_lookup_bulk(setsum_vbf, key_array,
378 num_key_vbf, set_ids_vbf);
380 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0 && ret_vbf >= 0,
381 "bulk lookup function error");
383 for (i = 0; i < NUM_SAMPLES / 2; i++) {
384 TEST_ASSERT((set_ids_ht[i] == RTE_MEMBER_NO_MATCH) &&
385 (set_ids_cache[i] == RTE_MEMBER_NO_MATCH),
386 "bulk lookup result error");
389 for (i = NUM_SAMPLES / 2; i < NUM_SAMPLES; i++) {
390 TEST_ASSERT((set_ids_ht[i] == test_set[i]) &&
391 (set_ids_cache[i] == test_set[i]) &&
392 (set_ids_vbf[i] == test_set[i]),
393 "bulk lookup result error");
396 /* Delete the left of inserted keys */
397 for (i = NUM_SAMPLES / 2; i < NUM_SAMPLES; i++) {
398 ret_ht = rte_member_delete(setsum_ht, &keys[i], test_set[i]);
399 ret_cache = rte_member_delete(setsum_cache, &keys[i],
401 ret_vbf = rte_member_delete(setsum_vbf, &keys[i], test_set[i]);
402 /* VBF does not support delete yet, so return error code */
403 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0,
404 "key deletion function error");
405 TEST_ASSERT(ret_vbf < 0,
406 "vbf does not support deletion, error");
409 for (i = 0; i < NUM_SAMPLES; i++) {
410 ret_ht = rte_member_lookup(setsum_ht, &keys[i], &set_ht);
411 ret_cache = rte_member_lookup(setsum_cache, &keys[i],
413 ret_vbf = rte_member_lookup(setsum_vbf, &keys[i], &set_vbf);
414 TEST_ASSERT(ret_ht >= 0 && ret_cache >= 0,
415 "key lookup function error");
416 TEST_ASSERT(set_ht == RTE_MEMBER_NO_MATCH &&
417 ret_cache == RTE_MEMBER_NO_MATCH,
418 "key deletion failed");
420 /* Reset vbf for other following tests */
421 rte_member_reset(setsum_vbf);
423 printf("delete success\n");
427 static int test_member_multimatch(void)
429 int ret_ht, ret_vbf, ret_cache;
430 member_set_t set_ids_ht[MAX_MATCH] = {0};
431 member_set_t set_ids_vbf[MAX_MATCH] = {0};
432 member_set_t set_ids_cache[MAX_MATCH] = {0};
434 member_set_t set_ids_ht_m[NUM_SAMPLES][MAX_MATCH] = {{0} };
435 member_set_t set_ids_vbf_m[NUM_SAMPLES][MAX_MATCH] = {{0} };
436 member_set_t set_ids_cache_m[NUM_SAMPLES][MAX_MATCH] = {{0} };
438 uint32_t match_count_ht[NUM_SAMPLES];
439 uint32_t match_count_vbf[NUM_SAMPLES];
440 uint32_t match_count_cache[NUM_SAMPLES];
442 uint32_t num_key_ht = NUM_SAMPLES;
443 uint32_t num_key_vbf = NUM_SAMPLES;
444 uint32_t num_key_cache = NUM_SAMPLES;
446 const void *key_array[NUM_SAMPLES];
450 /* Same key at most inserted 2*entry_per_bucket times for HT mode */
451 for (i = M_MATCH_S; i <= M_MATCH_E; i += M_MATCH_STEP) {
452 for (j = 0; j < NUM_SAMPLES; j++) {
453 ret_ht = rte_member_add(setsum_ht, &keys[j], i);
454 ret_vbf = rte_member_add(setsum_vbf, &keys[j], i);
455 ret_cache = rte_member_add(setsum_cache, &keys[j], i);
457 TEST_ASSERT(ret_ht >= 0 && ret_vbf >= 0 &&
459 "insert function error");
463 /* Single multimatch test */
464 for (i = 0; i < NUM_SAMPLES; i++) {
465 ret_vbf = rte_member_lookup_multi(setsum_vbf, &keys[i],
466 MAX_MATCH, set_ids_vbf);
467 ret_ht = rte_member_lookup_multi(setsum_ht, &keys[i],
468 MAX_MATCH, set_ids_ht);
469 ret_cache = rte_member_lookup_multi(setsum_cache, &keys[i],
470 MAX_MATCH, set_ids_cache);
472 * For cache mode, keys overwrite when signature same.
473 * the multimatch should work like single match.
475 TEST_ASSERT(ret_ht == M_MATCH_CNT && ret_vbf == M_MATCH_CNT &&
477 "single lookup_multi error");
478 TEST_ASSERT(set_ids_cache[0] == M_MATCH_E,
479 "single lookup_multi cache error");
481 for (j = 1; j <= M_MATCH_CNT; j++) {
482 TEST_ASSERT(set_ids_ht[j-1] == j * M_MATCH_STEP - 1 &&
484 j * M_MATCH_STEP - 1,
485 "single multimatch lookup error");
488 printf("lookup single key for multimatch success\n");
490 /* Bulk multimatch test */
491 for (i = 0; i < NUM_SAMPLES; i++)
492 key_array[i] = &keys[i];
493 ret_vbf = rte_member_lookup_multi_bulk(setsum_vbf,
494 &key_array[0], num_key_ht, MAX_MATCH, match_count_vbf,
495 (member_set_t *)set_ids_vbf_m);
497 ret_ht = rte_member_lookup_multi_bulk(setsum_ht,
498 &key_array[0], num_key_vbf, MAX_MATCH, match_count_ht,
499 (member_set_t *)set_ids_ht_m);
501 ret_cache = rte_member_lookup_multi_bulk(setsum_cache,
502 &key_array[0], num_key_cache, MAX_MATCH,
503 match_count_cache, (member_set_t *)set_ids_cache_m);
506 for (j = 0; j < NUM_SAMPLES; j++) {
507 TEST_ASSERT(match_count_ht[j] == M_MATCH_CNT,
508 "bulk multimatch lookup HT match count error");
509 TEST_ASSERT(match_count_vbf[j] == M_MATCH_CNT,
510 "bulk multimatch lookup vBF match count error");
511 TEST_ASSERT(match_count_cache[j] == 1,
512 "bulk multimatch lookup CACHE match count error");
513 TEST_ASSERT(set_ids_cache_m[j][0] == M_MATCH_E,
514 "bulk multimatch lookup CACHE set value error");
516 for (i = 1; i <= M_MATCH_CNT; i++) {
517 TEST_ASSERT(set_ids_ht_m[j][i-1] ==
518 i * M_MATCH_STEP - 1,
519 "bulk multimatch lookup HT set value error");
520 TEST_ASSERT(set_ids_vbf_m[j][i-1] ==
521 i * M_MATCH_STEP - 1,
522 "bulk multimatch lookup vBF set value error");
526 printf("lookup for bulk multimatch success\n");
531 static int key_compare(const void *key1, const void *key2)
533 return memcmp(key1, key2, KEY_SIZE);
537 setup_keys_and_data(void)
542 /* Reset all arrays */
543 for (i = 0; i < KEY_SIZE; i++)
544 generated_keys[0][i] = 0;
546 /* Generate a list of keys, some of which may be duplicates */
547 for (i = 0; i < MAX_ENTRIES; i++) {
548 for (j = 0; j < KEY_SIZE; j++)
549 generated_keys[i][j] = rte_rand() & 0xFF;
552 /* Remove duplicates from the keys array */
555 /* Sort the list of keys to make it easier to find duplicates */
556 qsort(generated_keys, MAX_ENTRIES, KEY_SIZE, key_compare);
558 /* Sift through the list of keys and look for duplicates */
559 int num_duplicates = 0;
560 for (i = 0; i < MAX_ENTRIES - 1; i++) {
561 if (memcmp(generated_keys[i], generated_keys[i + 1],
563 /* This key already exists, try again */
565 for (j = 0; j < KEY_SIZE; j++)
566 generated_keys[i][j] =
570 } while (num_duplicates != 0);
574 add_generated_keys(struct rte_member_setsum *setsum, unsigned int *added_keys)
578 for (*added_keys = 0; ret >= 0 && *added_keys < MAX_ENTRIES;
580 uint16_t set = (rte_rand() & 0xf) + 1;
581 ret = rte_member_add(setsum, &generated_keys[*added_keys], set);
587 add_generated_keys_cache(struct rte_member_setsum *setsum,
588 unsigned int *added_keys)
592 for (*added_keys = 0; ret == 0 && *added_keys < MAX_ENTRIES;
594 uint16_t set = (rte_rand() & 0xf) + 1;
595 ret = rte_member_add(setsum, &generated_keys[*added_keys], set);
601 test_member_loadfactor(void)
604 unsigned int added_keys, average_keys_added = 0;
607 setup_keys_and_data();
609 rte_member_free(setsum_ht);
610 rte_member_free(setsum_cache);
611 rte_member_free(setsum_vbf);
613 params.key_len = KEY_SIZE;
614 params.name = "test_member_ht";
616 params.type = RTE_MEMBER_TYPE_HT;
617 setsum_ht = rte_member_create(¶ms);
619 params.name = "test_member_cache";
621 setsum_cache = rte_member_create(¶ms);
624 if (setsum_ht == NULL || setsum_cache == NULL) {
625 printf("Creation of setsums fail\n");
628 /* Test HT non-cache mode */
629 for (j = 0; j < ITERATIONS; j++) {
630 /* Add random entries until key cannot be added */
631 ret = add_generated_keys(setsum_ht, &added_keys);
632 if (ret != -ENOSPC) {
633 printf("Unexpected error when adding keys\n");
636 average_keys_added += added_keys;
638 /* Reset the table */
639 rte_member_reset(setsum_ht);
641 /* Print a dot to show progress on operations */
646 average_keys_added /= ITERATIONS;
648 printf("\nKeys inserted when no space(non-cache) = %.2f%% (%u/%u)\n",
649 ((double) average_keys_added / params.num_keys * 100),
650 average_keys_added, params.num_keys);
652 /* Test cache mode */
653 added_keys = average_keys_added = 0;
654 for (j = 0; j < ITERATIONS; j++) {
655 /* Add random entries until key cannot be added */
656 ret = add_generated_keys_cache(setsum_cache, &added_keys);
658 printf("Unexpected error when adding keys\n");
661 average_keys_added += added_keys;
663 /* Reset the table */
664 rte_member_reset(setsum_cache);
666 /* Print a dot to show progress on operations */
671 average_keys_added /= ITERATIONS;
673 printf("\nKeys inserted when eviction happens(cache)= %.2f%% (%u/%u)\n",
674 ((double) average_keys_added / params.num_keys * 100),
675 average_keys_added, params.num_keys);
682 rte_member_free(setsum_ht);
683 rte_member_free(setsum_cache);
684 rte_member_free(setsum_vbf);
690 if (test_member_create_bad_param() < 0)
693 if (test_member_find_existing() < 0)
696 if (test_member_create() < 0) {
700 if (test_member_insert() < 0) {
704 if (test_member_lookup() < 0) {
708 if (test_member_delete() < 0) {
712 if (test_member_multimatch() < 0) {
716 if (test_member_loadfactor() < 0) {
717 rte_member_free(setsum_ht);
718 rte_member_free(setsum_cache);
726 #endif /* !RTE_EXEC_ENV_WINDOWS */
728 REGISTER_TEST_COMMAND(member_autotest, test_member);