4 * Copyright(c) 2010-2016 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
35 #include <rte_byteorder.h>
36 #include <rte_table_lpm_ipv6.h>
38 #include <rte_cycles.h>
39 #include "test_table_tables.h"
40 #include "test_table.h"
42 table_test table_tests[] = {
49 test_table_hash_cuckoo,
52 #define PREPARE_PACKET(mbuf, value) do { \
53 uint32_t *k32, *signature; \
55 mbuf = rte_pktmbuf_alloc(pool); \
56 signature = RTE_MBUF_METADATA_UINT32_PTR(mbuf, \
57 APP_METADATA_OFFSET(0)); \
58 key = RTE_MBUF_METADATA_UINT8_PTR(mbuf, \
59 APP_METADATA_OFFSET(32)); \
61 k32 = (uint32_t *) key; \
63 *signature = pipeline_test_hash(key, 0, 0); \
66 unsigned n_table_tests = RTE_DIM(table_tests);
68 /* Function prototypes */
70 test_table_hash_lru_generic(struct rte_table_ops *ops, uint32_t key_size);
72 test_table_hash_ext_generic(struct rte_table_ops *ops, uint32_t key_size);
74 struct rte_bucket_4_8 {
78 struct rte_bucket_4_8 *next;
85 #if RTE_TABLE_HASH_LRU_STRATEGY == 3
86 uint64_t shuffles = 0xfffffffdfffbfff9ULL;
88 uint64_t shuffles = 0x0003000200010000ULL;
91 static int test_lru_update(void)
93 struct rte_bucket_4_8 b;
94 struct rte_bucket_4_8 *bucket;
101 printf("---------------------------\n");
102 printf("Testing lru_update macro...\n");
103 printf("---------------------------\n");
106 #if RTE_TABLE_HASH_LRU_STRATEGY == 3
107 bucket->lru_list = 0xFFFFFFFFFFFFFFFFULL;
109 bucket->lru_list = 0x0000000100020003ULL;
112 for (j = 0; j < iterations; j++)
113 for (i = 0; i < 9; i++) {
114 uint32_t idx = i >> 1;
115 lru_update(bucket, idx);
116 pos = lru_pos(bucket);
118 printf("%s: %d lru_list=%016"PRIx64", upd=%d, "
120 __func__, i, bucket->lru_list, i>>1, pos);
123 if (bucket->lru_list != shuffles) {
124 printf("%s: ERROR: %d lru_list=%016"PRIx64", expected %016"
126 __func__, i, bucket->lru_list, shuffles);
129 printf("%s: output checksum of results =%d\n",
133 printf("%s: ERROR output checksum of results =%d expected %d\n",
134 __func__, poss, 126);
141 uint64_t sc_start = rte_rdtsc();
142 iterations = 100000000;
144 for (j = 0; j < iterations; j++) {
145 for (i = 0; i < 4; i++) {
146 lru_update(bucket, i);
147 pos |= bucket->lru_list;
150 uint64_t sc_end = rte_rdtsc();
152 printf("%s: output checksum of results =%llu\n",
153 __func__, (long long unsigned int)pos);
154 printf("%s: start=%016"PRIx64", end=%016"PRIx64"\n",
155 __func__, sc_start, sc_end);
156 printf("\nlru_update: %lu cycles per loop iteration.\n\n",
157 (long unsigned int)((sc_end-sc_start)/(iterations*4)));
164 test_table_stub(void)
167 uint64_t expected_mask = 0, result_mask;
168 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
170 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
173 table = rte_table_stub_ops.f_create(NULL, 0, 1);
178 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
180 PREPARE_PACKET(mbufs[i], 0xadadadad);
182 PREPARE_PACKET(mbufs[i], 0xadadadab);
185 rte_table_stub_ops.f_lookup(table, mbufs, -1,
186 &result_mask, (void **)entries);
187 if (result_mask != expected_mask)
191 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
192 rte_pktmbuf_free(mbufs[i]);
198 test_table_array(void)
201 uint64_t result_mask;
202 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
204 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
209 /* Initialize params and create tables */
210 struct rte_table_array_params array_params = {
212 .offset = APP_METADATA_OFFSET(1)
215 table = rte_table_array_ops.f_create(NULL, 0, 1);
219 array_params.n_entries = 0;
221 table = rte_table_array_ops.f_create(&array_params, 0, 1);
225 array_params.n_entries = 7;
227 table = rte_table_array_ops.f_create(&array_params, 0, 1);
231 array_params.n_entries = 1 << 24;
232 array_params.offset = APP_METADATA_OFFSET(1);
234 table = rte_table_array_ops.f_create(&array_params, 0, 1);
238 array_params.offset = APP_METADATA_OFFSET(32);
240 table = rte_table_array_ops.f_create(&array_params, 0, 1);
245 status = rte_table_array_ops.f_free(table);
249 status = rte_table_array_ops.f_free(NULL);
254 struct rte_table_array_key array_key_1 = {
257 struct rte_table_array_key array_key_2 = {
263 table = rte_table_array_ops.f_create(&array_params, 0, 1);
267 status = rte_table_array_ops.f_add(NULL, (void *) &array_key_1, &entry1,
268 &key_found, &entry_ptr);
272 status = rte_table_array_ops.f_add(table, (void *) &array_key_1, NULL,
273 &key_found, &entry_ptr);
277 status = rte_table_array_ops.f_add(table, (void *) &array_key_1,
278 &entry1, &key_found, &entry_ptr);
283 status = rte_table_array_ops.f_add(table, (void *) &array_key_2,
284 &entry2, &key_found, &entry_ptr);
288 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
290 PREPARE_PACKET(mbufs[i], 10);
292 PREPARE_PACKET(mbufs[i], 20);
294 rte_table_array_ops.f_lookup(table, mbufs, -1,
295 &result_mask, (void **)entries);
297 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
298 if (i % 2 == 0 && *entries[i] != 'A')
301 if (i % 2 == 1 && *entries[i] != 'B')
305 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
306 rte_pktmbuf_free(mbufs[i]);
308 status = rte_table_array_ops.f_free(table);
317 uint64_t expected_mask = 0, result_mask;
318 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
320 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
324 uint32_t entry_size = 1;
326 /* Initialize params and create tables */
327 struct rte_table_lpm_params lpm_params = {
330 .number_tbl8s = 1 << 8,
332 .entry_unique_size = entry_size,
333 .offset = APP_METADATA_OFFSET(1)
336 table = rte_table_lpm_ops.f_create(NULL, 0, entry_size);
340 lpm_params.name = NULL;
342 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
346 lpm_params.name = "LPM";
347 lpm_params.n_rules = 0;
349 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
353 lpm_params.n_rules = 1 << 24;
354 lpm_params.offset = APP_METADATA_OFFSET(32);
355 lpm_params.entry_unique_size = 0;
357 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
361 lpm_params.entry_unique_size = entry_size + 1;
363 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
367 lpm_params.entry_unique_size = entry_size;
369 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
374 status = rte_table_lpm_ops.f_free(table);
378 status = rte_table_lpm_ops.f_free(NULL);
383 struct rte_table_lpm_key lpm_key;
384 lpm_key.ip = 0xadadadad;
386 table = rte_table_lpm_ops.f_create(&lpm_params, 0, 1);
390 status = rte_table_lpm_ops.f_add(NULL, &lpm_key, &entry, &key_found,
395 status = rte_table_lpm_ops.f_add(table, NULL, &entry, &key_found,
400 status = rte_table_lpm_ops.f_add(table, &lpm_key, NULL, &key_found,
406 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
412 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
418 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
424 status = rte_table_lpm_ops.f_delete(NULL, &lpm_key, &key_found, NULL);
428 status = rte_table_lpm_ops.f_delete(table, NULL, &key_found, NULL);
433 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
438 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
443 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
447 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
453 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
458 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
460 expected_mask |= (uint64_t)1 << i;
461 PREPARE_PACKET(mbufs[i], 0xadadadad);
463 PREPARE_PACKET(mbufs[i], 0xadadadab);
465 rte_table_lpm_ops.f_lookup(table, mbufs, -1,
466 &result_mask, (void **)entries);
467 if (result_mask != expected_mask)
471 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
472 rte_pktmbuf_free(mbufs[i]);
474 status = rte_table_lpm_ops.f_free(table);
480 test_table_lpm_ipv6(void)
483 uint64_t expected_mask = 0, result_mask;
484 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
486 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
490 uint32_t entry_size = 1;
492 /* Initialize params and create tables */
493 struct rte_table_lpm_ipv6_params lpm_params = {
496 .number_tbl8s = 1 << 21,
497 .entry_unique_size = entry_size,
498 .offset = APP_METADATA_OFFSET(32)
501 table = rte_table_lpm_ipv6_ops.f_create(NULL, 0, entry_size);
505 lpm_params.name = NULL;
507 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
511 lpm_params.name = "LPM";
512 lpm_params.n_rules = 0;
514 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
518 lpm_params.n_rules = 1 << 24;
519 lpm_params.number_tbl8s = 0;
520 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
524 lpm_params.number_tbl8s = 1 << 21;
525 lpm_params.entry_unique_size = 0;
526 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
530 lpm_params.entry_unique_size = entry_size + 1;
531 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
535 lpm_params.entry_unique_size = entry_size;
536 lpm_params.offset = APP_METADATA_OFFSET(32);
538 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
543 status = rte_table_lpm_ipv6_ops.f_free(table);
547 status = rte_table_lpm_ipv6_ops.f_free(NULL);
552 struct rte_table_lpm_ipv6_key lpm_key;
554 lpm_key.ip[0] = 0xad;
555 lpm_key.ip[1] = 0xad;
556 lpm_key.ip[2] = 0xad;
557 lpm_key.ip[3] = 0xad;
559 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
563 status = rte_table_lpm_ipv6_ops.f_add(NULL, &lpm_key, &entry,
564 &key_found, &entry_ptr);
568 status = rte_table_lpm_ipv6_ops.f_add(table, NULL, &entry, &key_found,
573 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, NULL, &key_found,
579 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
580 &key_found, &entry_ptr);
585 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
586 &key_found, &entry_ptr);
591 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
592 &key_found, &entry_ptr);
597 status = rte_table_lpm_ipv6_ops.f_delete(NULL, &lpm_key, &key_found,
602 status = rte_table_lpm_ipv6_ops.f_delete(table, NULL, &key_found, NULL);
607 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
613 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
619 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
624 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
631 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
632 &key_found, &entry_ptr);
636 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
638 expected_mask |= (uint64_t)1 << i;
639 PREPARE_PACKET(mbufs[i], 0xadadadad);
641 PREPARE_PACKET(mbufs[i], 0xadadadab);
643 rte_table_lpm_ipv6_ops.f_lookup(table, mbufs, -1,
644 &result_mask, (void **)entries);
645 if (result_mask != expected_mask)
649 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
650 rte_pktmbuf_free(mbufs[i]);
652 status = rte_table_lpm_ipv6_ops.f_free(table);
658 test_table_hash_lru_generic(struct rte_table_ops *ops, uint32_t key_size)
661 uint64_t expected_mask = 0, result_mask;
662 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
664 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
669 /* Initialize params and create tables */
670 struct rte_table_hash_params hash_params = {
672 .key_size = key_size,
673 .key_offset = APP_METADATA_OFFSET(32),
676 .n_buckets = 1 << 10,
677 .f_hash = (rte_table_hash_op_hash)pipeline_test_hash,
681 hash_params.n_keys = 0;
683 table = ops->f_create(&hash_params, 0, 1);
687 hash_params.n_keys = 1 << 10;
688 hash_params.f_hash = NULL;
690 table = ops->f_create(&hash_params, 0, 1);
694 hash_params.f_hash = (rte_table_hash_op_hash)pipeline_test_hash;
696 table = ops->f_create(&hash_params, 0, 1);
701 status = ops->f_free(table);
705 status = ops->f_free(NULL);
711 uint32_t *k32 = (uint32_t *) &key;
714 k32[0] = rte_be_to_cpu_32(0xadadadad);
716 table = ops->f_create(&hash_params, 0, 1);
721 status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
726 status = ops->f_delete(table, &key, &key_found, NULL);
730 status = ops->f_delete(table, &key, &key_found, NULL);
736 status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
740 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
742 expected_mask |= (uint64_t)1 << i;
743 PREPARE_PACKET(mbufs[i], 0xadadadad);
745 PREPARE_PACKET(mbufs[i], 0xadadadab);
747 ops->f_lookup(table, mbufs, -1, &result_mask, (void **)entries);
748 if (result_mask != expected_mask)
752 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
753 rte_pktmbuf_free(mbufs[i]);
755 status = ops->f_free(table);
761 test_table_hash_ext_generic(struct rte_table_ops *ops, uint32_t key_size)
764 uint64_t expected_mask = 0, result_mask;
765 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
767 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
772 /* Initialize params and create tables */
773 struct rte_table_hash_params hash_params = {
775 .key_size = key_size,
776 .key_offset = APP_METADATA_OFFSET(32),
779 .n_buckets = 1 << 10,
780 .f_hash = (rte_table_hash_op_hash)pipeline_test_hash,
784 hash_params.n_keys = 0;
786 table = ops->f_create(&hash_params, 0, 1);
790 hash_params.n_keys = 1 << 10;
791 hash_params.key_offset = APP_METADATA_OFFSET(1);
793 table = ops->f_create(&hash_params, 0, 1);
797 hash_params.key_offset = APP_METADATA_OFFSET(32);
798 hash_params.f_hash = NULL;
800 table = ops->f_create(&hash_params, 0, 1);
804 hash_params.f_hash = (rte_table_hash_op_hash)pipeline_test_hash;
806 table = ops->f_create(&hash_params, 0, 1);
811 status = ops->f_free(table);
815 status = ops->f_free(NULL);
821 uint32_t *k32 = (uint32_t *) &key;
824 k32[0] = rte_be_to_cpu_32(0xadadadad);
826 table = ops->f_create(&hash_params, 0, 1);
831 status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
836 status = ops->f_delete(table, &key, &key_found, NULL);
840 status = ops->f_delete(table, &key, &key_found, NULL);
846 status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
850 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
852 expected_mask |= (uint64_t)1 << i;
853 PREPARE_PACKET(mbufs[i], 0xadadadad);
855 PREPARE_PACKET(mbufs[i], 0xadadadab);
857 ops->f_lookup(table, mbufs, -1, &result_mask, (void **)entries);
858 if (result_mask != expected_mask)
862 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
863 rte_pktmbuf_free(mbufs[i]);
865 status = ops->f_free(table);
871 test_table_hash_lru(void)
875 status = test_table_hash_lru_generic(
876 &rte_table_hash_key8_lru_ops,
881 status = test_table_hash_lru_generic(
882 &rte_table_hash_key16_lru_ops,
887 status = test_table_hash_lru_generic(
888 &rte_table_hash_key32_lru_ops,
893 status = test_lru_update();
901 test_table_hash_ext(void)
905 status = test_table_hash_ext_generic(&rte_table_hash_key8_ext_ops, 8);
909 status = test_table_hash_ext_generic(&rte_table_hash_key16_ext_ops, 16);
913 status = test_table_hash_ext_generic(&rte_table_hash_key32_ext_ops, 32);
922 test_table_hash_cuckoo(void)
925 uint64_t expected_mask = 0, result_mask;
926 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
928 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
932 uint32_t entry_size = 1;
934 /* Initialize params and create tables */
935 struct rte_table_hash_params cuckoo_params = {
938 .key_offset = APP_METADATA_OFFSET(32),
941 .n_buckets = 1 << 16,
942 .f_hash = (rte_table_hash_op_hash)pipeline_test_hash,
946 table = rte_table_hash_cuckoo_ops.f_create(NULL, 0, entry_size);
950 cuckoo_params.key_size = 0;
952 table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params,
957 cuckoo_params.key_size = 32;
958 cuckoo_params.n_keys = 0;
960 table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params,
965 cuckoo_params.n_keys = 1 << 24;
966 cuckoo_params.f_hash = NULL;
968 table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params,
973 cuckoo_params.f_hash = (rte_table_hash_op_hash)pipeline_test_hash;
974 cuckoo_params.name = NULL;
976 table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params,
981 cuckoo_params.name = "CUCKOO";
983 table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params,
989 status = rte_table_hash_cuckoo_ops.f_free(table);
993 status = rte_table_hash_cuckoo_ops.f_free(NULL);
998 uint8_t key_cuckoo[32];
999 uint32_t *kcuckoo = (uint32_t *) &key_cuckoo;
1001 memset(key_cuckoo, 0, 32);
1002 kcuckoo[0] = rte_be_to_cpu_32(0xadadadad);
1004 table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, 1);
1009 status = rte_table_hash_cuckoo_ops.f_add(NULL, &key_cuckoo,
1010 &entry, &key_found, &entry_ptr);
1014 status = rte_table_hash_cuckoo_ops.f_add(table, NULL, &entry,
1015 &key_found, &entry_ptr);
1019 status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo,
1020 NULL, &key_found, &entry_ptr);
1024 status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo,
1025 &entry, &key_found, &entry_ptr);
1029 status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo,
1030 &entry, &key_found, &entry_ptr);
1035 status = rte_table_hash_cuckoo_ops.f_delete(NULL, &key_cuckoo,
1040 status = rte_table_hash_cuckoo_ops.f_delete(table, NULL,
1045 status = rte_table_hash_cuckoo_ops.f_delete(table, &key_cuckoo,
1050 status = rte_table_hash_cuckoo_ops.f_delete(table, &key_cuckoo,
1052 if (status != -ENOENT)
1057 status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo,
1063 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
1065 expected_mask |= (uint64_t)1 << i;
1066 PREPARE_PACKET(mbufs[i], 0xadadadad);
1068 PREPARE_PACKET(mbufs[i], 0xadadadab);
1070 rte_table_hash_cuckoo_ops.f_lookup(table, mbufs, -1,
1071 &result_mask, (void **)entries);
1072 if (result_mask != expected_mask)
1075 /* Free resources */
1076 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
1077 rte_pktmbuf_free(mbufs[i]);
1079 status = rte_table_hash_cuckoo_ops.f_free(table);