168fd260d5
This patch reduces the memory footprint of tables for the unit test. Lower memory footprint means the test now passes when trying to allocate the tables. This patch is mainly to make table_autotest pass in CI. Signed-off-by: Michael Santana <msantana@redhat.com> Acked-by: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
1055 lines
23 KiB
C
1055 lines
23 KiB
C
/* SPDX-License-Identifier: BSD-3-Clause
|
|
* Copyright(c) 2010-2016 Intel Corporation
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <rte_byteorder.h>
|
|
#include <rte_table_lpm_ipv6.h>
|
|
#include <rte_lru.h>
|
|
#include <rte_cycles.h>
|
|
#include "test_table_tables.h"
|
|
#include "test_table.h"
|
|
|
|
table_test table_tests[] = {
|
|
test_table_stub,
|
|
test_table_array,
|
|
test_table_lpm,
|
|
test_table_lpm_ipv6,
|
|
test_table_hash_lru,
|
|
test_table_hash_ext,
|
|
test_table_hash_cuckoo,
|
|
};
|
|
|
|
#define PREPARE_PACKET(mbuf, value) do { \
|
|
uint32_t *k32, *signature; \
|
|
uint8_t *key; \
|
|
mbuf = rte_pktmbuf_alloc(pool); \
|
|
signature = RTE_MBUF_METADATA_UINT32_PTR(mbuf, \
|
|
APP_METADATA_OFFSET(0)); \
|
|
key = RTE_MBUF_METADATA_UINT8_PTR(mbuf, \
|
|
APP_METADATA_OFFSET(32)); \
|
|
memset(key, 0, 32); \
|
|
k32 = (uint32_t *) key; \
|
|
k32[0] = (value); \
|
|
*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, uint32_t key_size);
|
|
static int
|
|
test_table_hash_ext_generic(struct rte_table_ops *ops, uint32_t key_size);
|
|
|
|
struct rte_bucket_4_8 {
|
|
/* Cache line 0 */
|
|
uint64_t signature;
|
|
uint64_t lru_list;
|
|
struct rte_bucket_4_8 *next;
|
|
uint64_t next_valid;
|
|
uint64_t key[4];
|
|
/* Cache line 1 */
|
|
uint8_t data[0];
|
|
};
|
|
|
|
#if RTE_TABLE_HASH_LRU_STRATEGY == 3
|
|
uint64_t shuffles = 0xfffffffdfffbfff9ULL;
|
|
#else
|
|
uint64_t shuffles = 0x0003000200010000ULL;
|
|
#endif
|
|
|
|
static int test_lru_update(void)
|
|
{
|
|
struct rte_bucket_4_8 b;
|
|
struct rte_bucket_4_8 *bucket;
|
|
uint32_t i;
|
|
uint64_t pos;
|
|
uint64_t iterations;
|
|
uint64_t j;
|
|
int poss;
|
|
|
|
printf("---------------------------\n");
|
|
printf("Testing lru_update macro...\n");
|
|
printf("---------------------------\n");
|
|
bucket = &b;
|
|
iterations = 10;
|
|
#if RTE_TABLE_HASH_LRU_STRATEGY == 3
|
|
bucket->lru_list = 0xFFFFFFFFFFFFFFFFULL;
|
|
#else
|
|
bucket->lru_list = 0x0000000100020003ULL;
|
|
#endif
|
|
poss = 0;
|
|
for (j = 0; j < iterations; j++)
|
|
for (i = 0; i < 9; i++) {
|
|
uint32_t idx = i >> 1;
|
|
lru_update(bucket, idx);
|
|
pos = lru_pos(bucket);
|
|
poss += pos;
|
|
printf("%s: %d lru_list=%016"PRIx64", upd=%d, "
|
|
"pos=%"PRIx64"\n",
|
|
__func__, i, bucket->lru_list, i>>1, pos);
|
|
}
|
|
|
|
if (bucket->lru_list != shuffles) {
|
|
printf("%s: ERROR: %d lru_list=%016"PRIx64", expected %016"
|
|
PRIx64"\n",
|
|
__func__, i, bucket->lru_list, shuffles);
|
|
return -1;
|
|
}
|
|
printf("%s: output checksum of results =%d\n",
|
|
__func__, poss);
|
|
#if 0
|
|
if (poss != 126) {
|
|
printf("%s: ERROR output checksum of results =%d expected %d\n",
|
|
__func__, poss, 126);
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
fflush(stdout);
|
|
|
|
uint64_t sc_start = rte_rdtsc();
|
|
iterations = 100000000;
|
|
poss = 0;
|
|
for (j = 0; j < iterations; j++) {
|
|
for (i = 0; i < 4; i++) {
|
|
lru_update(bucket, i);
|
|
pos |= bucket->lru_list;
|
|
}
|
|
}
|
|
uint64_t sc_end = rte_rdtsc();
|
|
|
|
printf("%s: output checksum of results =%llu\n",
|
|
__func__, (long long unsigned int)pos);
|
|
printf("%s: start=%016"PRIx64", end=%016"PRIx64"\n",
|
|
__func__, sc_start, sc_end);
|
|
printf("\nlru_update: %lu cycles per loop iteration.\n\n",
|
|
(long unsigned int)((sc_end-sc_start)/(iterations*4)));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Table tests */
|
|
int
|
|
test_table_stub(void)
|
|
{
|
|
int i;
|
|
uint64_t expected_mask = 0, result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
|
|
/* Create */
|
|
table = rte_table_stub_ops.f_create(NULL, 0, 1);
|
|
if (table == NULL)
|
|
return -1;
|
|
|
|
/* Traffic flow */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0)
|
|
PREPARE_PACKET(mbufs[i], 0xadadadad);
|
|
else
|
|
PREPARE_PACKET(mbufs[i], 0xadadadab);
|
|
|
|
expected_mask = 0;
|
|
rte_table_stub_ops.f_lookup(table, mbufs, -1,
|
|
&result_mask, (void **)entries);
|
|
if (result_mask != expected_mask)
|
|
return -2;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
test_table_array(void)
|
|
{
|
|
int status, i;
|
|
uint64_t result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
char entry1, entry2;
|
|
void *entry_ptr;
|
|
int key_found;
|
|
|
|
/* Initialize params and create tables */
|
|
struct rte_table_array_params array_params = {
|
|
.n_entries = 7,
|
|
.offset = APP_METADATA_OFFSET(1)
|
|
};
|
|
|
|
table = rte_table_array_ops.f_create(NULL, 0, 1);
|
|
if (table != NULL)
|
|
return -1;
|
|
|
|
array_params.n_entries = 0;
|
|
|
|
table = rte_table_array_ops.f_create(&array_params, 0, 1);
|
|
if (table != NULL)
|
|
return -2;
|
|
|
|
array_params.n_entries = 7;
|
|
|
|
table = rte_table_array_ops.f_create(&array_params, 0, 1);
|
|
if (table != NULL)
|
|
return -3;
|
|
|
|
array_params.n_entries = 1 << 24;
|
|
array_params.offset = APP_METADATA_OFFSET(1);
|
|
|
|
table = rte_table_array_ops.f_create(&array_params, 0, 1);
|
|
if (table == NULL)
|
|
return -4;
|
|
|
|
array_params.offset = APP_METADATA_OFFSET(32);
|
|
|
|
table = rte_table_array_ops.f_create(&array_params, 0, 1);
|
|
if (table == NULL)
|
|
return -5;
|
|
|
|
/* Free */
|
|
status = rte_table_array_ops.f_free(table);
|
|
if (status < 0)
|
|
return -6;
|
|
|
|
status = rte_table_array_ops.f_free(NULL);
|
|
if (status == 0)
|
|
return -7;
|
|
|
|
/* Add */
|
|
struct rte_table_array_key array_key_1 = {
|
|
.pos = 10,
|
|
};
|
|
struct rte_table_array_key array_key_2 = {
|
|
.pos = 20,
|
|
};
|
|
entry1 = 'A';
|
|
entry2 = 'B';
|
|
|
|
table = rte_table_array_ops.f_create(&array_params, 0, 1);
|
|
if (table == NULL)
|
|
return -8;
|
|
|
|
status = rte_table_array_ops.f_add(NULL, (void *) &array_key_1, &entry1,
|
|
&key_found, &entry_ptr);
|
|
if (status == 0)
|
|
return -9;
|
|
|
|
status = rte_table_array_ops.f_add(table, (void *) &array_key_1, NULL,
|
|
&key_found, &entry_ptr);
|
|
if (status == 0)
|
|
return -10;
|
|
|
|
status = rte_table_array_ops.f_add(table, (void *) &array_key_1,
|
|
&entry1, &key_found, &entry_ptr);
|
|
if (status != 0)
|
|
return -11;
|
|
|
|
/* Traffic flow */
|
|
status = rte_table_array_ops.f_add(table, (void *) &array_key_2,
|
|
&entry2, &key_found, &entry_ptr);
|
|
if (status != 0)
|
|
return -12;
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0)
|
|
PREPARE_PACKET(mbufs[i], 10);
|
|
else
|
|
PREPARE_PACKET(mbufs[i], 20);
|
|
|
|
rte_table_array_ops.f_lookup(table, mbufs, -1,
|
|
&result_mask, (void **)entries);
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0 && *entries[i] != 'A')
|
|
return -13;
|
|
else
|
|
if (i % 2 == 1 && *entries[i] != 'B')
|
|
return -13;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
status = rte_table_array_ops.f_free(table);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
test_table_lpm(void)
|
|
{
|
|
int status, i;
|
|
uint64_t expected_mask = 0, result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
char entry;
|
|
void *entry_ptr;
|
|
int key_found;
|
|
uint32_t entry_size = 1;
|
|
|
|
/* Initialize params and create tables */
|
|
struct rte_table_lpm_params lpm_params = {
|
|
.name = "LPM",
|
|
.n_rules = 1 << 24,
|
|
.number_tbl8s = 1 << 8,
|
|
.flags = 0,
|
|
.entry_unique_size = entry_size,
|
|
.offset = APP_METADATA_OFFSET(1)
|
|
};
|
|
|
|
table = rte_table_lpm_ops.f_create(NULL, 0, entry_size);
|
|
if (table != NULL)
|
|
return -1;
|
|
|
|
lpm_params.name = NULL;
|
|
|
|
table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -2;
|
|
|
|
lpm_params.name = "LPM";
|
|
lpm_params.n_rules = 0;
|
|
|
|
table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -3;
|
|
|
|
lpm_params.n_rules = 1 << 24;
|
|
lpm_params.offset = APP_METADATA_OFFSET(32);
|
|
lpm_params.entry_unique_size = 0;
|
|
|
|
table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -4;
|
|
|
|
lpm_params.entry_unique_size = entry_size + 1;
|
|
|
|
table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -5;
|
|
|
|
lpm_params.entry_unique_size = entry_size;
|
|
|
|
table = rte_table_lpm_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table == NULL)
|
|
return -6;
|
|
|
|
/* Free */
|
|
status = rte_table_lpm_ops.f_free(table);
|
|
if (status < 0)
|
|
return -7;
|
|
|
|
status = rte_table_lpm_ops.f_free(NULL);
|
|
if (status == 0)
|
|
return -8;
|
|
|
|
/* Add */
|
|
struct rte_table_lpm_key lpm_key;
|
|
lpm_key.ip = 0xadadadad;
|
|
|
|
table = rte_table_lpm_ops.f_create(&lpm_params, 0, 1);
|
|
if (table == NULL)
|
|
return -9;
|
|
|
|
status = rte_table_lpm_ops.f_add(NULL, &lpm_key, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -10;
|
|
|
|
status = rte_table_lpm_ops.f_add(table, NULL, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -11;
|
|
|
|
status = rte_table_lpm_ops.f_add(table, &lpm_key, NULL, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -12;
|
|
|
|
lpm_key.depth = 0;
|
|
status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -13;
|
|
|
|
lpm_key.depth = 33;
|
|
status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -14;
|
|
|
|
lpm_key.depth = 16;
|
|
status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status != 0)
|
|
return -15;
|
|
|
|
/* Delete */
|
|
status = rte_table_lpm_ops.f_delete(NULL, &lpm_key, &key_found, NULL);
|
|
if (status == 0)
|
|
return -16;
|
|
|
|
status = rte_table_lpm_ops.f_delete(table, NULL, &key_found, NULL);
|
|
if (status == 0)
|
|
return -17;
|
|
|
|
lpm_key.depth = 0;
|
|
status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
|
|
if (status == 0)
|
|
return -18;
|
|
|
|
lpm_key.depth = 33;
|
|
status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
|
|
if (status == 0)
|
|
return -19;
|
|
|
|
lpm_key.depth = 16;
|
|
status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
|
|
if (status != 0)
|
|
return -20;
|
|
|
|
status = rte_table_lpm_ops.f_delete(table, &lpm_key, &key_found, NULL);
|
|
if (status != 0)
|
|
return -21;
|
|
|
|
/* Traffic flow */
|
|
entry = 'A';
|
|
status = rte_table_lpm_ops.f_add(table, &lpm_key, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status < 0)
|
|
return -22;
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0) {
|
|
expected_mask |= (uint64_t)1 << i;
|
|
PREPARE_PACKET(mbufs[i], 0xadadadad);
|
|
} else
|
|
PREPARE_PACKET(mbufs[i], 0xadadadab);
|
|
|
|
rte_table_lpm_ops.f_lookup(table, mbufs, -1,
|
|
&result_mask, (void **)entries);
|
|
if (result_mask != expected_mask)
|
|
return -23;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
status = rte_table_lpm_ops.f_free(table);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
test_table_lpm_ipv6(void)
|
|
{
|
|
int status, i;
|
|
uint64_t expected_mask = 0, result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
char entry;
|
|
void *entry_ptr;
|
|
int key_found;
|
|
uint32_t entry_size = 1;
|
|
|
|
/* Initialize params and create tables */
|
|
struct rte_table_lpm_ipv6_params lpm_params = {
|
|
.name = "LPM",
|
|
.n_rules = 1 << 24,
|
|
.number_tbl8s = 1 << 18,
|
|
.entry_unique_size = entry_size,
|
|
.offset = APP_METADATA_OFFSET(32)
|
|
};
|
|
|
|
table = rte_table_lpm_ipv6_ops.f_create(NULL, 0, entry_size);
|
|
if (table != NULL)
|
|
return -1;
|
|
|
|
lpm_params.name = NULL;
|
|
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -2;
|
|
|
|
lpm_params.name = "LPM";
|
|
lpm_params.n_rules = 0;
|
|
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -3;
|
|
|
|
lpm_params.n_rules = 1 << 24;
|
|
lpm_params.number_tbl8s = 0;
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -4;
|
|
|
|
lpm_params.number_tbl8s = 1 << 18;
|
|
lpm_params.entry_unique_size = 0;
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -5;
|
|
|
|
lpm_params.entry_unique_size = entry_size + 1;
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table != NULL)
|
|
return -6;
|
|
|
|
lpm_params.entry_unique_size = entry_size;
|
|
lpm_params.offset = APP_METADATA_OFFSET(32);
|
|
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table == NULL)
|
|
return -7;
|
|
|
|
/* Free */
|
|
status = rte_table_lpm_ipv6_ops.f_free(table);
|
|
if (status < 0)
|
|
return -8;
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_free(NULL);
|
|
if (status == 0)
|
|
return -9;
|
|
|
|
/* Add */
|
|
struct rte_table_lpm_ipv6_key lpm_key;
|
|
|
|
lpm_key.ip[0] = 0xad;
|
|
lpm_key.ip[1] = 0xad;
|
|
lpm_key.ip[2] = 0xad;
|
|
lpm_key.ip[3] = 0xad;
|
|
|
|
table = rte_table_lpm_ipv6_ops.f_create(&lpm_params, 0, entry_size);
|
|
if (table == NULL)
|
|
return -10;
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_add(NULL, &lpm_key, &entry,
|
|
&key_found, &entry_ptr);
|
|
if (status == 0)
|
|
return -11;
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_add(table, NULL, &entry, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -12;
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, NULL, &key_found,
|
|
&entry_ptr);
|
|
if (status == 0)
|
|
return -13;
|
|
|
|
lpm_key.depth = 0;
|
|
status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
|
|
&key_found, &entry_ptr);
|
|
if (status == 0)
|
|
return -14;
|
|
|
|
lpm_key.depth = 129;
|
|
status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
|
|
&key_found, &entry_ptr);
|
|
if (status == 0)
|
|
return -15;
|
|
|
|
lpm_key.depth = 16;
|
|
status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
|
|
&key_found, &entry_ptr);
|
|
if (status != 0)
|
|
return -16;
|
|
|
|
/* Delete */
|
|
status = rte_table_lpm_ipv6_ops.f_delete(NULL, &lpm_key, &key_found,
|
|
NULL);
|
|
if (status == 0)
|
|
return -17;
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_delete(table, NULL, &key_found, NULL);
|
|
if (status == 0)
|
|
return -18;
|
|
|
|
lpm_key.depth = 0;
|
|
status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
|
|
NULL);
|
|
if (status == 0)
|
|
return -19;
|
|
|
|
lpm_key.depth = 129;
|
|
status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
|
|
NULL);
|
|
if (status == 0)
|
|
return -20;
|
|
|
|
lpm_key.depth = 16;
|
|
status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
|
|
NULL);
|
|
if (status != 0)
|
|
return -21;
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_delete(table, &lpm_key, &key_found,
|
|
NULL);
|
|
if (status != 0)
|
|
return -22;
|
|
|
|
/* Traffic flow */
|
|
entry = 'A';
|
|
status = rte_table_lpm_ipv6_ops.f_add(table, &lpm_key, &entry,
|
|
&key_found, &entry_ptr);
|
|
if (status < 0)
|
|
return -23;
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0) {
|
|
expected_mask |= (uint64_t)1 << i;
|
|
PREPARE_PACKET(mbufs[i], 0xadadadad);
|
|
} else
|
|
PREPARE_PACKET(mbufs[i], 0xadadadab);
|
|
|
|
rte_table_lpm_ipv6_ops.f_lookup(table, mbufs, -1,
|
|
&result_mask, (void **)entries);
|
|
if (result_mask != expected_mask)
|
|
return -24;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
status = rte_table_lpm_ipv6_ops.f_free(table);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_table_hash_lru_generic(struct rte_table_ops *ops, uint32_t key_size)
|
|
{
|
|
int status, i;
|
|
uint64_t expected_mask = 0, result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
char entry;
|
|
void *entry_ptr;
|
|
int key_found;
|
|
|
|
/* Initialize params and create tables */
|
|
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_keys = 0;
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table != NULL)
|
|
return -1;
|
|
|
|
hash_params.n_keys = 1 << 10;
|
|
hash_params.f_hash = NULL;
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table != NULL)
|
|
return -4;
|
|
|
|
hash_params.f_hash = pipeline_test_hash;
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table == NULL)
|
|
return -5;
|
|
|
|
/* Free */
|
|
status = ops->f_free(table);
|
|
if (status < 0)
|
|
return -6;
|
|
|
|
status = ops->f_free(NULL);
|
|
if (status == 0)
|
|
return -7;
|
|
|
|
/* Add */
|
|
uint8_t key[32];
|
|
uint32_t *k32 = (uint32_t *) &key;
|
|
|
|
memset(key, 0, 32);
|
|
k32[0] = rte_be_to_cpu_32(0xadadadad);
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table == NULL)
|
|
return -8;
|
|
|
|
entry = 'A';
|
|
status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
|
|
if (status != 0)
|
|
return -9;
|
|
|
|
/* Delete */
|
|
status = ops->f_delete(table, &key, &key_found, NULL);
|
|
if (status != 0)
|
|
return -10;
|
|
|
|
status = ops->f_delete(table, &key, &key_found, NULL);
|
|
if (status != 0)
|
|
return -11;
|
|
|
|
/* Traffic flow */
|
|
entry = 'A';
|
|
status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
|
|
if (status < 0)
|
|
return -12;
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0) {
|
|
expected_mask |= (uint64_t)1 << i;
|
|
PREPARE_PACKET(mbufs[i], 0xadadadad);
|
|
} else
|
|
PREPARE_PACKET(mbufs[i], 0xadadadab);
|
|
|
|
ops->f_lookup(table, mbufs, -1, &result_mask, (void **)entries);
|
|
if (result_mask != expected_mask)
|
|
return -13;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
status = ops->f_free(table);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_table_hash_ext_generic(struct rte_table_ops *ops, uint32_t key_size)
|
|
{
|
|
int status, i;
|
|
uint64_t expected_mask = 0, result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
char entry;
|
|
int key_found;
|
|
void *entry_ptr;
|
|
|
|
/* Initialize params and create tables */
|
|
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_keys = 0;
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table != NULL)
|
|
return -1;
|
|
|
|
hash_params.n_keys = 1 << 10;
|
|
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.f_hash = NULL;
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table != NULL)
|
|
return -4;
|
|
|
|
hash_params.f_hash = pipeline_test_hash;
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table == NULL)
|
|
return -5;
|
|
|
|
/* Free */
|
|
status = ops->f_free(table);
|
|
if (status < 0)
|
|
return -6;
|
|
|
|
status = ops->f_free(NULL);
|
|
if (status == 0)
|
|
return -7;
|
|
|
|
/* Add */
|
|
uint8_t key[32];
|
|
uint32_t *k32 = (uint32_t *) &key;
|
|
|
|
memset(key, 0, 32);
|
|
k32[0] = rte_be_to_cpu_32(0xadadadad);
|
|
|
|
table = ops->f_create(&hash_params, 0, 1);
|
|
if (table == NULL)
|
|
return -8;
|
|
|
|
entry = 'A';
|
|
status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
|
|
if (status != 0)
|
|
return -9;
|
|
|
|
/* Delete */
|
|
status = ops->f_delete(table, &key, &key_found, NULL);
|
|
if (status != 0)
|
|
return -10;
|
|
|
|
status = ops->f_delete(table, &key, &key_found, NULL);
|
|
if (status != 0)
|
|
return -11;
|
|
|
|
/* Traffic flow */
|
|
entry = 'A';
|
|
status = ops->f_add(table, &key, &entry, &key_found, &entry_ptr);
|
|
if (status < 0)
|
|
return -12;
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0) {
|
|
expected_mask |= (uint64_t)1 << i;
|
|
PREPARE_PACKET(mbufs[i], 0xadadadad);
|
|
} else
|
|
PREPARE_PACKET(mbufs[i], 0xadadadab);
|
|
|
|
ops->f_lookup(table, mbufs, -1, &result_mask, (void **)entries);
|
|
if (result_mask != expected_mask)
|
|
return -13;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
status = ops->f_free(table);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
test_table_hash_lru(void)
|
|
{
|
|
int status;
|
|
|
|
status = test_table_hash_lru_generic(
|
|
&rte_table_hash_key8_lru_ops,
|
|
8);
|
|
if (status < 0)
|
|
return status;
|
|
|
|
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,
|
|
32);
|
|
if (status < 0)
|
|
return status;
|
|
|
|
status = test_lru_update();
|
|
if (status < 0)
|
|
return status;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
test_table_hash_ext(void)
|
|
{
|
|
int status;
|
|
|
|
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_key16_ext_ops, 16);
|
|
if (status < 0)
|
|
return status;
|
|
|
|
status = test_table_hash_ext_generic(&rte_table_hash_key32_ext_ops, 32);
|
|
if (status < 0)
|
|
return status;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
test_table_hash_cuckoo(void)
|
|
{
|
|
int status, i;
|
|
uint64_t expected_mask = 0, result_mask;
|
|
struct rte_mbuf *mbufs[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
void *table;
|
|
char *entries[RTE_PORT_IN_BURST_SIZE_MAX];
|
|
char entry;
|
|
void *entry_ptr;
|
|
int key_found;
|
|
uint32_t entry_size = 1;
|
|
|
|
/* Initialize params and create tables */
|
|
struct rte_table_hash_cuckoo_params cuckoo_params = {
|
|
.name = "TABLE",
|
|
.key_size = 32,
|
|
.key_offset = APP_METADATA_OFFSET(32),
|
|
.key_mask = NULL,
|
|
.n_keys = 1 << 16,
|
|
.n_buckets = 1 << 16,
|
|
.f_hash = pipeline_test_hash_cuckoo,
|
|
.seed = 0,
|
|
};
|
|
|
|
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_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_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_ops.f_create(&cuckoo_params,
|
|
0, entry_size);
|
|
if (table != NULL)
|
|
return -4;
|
|
|
|
cuckoo_params.f_hash = pipeline_test_hash_cuckoo;
|
|
cuckoo_params.name = NULL;
|
|
|
|
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_ops.f_create(&cuckoo_params,
|
|
0, entry_size);
|
|
if (table == NULL)
|
|
return -6;
|
|
|
|
/* Free */
|
|
status = rte_table_hash_cuckoo_ops.f_free(table);
|
|
if (status < 0)
|
|
return -7;
|
|
|
|
status = rte_table_hash_cuckoo_ops.f_free(NULL);
|
|
if (status == 0)
|
|
return -8;
|
|
|
|
/* Add */
|
|
uint8_t key_cuckoo[32];
|
|
uint32_t *kcuckoo = (uint32_t *) &key_cuckoo;
|
|
|
|
memset(key_cuckoo, 0, 32);
|
|
kcuckoo[0] = rte_be_to_cpu_32(0xadadadad);
|
|
|
|
table = rte_table_hash_cuckoo_ops.f_create(&cuckoo_params, 0, 1);
|
|
if (table == NULL)
|
|
return -9;
|
|
|
|
entry = 'A';
|
|
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_ops.f_add(table, NULL, &entry,
|
|
&key_found, &entry_ptr);
|
|
if (status == 0)
|
|
return -11;
|
|
|
|
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_ops.f_add(table, &key_cuckoo,
|
|
&entry, &key_found, &entry_ptr);
|
|
if (status != 0)
|
|
return -13;
|
|
|
|
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_ops.f_delete(NULL, &key_cuckoo,
|
|
&key_found, NULL);
|
|
if (status == 0)
|
|
return -15;
|
|
|
|
status = rte_table_hash_cuckoo_ops.f_delete(table, NULL,
|
|
&key_found, NULL);
|
|
if (status == 0)
|
|
return -16;
|
|
|
|
status = rte_table_hash_cuckoo_ops.f_delete(table, &key_cuckoo,
|
|
&key_found, NULL);
|
|
if (status != 0)
|
|
return -17;
|
|
|
|
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_ops.f_add(table, &key_cuckoo,
|
|
&entry, &key_found,
|
|
&entry_ptr);
|
|
if (status < 0)
|
|
return -19;
|
|
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
if (i % 2 == 0) {
|
|
expected_mask |= (uint64_t)1 << i;
|
|
PREPARE_PACKET(mbufs[i], 0xadadadad);
|
|
} else
|
|
PREPARE_PACKET(mbufs[i], 0xadadadab);
|
|
|
|
rte_table_hash_cuckoo_ops.f_lookup(table, mbufs, -1,
|
|
&result_mask, (void **)entries);
|
|
if (result_mask != expected_mask)
|
|
return -20;
|
|
|
|
/* Free resources */
|
|
for (i = 0; i < RTE_PORT_IN_BURST_SIZE_MAX; i++)
|
|
rte_pktmbuf_free(mbufs[i]);
|
|
|
|
status = rte_table_hash_cuckoo_ops.f_free(table);
|
|
|
|
return 0;
|
|
}
|
|
|