-/*-
- * 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 <string.h>
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 */
}
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;
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);
}
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;
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);
{
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;
{
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;
uint32_t entry_size = 1;
/* Initialize params and create tables */
- struct rte_table_hash_cuckoo_params cuckoo_params = {
+ struct rte_table_hash_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 = (rte_table_hash_op_hash)pipeline_test_hash,
+ .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;
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;
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.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;
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)
} 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;
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;
}
git.droids-corp.org / dpdk.git / blobdiff