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