4 * Copyright(c) 2010-2014 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[] = {
51 #define PREPARE_PACKET(mbuf, value) do { \
52 uint32_t *k32, *signature; \
54 mbuf = rte_pktmbuf_alloc(pool); \
55 signature = RTE_MBUF_METADATA_UINT32_PTR(mbuf, 0); \
56 key = RTE_MBUF_METADATA_UINT8_PTR(mbuf, 32); \
58 k32 = (uint32_t *) key; \
60 *signature = pipeline_test_hash(key, 0, 0); \
63 unsigned n_table_tests = RTE_DIM(table_tests);
65 /* Function prototypes */
67 test_table_hash_lru_generic(struct rte_table_ops *ops);
69 test_table_hash_ext_generic(struct rte_table_ops *ops);
71 struct rte_bucket_4_8 {
75 struct rte_bucket_4_8 *next;
82 #if RTE_TABLE_HASH_LRU_STRATEGY == 3
83 uint64_t shuffles = 0xfffffffdfffbfff9ULL;
85 uint64_t shuffles = 0x0003000200010000ULL;
88 static int test_lru_update(void)
90 struct rte_bucket_4_8 b;
91 struct rte_bucket_4_8 *bucket;
98 printf("---------------------------\n");
99 printf("Testing lru_update macro...\n");
100 printf("---------------------------\n");
103 #if RTE_TABLE_HASH_LRU_STRATEGY == 3
104 bucket->lru_list = 0xFFFFFFFFFFFFFFFFULL;
106 bucket->lru_list = 0x0000000100020003ULL;
109 for (j = 0; j < iterations; j++)
110 for (i = 0; i < 9; i++) {
111 uint32_t idx = i >> 1;
112 lru_update(bucket, idx);
113 pos = lru_pos(bucket);
115 printf("%s: %d lru_list=%016"PRIx64", upd=%d, "
117 __func__, i, bucket->lru_list, i>>1, pos);
120 if (bucket->lru_list != shuffles) {
121 printf("%s: ERROR: %d lru_list=%016"PRIx64", expected %016"
123 __func__, i, bucket->lru_list, shuffles);
126 printf("%s: output checksum of results =%d\n",
130 printf("%s: ERROR output checksum of results =%d expected %d\n",
131 __func__, poss, 126);
138 uint64_t sc_start = rte_rdtsc();
139 iterations = 100000000;
141 for (j = 0; j < iterations; j++) {
142 for (i = 0; i < 4; i++) {
143 lru_update(bucket, i);
144 pos |= bucket->lru_list;
147 uint64_t sc_end = rte_rdtsc();
149 printf("%s: output checksum of results =%llu\n",
150 __func__, (long long unsigned int)pos);
151 printf("%s: start=%016"PRIx64", end=%016"PRIx64"\n",
152 __func__, sc_start, sc_end);
153 printf("\nlru_update: %lu cycles per loop iteration.\n\n",
154 (long unsigned int)((sc_end-sc_start)/(iterations*4)));
161 test_table_stub(void)
164 uint64_t expected_mask = 0, result_mask;
165 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
167 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
170 table = rte_table_stub_ops.f_create(NULL, 0, 1);
175 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
177 PREPARE_PACKET(mbufs[i], 0xadadadad);
179 PREPARE_PACKET(mbufs[i], 0xadadadab);
182 rte_table_stub_ops.f_lookup(table, mbufs, -1,
183 &result_mask, (void **)entries);
184 if (result_mask != expected_mask)
188 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
189 rte_pktmbuf_free(mbufs[i]);
195 test_table_array(void)
198 uint64_t result_mask;
199 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
201 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
206 /* Initialize params and create tables */
207 struct rte_table_array_params array_params = {
212 table = rte_table_array_ops.f_create(NULL, 0, 1);
216 array_params.n_entries = 0;
218 table = rte_table_array_ops.f_create(&array_params, 0, 1);
222 array_params.n_entries = 7;
224 table = rte_table_array_ops.f_create(&array_params, 0, 1);
228 array_params.n_entries = 1 << 24;
229 array_params.offset = 1;
231 table = rte_table_array_ops.f_create(&array_params, 0, 1);
235 array_params.offset = 32;
237 table = rte_table_array_ops.f_create(&array_params, 0, 1);
242 status = rte_table_array_ops.f_free(table);
246 status = rte_table_array_ops.f_free(NULL);
251 struct rte_table_array_key array_key_1 = {
254 struct rte_table_array_key array_key_2 = {
260 table = rte_table_array_ops.f_create(&array_params, 0, 1);
264 status = rte_table_array_ops.f_add(NULL, (void *) &array_key_1, &entry1,
265 &key_found, &entry_ptr);
269 status = rte_table_array_ops.f_add(table, (void *) &array_key_1, NULL,
270 &key_found, &entry_ptr);
274 status = rte_table_array_ops.f_add(table, (void *) &array_key_1,
275 &entry1, &key_found, &entry_ptr);
280 status = rte_table_array_ops.f_add(table, (void *) &array_key_2,
281 &entry2, &key_found, &entry_ptr);
285 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
287 PREPARE_PACKET(mbufs[i], 10);
289 PREPARE_PACKET(mbufs[i], 20);
291 rte_table_array_ops.f_lookup(table, mbufs, -1,
292 &result_mask, (void **)entries);
294 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
295 if (i % 2 == 0 && *entries[i] != 'A')
298 if (i % 2 == 1 && *entries[i] != 'B')
302 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
303 rte_pktmbuf_free(mbufs[i]);
305 status = rte_table_array_ops.f_free(table);
314 uint64_t expected_mask = 0, result_mask;
315 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
317 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
321 uint32_t entry_size = 1;
323 /* Initialize params and create tables */
324 struct rte_table_lpm_params lpm_params = {
326 .entry_unique_size = entry_size,
330 table = rte_table_lpm_ops.f_create(NULL, 0, entry_size);
334 lpm_params.n_rules = 0;
336 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
340 lpm_params.n_rules = 1 << 24;
341 lpm_params.offset = 32;
342 lpm_params.entry_unique_size = 0;
344 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
348 lpm_params.entry_unique_size = entry_size + 1;
350 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
354 lpm_params.entry_unique_size = entry_size;
356 table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
361 status = rte_table_lpm_ops.f_free(table);
365 status = rte_table_lpm_ops.f_free(NULL);
370 struct rte_table_lpm_key lpm_key;
371 lpm_key.ip = 0xadadadad;
373 table = rte_table_lpm_ops.f_create(&lpm_params, 0, 1);
377 status = rte_table_lpm_ops.f_add(NULL, &lpm_key, &entry, &key_found,
382 status = rte_table_lpm_ops.f_add(table, NULL, &entry, &key_found,
387 status = rte_table_lpm_ops.f_add(table, &lpm_key, NULL, &key_found,
393 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
399 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
405 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
411 status = rte_table_lpm_ops.f_delete(NULL, &lpm_key, &key_found, NULL);
415 status = rte_table_lpm_ops.f_delete(table, NULL, &key_found, NULL);
420 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
425 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
430 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
434 status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
440 status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
445 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
447 expected_mask |= (uint64_t)1 << i;
448 PREPARE_PACKET(mbufs[i], 0xadadadad);
450 PREPARE_PACKET(mbufs[i], 0xadadadab);
452 rte_table_lpm_ops.f_lookup(table, mbufs, -1,
453 &result_mask, (void **)entries);
454 if (result_mask != expected_mask)
458 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
459 rte_pktmbuf_free(mbufs[i]);
461 status = rte_table_lpm_ops.f_free(table);
467 test_table_lpm_ipv6(void)
470 uint64_t expected_mask = 0, result_mask;
471 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
473 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
477 uint32_t entry_size = 1;
479 /* Initialize params and create tables */
480 struct rte_table_lpm_ipv6_params lpm_params = {
482 .number_tbl8s = 1 << 21,
483 .entry_unique_size = entry_size,
487 table = rte_table_lpm_ipv6_ops.f_create(NULL, 0, entry_size);
491 lpm_params.n_rules = 0;
493 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
497 lpm_params.n_rules = 1 << 24;
498 lpm_params.number_tbl8s = 0;
499 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
503 lpm_params.number_tbl8s = 1 << 21;
504 lpm_params.entry_unique_size = 0;
505 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
509 lpm_params.entry_unique_size = entry_size + 1;
510 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
514 lpm_params.entry_unique_size = entry_size;
515 lpm_params.offset = 32;
517 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
522 status = rte_table_lpm_ipv6_ops.f_free(table);
526 status = rte_table_lpm_ipv6_ops.f_free(NULL);
531 struct rte_table_lpm_ipv6_key lpm_key;
533 lpm_key.ip[0] = 0xad;
534 lpm_key.ip[1] = 0xad;
535 lpm_key.ip[2] = 0xad;
536 lpm_key.ip[3] = 0xad;
538 table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
542 status = rte_table_lpm_ipv6_ops.f_add(NULL, &lpm_key, &entry,
543 &key_found, &entry_ptr);
547 status = rte_table_lpm_ipv6_ops.f_add(table, NULL, &entry, &key_found,
552 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, NULL, &key_found,
558 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
559 &key_found, &entry_ptr);
564 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
565 &key_found, &entry_ptr);
570 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
571 &key_found, &entry_ptr);
576 status = rte_table_lpm_ipv6_ops.f_delete(NULL, &lpm_key, &key_found,
581 status = rte_table_lpm_ipv6_ops.f_delete(table, NULL, &key_found, NULL);
586 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
592 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
598 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
603 status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
610 status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
611 &key_found, &entry_ptr);
615 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
617 expected_mask |= (uint64_t)1 << i;
618 PREPARE_PACKET(mbufs[i], 0xadadadad);
620 PREPARE_PACKET(mbufs[i], 0xadadadab);
622 rte_table_lpm_ipv6_ops.f_lookup(table, mbufs, -1,
623 &result_mask, (void **)entries);
624 if (result_mask != expected_mask)
628 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
629 rte_pktmbuf_free(mbufs[i]);
631 status = rte_table_lpm_ipv6_ops.f_free(table);
637 test_table_hash_lru_generic(struct rte_table_ops *ops)
640 uint64_t expected_mask = 0, result_mask;
641 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
643 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
648 /* Initialize params and create tables */
649 struct rte_table_hash_key8_lru_params hash_params = {
650 .n_entries = 1 << 10,
651 .f_hash = pipeline_test_hash,
653 .signature_offset = 1,
657 hash_params.n_entries = 0;
659 table = ops->f_create(&hash_params, 0, 1);
663 hash_params.n_entries = 1 << 10;
664 hash_params.signature_offset = 1;
666 table = ops->f_create(&hash_params, 0, 1);
670 hash_params.signature_offset = 0;
671 hash_params.key_offset = 1;
673 table = ops->f_create(&hash_params, 0, 1);
677 hash_params.key_offset = 32;
678 hash_params.f_hash = NULL;
680 table = ops->f_create(&hash_params, 0, 1);
684 hash_params.f_hash = pipeline_test_hash;
686 table = ops->f_create(&hash_params, 0, 1);
691 status = ops->f_free(table);
695 status = ops->f_free(NULL);
701 uint32_t *k32 = (uint32_t *) &key;
704 k32[0] = rte_be_to_cpu_32(0xadadadad);
706 table = ops->f_create(&hash_params, 0, 1);
711 status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
716 status = ops->f_delete(table, &key, &key_found, NULL);
720 status = ops->f_delete(table, &key, &key_found, NULL);
726 status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
730 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
732 expected_mask |= (uint64_t)1 << i;
733 PREPARE_PACKET(mbufs[i], 0xadadadad);
735 PREPARE_PACKET(mbufs[i], 0xadadadab);
737 ops->f_lookup(table, mbufs, -1, &result_mask, (void **)entries);
738 if (result_mask != expected_mask)
742 for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
743 rte_pktmbuf_free(mbufs[i]);
745 status = ops->f_free(table);
751 test_table_hash_ext_generic(struct rte_table_ops *ops)
754 uint64_t expected_mask = 0, result_mask;
755 struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
757 char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
762 /* Initialize params and create tables */
763 struct rte_table_hash_key8_ext_params hash_params = {
764 .n_entries = 1 << 10,
765 .n_entries_ext = 1 << 4,
766 .f_hash = pipeline_test_hash,
768 .signature_offset = 1,
772 hash_params.n_entries = 0;
774 table = ops->f_create(&hash_params, 0, 1);
778 hash_params.n_entries = 1 << 10;
779 hash_params.n_entries_ext = 0;
780 table = ops->f_create(&hash_params, 0, 1);
784 hash_params.n_entries_ext = 1 << 4;
785 hash_params.signature_offset = 1;
786 table = ops->f_create(&hash_params, 0, 1);
790 hash_params.signature_offset = 0;
791 hash_params.key_offset = 1;
793 table = ops->f_create(&hash_params, 0, 1);
797 hash_params.key_offset = 32;
798 hash_params.f_hash = NULL;
800 table = ops->f_create(&hash_params, 0, 1);
804 hash_params.f_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(&rte_table_hash_key8_lru_ops);
879 status = test_table_hash_lru_generic(
880 &rte_table_hash_key8_lru_dosig_ops);
884 status = test_table_hash_lru_generic(&rte_table_hash_key16_lru_ops);
888 status = test_table_hash_lru_generic(&rte_table_hash_key32_lru_ops);
892 status = test_lru_update();
900 test_table_hash_ext(void)
904 status = test_table_hash_ext_generic(&rte_table_hash_key8_ext_ops);
908 status = test_table_hash_ext_generic(
909 &rte_table_hash_key8_ext_dosig_ops);
913 status = test_table_hash_ext_generic(&rte_table_hash_key16_ext_ops);
917 status = test_table_hash_ext_generic(&rte_table_hash_key32_ext_ops);