X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=test%2Ftest%2Ftest_table_tables.c;h=20df2e9225475651d4b691deef03de6de7ef20df;hb=10be59c1e6348509d0d5497b8b143f3da6b2b60a;hp=43280b0c9c5cd0487f39fd1b60430d16304195cc;hpb=4f1c1fa14214ea4b4738a3978b13b1d58d90903b;p=dpdk.git diff --git a/test/test/test_table_tables.c b/test/test/test_table_tables.c index 43280b0c9c..20df2e9225 100644 --- a/test/test/test_table_tables.c +++ b/test/test/test_table_tables.c @@ -1,34 +1,5 @@ -/*- - * BSD LICENSE - * - * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2016 Intel Corporation */ #include @@ -60,16 +31,16 @@ table_test table_tests[] = { memset(key, 0, 32); \ k32 = (uint32_t *) key; \ k32[0] = (value); \ - *signature = pipeline_test_hash(key, 0, 0); \ + *signature = pipeline_test_hash(key, NULL, 0, 0); \ } while (0) unsigned n_table_tests = RTE_DIM(table_tests); /* Function prototypes */ static int -test_table_hash_lru_generic(struct rte_table_ops *ops); +test_table_hash_lru_generic(struct rte_table_ops *ops, uint32_t key_size); static int -test_table_hash_ext_generic(struct rte_table_ops *ops); +test_table_hash_ext_generic(struct rte_table_ops *ops, uint32_t key_size); struct rte_bucket_4_8 { /* Cache line 0 */ @@ -655,7 +626,7 @@ test_table_lpm_ipv6(void) } static int -test_table_hash_lru_generic(struct rte_table_ops *ops) +test_table_hash_lru_generic(struct rte_table_ops *ops, uint32_t key_size) { int status, i; uint64_t expected_mask = 0, result_mask; @@ -667,36 +638,24 @@ test_table_hash_lru_generic(struct rte_table_ops *ops) int key_found; /* Initialize params and create tables */ - struct rte_table_hash_key8_lru_params hash_params = { - .n_entries = 1 << 10, - .f_hash = pipeline_test_hash, - .seed = 0, - .signature_offset = APP_METADATA_OFFSET(1), + struct rte_table_hash_params hash_params = { + .name = "TABLE", + .key_size = key_size, .key_offset = APP_METADATA_OFFSET(32), .key_mask = NULL, + .n_keys = 1 << 10, + .n_buckets = 1 << 10, + .f_hash = pipeline_test_hash, + .seed = 0, }; - hash_params.n_entries = 0; + hash_params.n_keys = 0; table = ops->f_create(&hash_params, 0, 1); if (table != NULL) return -1; - hash_params.n_entries = 1 << 10; - hash_params.signature_offset = APP_METADATA_OFFSET(1); - - table = ops->f_create(&hash_params, 0, 1); - if (table == NULL) - return -2; - - hash_params.signature_offset = APP_METADATA_OFFSET(0); - hash_params.key_offset = APP_METADATA_OFFSET(1); - - table = ops->f_create(&hash_params, 0, 1); - if (table == NULL) - return -3; - - hash_params.key_offset = APP_METADATA_OFFSET(32); + hash_params.n_keys = 1 << 10; hash_params.f_hash = NULL; table = ops->f_create(&hash_params, 0, 1); @@ -770,7 +729,7 @@ test_table_hash_lru_generic(struct rte_table_ops *ops) } static int -test_table_hash_ext_generic(struct rte_table_ops *ops) +test_table_hash_ext_generic(struct rte_table_ops *ops, uint32_t key_size) { int status, i; uint64_t expected_mask = 0, result_mask; @@ -782,35 +741,24 @@ test_table_hash_ext_generic(struct rte_table_ops *ops) void *entry_ptr; /* Initialize params and create tables */ - struct rte_table_hash_key8_ext_params hash_params = { - .n_entries = 1 << 10, - .n_entries_ext = 1 << 4, - .f_hash = pipeline_test_hash, - .seed = 0, - .signature_offset = APP_METADATA_OFFSET(1), + struct rte_table_hash_params hash_params = { + .name = "TABLE", + .key_size = key_size, .key_offset = APP_METADATA_OFFSET(32), .key_mask = NULL, + .n_keys = 1 << 10, + .n_buckets = 1 << 10, + .f_hash = pipeline_test_hash, + .seed = 0, }; - hash_params.n_entries = 0; + hash_params.n_keys = 0; table = ops->f_create(&hash_params, 0, 1); if (table != NULL) return -1; - hash_params.n_entries = 1 << 10; - hash_params.n_entries_ext = 0; - table = ops->f_create(&hash_params, 0, 1); - if (table != NULL) - return -2; - - hash_params.n_entries_ext = 1 << 4; - hash_params.signature_offset = APP_METADATA_OFFSET(1); - table = ops->f_create(&hash_params, 0, 1); - if (table == NULL) - return -2; - - hash_params.signature_offset = APP_METADATA_OFFSET(0); + hash_params.n_keys = 1 << 10; hash_params.key_offset = APP_METADATA_OFFSET(1); table = ops->f_create(&hash_params, 0, 1); @@ -895,20 +843,21 @@ test_table_hash_lru(void) { int status; - status = test_table_hash_lru_generic(&rte_table_hash_key8_lru_ops); - if (status < 0) - return status; - status = test_table_hash_lru_generic( - &rte_table_hash_key8_lru_ops); + &rte_table_hash_key8_lru_ops, + 8); if (status < 0) return status; - status = test_table_hash_lru_generic(&rte_table_hash_key16_lru_dosig_ops); + status = test_table_hash_lru_generic( + &rte_table_hash_key16_lru_ops, + 16); if (status < 0) return status; - status = test_table_hash_lru_generic(&rte_table_hash_key32_lru_ops); + status = test_table_hash_lru_generic( + &rte_table_hash_key32_lru_ops, + 32); if (status < 0) return status; @@ -924,20 +873,15 @@ test_table_hash_ext(void) { int status; - status = test_table_hash_ext_generic(&rte_table_hash_key8_ext_ops); + status = test_table_hash_ext_generic(&rte_table_hash_key8_ext_ops, 8); if (status < 0) return status; - status = test_table_hash_ext_generic( - &rte_table_hash_key8_ext_ops); + status = test_table_hash_ext_generic(&rte_table_hash_key16_ext_ops, 16); if (status < 0) return status; - status = test_table_hash_ext_generic(&rte_table_hash_key16_ext_dosig_ops); - if (status < 0) - return status; - - status = test_table_hash_ext_generic(&rte_table_hash_key32_ext_ops); + status = test_table_hash_ext_generic(&rte_table_hash_key32_ext_ops, 32); if (status < 0) return status; @@ -960,22 +904,23 @@ test_table_hash_cuckoo(void) /* Initialize params and create tables */ struct rte_table_hash_cuckoo_params cuckoo_params = { + .name = "TABLE", .key_size = 32, - .n_keys = 1 << 24, - .f_hash = pipeline_test_hash, - .seed = 0, - .signature_offset = APP_METADATA_OFFSET(0), .key_offset = APP_METADATA_OFFSET(32), - .name = "CUCKOO", + .key_mask = NULL, + .n_keys = 1 << 16, + .n_buckets = 1 << 16, + .f_hash = pipeline_test_hash_cuckoo, + .seed = 0, }; - table = rte_table_hash_cuckoo_dosig_ops.f_create(NULL, 0, entry_size); + table = rte_table_hash_cuckoo_ops.f_create(NULL, 0, entry_size); if (table != NULL) return -1; cuckoo_params.key_size = 0; - table = rte_table_hash_cuckoo_dosig_ops.f_create(&cuckoo_params, + table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, entry_size); if (table != NULL) return -2; @@ -983,7 +928,7 @@ test_table_hash_cuckoo(void) cuckoo_params.key_size = 32; cuckoo_params.n_keys = 0; - table = rte_table_hash_cuckoo_dosig_ops.f_create(&cuckoo_params, + table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, entry_size); if (table != NULL) return -3; @@ -991,32 +936,32 @@ test_table_hash_cuckoo(void) cuckoo_params.n_keys = 1 << 24; cuckoo_params.f_hash = NULL; - table = rte_table_hash_cuckoo_dosig_ops.f_create(&cuckoo_params, + table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, entry_size); if (table != NULL) return -4; - cuckoo_params.f_hash = pipeline_test_hash; + cuckoo_params.f_hash = pipeline_test_hash_cuckoo; cuckoo_params.name = NULL; - table = rte_table_hash_cuckoo_dosig_ops.f_create(&cuckoo_params, + table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, entry_size); if (table != NULL) return -5; cuckoo_params.name = "CUCKOO"; - table = rte_table_hash_cuckoo_dosig_ops.f_create(&cuckoo_params, + table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, entry_size); if (table == NULL) return -6; /* Free */ - status = rte_table_hash_cuckoo_dosig_ops.f_free(table); + status = rte_table_hash_cuckoo_ops.f_free(table); if (status < 0) return -7; - status = rte_table_hash_cuckoo_dosig_ops.f_free(NULL); + status = rte_table_hash_cuckoo_ops.f_free(NULL); if (status == 0) return -8; @@ -1027,60 +972,60 @@ test_table_hash_cuckoo(void) memset(key_cuckoo, 0, 32); kcuckoo[0] = rte_be_to_cpu_32(0xadadadad); - table = rte_table_hash_cuckoo_dosig_ops.f_create(&cuckoo_params, 0, 1); + table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, 1); if (table == NULL) return -9; entry = 'A'; - status = rte_table_hash_cuckoo_dosig_ops.f_add(NULL, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_add(NULL, &key_cuckoo, &entry, &key_found, &entry_ptr); if (status == 0) return -10; - status = rte_table_hash_cuckoo_dosig_ops.f_add(table, NULL, &entry, + status = rte_table_hash_cuckoo_ops.f_add(table, NULL, &entry, &key_found, &entry_ptr); if (status == 0) return -11; - status = rte_table_hash_cuckoo_dosig_ops.f_add(table, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo, NULL, &key_found, &entry_ptr); if (status == 0) return -12; - status = rte_table_hash_cuckoo_dosig_ops.f_add(table, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo, &entry, &key_found, &entry_ptr); if (status != 0) return -13; - status = rte_table_hash_cuckoo_dosig_ops.f_add(table, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo, &entry, &key_found, &entry_ptr); if (status != 0) return -14; /* Delete */ - status = rte_table_hash_cuckoo_dosig_ops.f_delete(NULL, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_delete(NULL, &key_cuckoo, &key_found, NULL); if (status == 0) return -15; - status = rte_table_hash_cuckoo_dosig_ops.f_delete(table, NULL, + status = rte_table_hash_cuckoo_ops.f_delete(table, NULL, &key_found, NULL); if (status == 0) return -16; - status = rte_table_hash_cuckoo_dosig_ops.f_delete(table, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_delete(table, &key_cuckoo, &key_found, NULL); if (status != 0) return -17; - status = rte_table_hash_cuckoo_dosig_ops.f_delete(table, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_delete(table, &key_cuckoo, &key_found, NULL); if (status != -ENOENT) return -18; /* Traffic flow */ entry = 'A'; - status = rte_table_hash_cuckoo_dosig_ops.f_add(table, &key_cuckoo, + status = rte_table_hash_cuckoo_ops.f_add(table, &key_cuckoo, &entry, &key_found, &entry_ptr); if (status < 0) @@ -1093,7 +1038,7 @@ test_table_hash_cuckoo(void) } else PREPARE_PACKET(mbufs[i], 0xadadadab); - rte_table_hash_cuckoo_dosig_ops.f_lookup(table, mbufs, -1, + rte_table_hash_cuckoo_ops.f_lookup(table, mbufs, -1, &result_mask, (void **)entries); if (result_mask != expected_mask) return -20; @@ -1102,7 +1047,7 @@ test_table_hash_cuckoo(void) for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++) rte_pktmbuf_free(mbufs[i]); - status = rte_table_hash_cuckoo_dosig_ops.f_free(table); + status = rte_table_hash_cuckoo_ops.f_free(table); return 0; }