New upstream version 17.11-rc3

[deb_dpdk.git] / test / test / test_table_tables.c

diff --git a/test/test/test_table_tables.c b/test/test/test_table_tables.c
index d835eb9..a1b0c58 100644 (file)
--- a/test/test/test_table_tables.c
+++ b/test/test/test_table_tables.c
@@ -60,16 +60,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 +655,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 +667,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 +758,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 +770,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 +872,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_dosig_ops);
+               &rte_table_hash_key8_lru_ops,
+               8);
        if (status < 0)
                return status;
 
-       status = test_table_hash_lru_generic(&rte_table_hash_key16_lru_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 +902,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_dosig_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_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;
 
@@ -959,23 +932,24 @@ test_table_hash_cuckoo(void)
        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;
@@ -983,7 +957,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,7 +965,7 @@ 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;
@@ -999,24 +973,24 @@ test_table_hash_cuckoo(void)
        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;
 
@@ -1027,60 +1001,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 +1067,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 +1076,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;
 }