d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
555e40752b
numam-dpdk/app/test/test_hash.c

2269 lines
61 KiB
C
Raw Normal View History

test: use SPDX tag for Intel copyright files Replace the BSD license header with the SPDX tag for files with only an Intel copyright on them. Signed-off-by: Bruce Richardson <bruce.richardson@intel.com>
2017-12-19 15:49:05 +00:00
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2010-2015 Intel Corporation
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/queue.h>
#include <rte_common.h>
#include <rte_malloc.h>
#include <rte_cycles.h>
#include <rte_random.h>
#include <rte_memory.h>
#include <rte_eal.h>
#include <rte_ip.h>
#include <rte_string_fns.h>
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
#include "test.h"
hash: select default hash by looking at SSE flags Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
#include <rte_hash.h>
#include <rte_fbk_hash.h>
#include <rte_jhash.h>
#include <rte_hash_crc.h>
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*******************************************************************************
* Hash function performance test configuration section. Each performance test
* will be performed HASHTEST_ITERATIONS times.
*
* The five arrays below control what tests are performed. Every combination
* from the array entries is tested.
*/
static rte_hash_function hashtest_funcs[] = {rte_jhash, rte_hash_crc};
static uint32_t hashtest_initvals[] = {0};
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
static uint32_t hashtest_key_lens[] = {0, 2, 4, 5, 6, 7, 8, 10, 11, 15, 16, 21, 31, 32, 33, 63, 64};
hash: remove deprecated function and macros The function rte_jhash2() was renamed rte_jhash_32b and macros RTE_HASH_KEY_LENGTH_MAX and RTE_HASH_BUCKET_ENTRIES_MAX were tagged as deprecated, so they can be removed in 2.2. RTE_HASH_KEY_LENGTH is replaced in unit tests by an internal macro for the memory allocation of all keys used. The library version number is incremented. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2015-09-04 09:05:40 +00:00
#define MAX_KEYSIZE 64
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/******************************************************************************/
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
#define LOCAL_FBK_HASH_ENTRIES_MAX (1 << 15)
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Check condition and return an error if true. Assumes that "handle" is the
* name of the hash structure pointer to be freed.
*/
#define RETURN_IF_ERROR(cond, str, ...) do { \
if (cond) { \
printf("ERROR line %d: " str "\n", __LINE__, ##__VA_ARGS__); \
if (handle) rte_hash_free(handle); \
return -1; \
} \
} while(0)
#define RETURN_IF_ERROR_FBK(cond, str, ...) do { \
if (cond) { \
printf("ERROR line %d: " str "\n", __LINE__, ##__VA_ARGS__); \
if (handle) rte_fbk_hash_free(handle); \
return -1; \
} \
} while(0)
test/hash: add RCU tests Add functional and performance tests for the integrated RCU QSBR. Suggested-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2020-10-21 22:50:06 +00:00
#define RETURN_IF_ERROR_RCU_QSBR(cond, str, ...) do { \
if (cond) { \
printf("ERROR line %d: " str "\n", __LINE__, ##__VA_ARGS__); \
if (rcu_cfg.mode == RTE_HASH_QSBR_MODE_SYNC) { \
writer_done = 1; \
/* Wait until reader exited. */ \
rte_eal_mp_wait_lcore(); \
} \
rte_hash_free(g_handle); \
rte_free(g_qsv); \
return -1; \
} \
} while (0)
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
/*
* 5-tuple key type.
* Should be packed to avoid holes with potentially
* undefined content in the middle.
*/
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
struct flow_key {
uint32_t ip_src;
uint32_t ip_dst;
uint16_t port_src;
uint16_t port_dst;
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
uint32_t proto;
replace packed attributes There is a common macro __rte_packed for packing structs, which is now used where appropriate for consistency. Signed-off-by: Thomas Monjalon <thomas@monjalon.net>
2020-02-09 17:29:23 +00:00
} __rte_packed;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Hash function that always returns the same value, to easily test what
* happens when a bucket is full.
*/
replace unused attributes There is a common macro __rte_unused, avoiding warnings, which is now used where appropriate for consistency. Signed-off-by: Thomas Monjalon <thomas@monjalon.net>
2020-02-09 15:54:54 +00:00
static uint32_t pseudo_hash(__rte_unused const void *keys,
__rte_unused uint32_t key_len,
__rte_unused uint32_t init_val)
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
{
return 3;
}
log: introduce logtype register macro Introduce the RTE_LOG_REGISTER macro to avoid the code duplication in the logtype registration process. It is a wrapper macro for declaring the logtype, registering it and setting its level in the constructor context. Signed-off-by: Jerin Jacob <jerinj@marvell.com> Acked-by: Adam Dybkowski <adamx.dybkowski@intel.com> Acked-by: Sachin Saxena <sachin.saxena@nxp.com> Acked-by: Akhil Goyal <akhil.goyal@nxp.com>
2020-07-01 12:33:35 +00:00
RTE_LOG_REGISTER(hash_logtype_test, test.hash, INFO);
test/hash: replace config macro with runtime log level Need to set hash log type to debug to print debug information, using following eal parameter: --log-level=test.hash:debug Suggested-by: Thomas Monjalon <thomas@monjalon.net> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Phil Yang <phil.yang@arm.com> Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
2019-02-26 23:02:27 +00:00
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Print out result of unit test hash operation.
*/
static void print_key_info(const char *msg, const struct flow_key *key,
int32_t pos)
{
test/hash: replace config macro with runtime log level Need to set hash log type to debug to print debug information, using following eal parameter: --log-level=test.hash:debug Suggested-by: Thomas Monjalon <thomas@monjalon.net> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Phil Yang <phil.yang@arm.com> Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
2019-02-26 23:02:27 +00:00
const uint8_t *p = (const uint8_t *)key;
unsigned int i;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
test/hash: replace config macro with runtime log level Need to set hash log type to debug to print debug information, using following eal parameter: --log-level=test.hash:debug Suggested-by: Thomas Monjalon <thomas@monjalon.net> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Phil Yang <phil.yang@arm.com> Reviewed-by: Ferruh Yigit <ferruh.yigit@intel.com>
2019-02-26 23:02:27 +00:00
rte_log(RTE_LOG_DEBUG, hash_logtype_test, "%s key:0x", msg);
for (i = 0; i < sizeof(struct flow_key); i++)
rte_log(RTE_LOG_DEBUG, hash_logtype_test, "%02X", p[i]);
rte_log(RTE_LOG_DEBUG, hash_logtype_test, " @ pos %d\n", pos);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
}
/* Keys used by unit test functions */
static struct flow_key keys[5] = { {
net: replace IPv4/v6 constants with uppercase name Since we change these macros, we might as well avoid triggering complaints from checkpatch because of mixed case. old=RTE_IPv4 new=RTE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv4 new=RTE_ETHER_TYPE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv6 new=RTE_ETHER_TYPE_IPV6 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" Signed-off-by: David Marchand <david.marchand@redhat.com> Reviewed-by: Olivier Matz <olivier.matz@6wind.com>
2019-05-29 11:29:16 +00:00
.ip_src = RTE_IPV4(0x03, 0x02, 0x01, 0x00),
.ip_dst = RTE_IPV4(0x07, 0x06, 0x05, 0x04),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.port_src = 0x0908,
.port_dst = 0x0b0a,
.proto = 0x0c,
}, {
net: replace IPv4/v6 constants with uppercase name Since we change these macros, we might as well avoid triggering complaints from checkpatch because of mixed case. old=RTE_IPv4 new=RTE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv4 new=RTE_ETHER_TYPE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv6 new=RTE_ETHER_TYPE_IPV6 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" Signed-off-by: David Marchand <david.marchand@redhat.com> Reviewed-by: Olivier Matz <olivier.matz@6wind.com>
2019-05-29 11:29:16 +00:00
.ip_src = RTE_IPV4(0x13, 0x12, 0x11, 0x10),
.ip_dst = RTE_IPV4(0x17, 0x16, 0x15, 0x14),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.port_src = 0x1918,
.port_dst = 0x1b1a,
.proto = 0x1c,
}, {
net: replace IPv4/v6 constants with uppercase name Since we change these macros, we might as well avoid triggering complaints from checkpatch because of mixed case. old=RTE_IPv4 new=RTE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv4 new=RTE_ETHER_TYPE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv6 new=RTE_ETHER_TYPE_IPV6 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" Signed-off-by: David Marchand <david.marchand@redhat.com> Reviewed-by: Olivier Matz <olivier.matz@6wind.com>
2019-05-29 11:29:16 +00:00
.ip_src = RTE_IPV4(0x23, 0x22, 0x21, 0x20),
.ip_dst = RTE_IPV4(0x27, 0x26, 0x25, 0x24),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.port_src = 0x2928,
.port_dst = 0x2b2a,
.proto = 0x2c,
}, {
net: replace IPv4/v6 constants with uppercase name Since we change these macros, we might as well avoid triggering complaints from checkpatch because of mixed case. old=RTE_IPv4 new=RTE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv4 new=RTE_ETHER_TYPE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv6 new=RTE_ETHER_TYPE_IPV6 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" Signed-off-by: David Marchand <david.marchand@redhat.com> Reviewed-by: Olivier Matz <olivier.matz@6wind.com>
2019-05-29 11:29:16 +00:00
.ip_src = RTE_IPV4(0x33, 0x32, 0x31, 0x30),
.ip_dst = RTE_IPV4(0x37, 0x36, 0x35, 0x34),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.port_src = 0x3938,
.port_dst = 0x3b3a,
.proto = 0x3c,
}, {
net: replace IPv4/v6 constants with uppercase name Since we change these macros, we might as well avoid triggering complaints from checkpatch because of mixed case. old=RTE_IPv4 new=RTE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv4 new=RTE_ETHER_TYPE_IPV4 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" old=RTE_ETHER_TYPE_IPv6 new=RTE_ETHER_TYPE_IPV6 git grep -lw $old | xargs sed -i -e "s/\<$old\>/$new/g" Signed-off-by: David Marchand <david.marchand@redhat.com> Reviewed-by: Olivier Matz <olivier.matz@6wind.com>
2019-05-29 11:29:16 +00:00
.ip_src = RTE_IPV4(0x43, 0x42, 0x41, 0x40),
.ip_dst = RTE_IPV4(0x47, 0x46, 0x45, 0x44),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.port_src = 0x4948,
.port_dst = 0x4b4a,
.proto = 0x4c,
} };
/* Parameters used for hash table in unit test functions. Name set later. */
static struct rte_hash_parameters ut_params = {
.entries = 64,
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
.key_len = sizeof(struct flow_key),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.hash_func = rte_jhash,
.hash_func_init_val = 0,
.socket_id = 0,
};
app/test: shorten execution time The autotests are too long to be run often. This patch reduces the needed time of some tests in fast_test. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2016-05-04 15:15:05 +00:00
#define CRC32_ITERATIONS (1U << 10)
app/test: add crc32 algorithms equivalence check New function test_crc32_hash_alg_equiv() checks whether software, 4-byte operand and 8-byte operand versions of CRC32 hash function implementations return the same result value. Signed-off-by: Yerden Zhumabekov <e_zhumabekov@sts.kz> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-02-25 12:34:06 +00:00
#define CRC32_DWORDS (1U << 6)
/*
* Test if all CRC32 implementations yield the same hash value
*/
static int
test_crc32_hash_alg_equiv(void)
{
uint32_t hash_val;
uint32_t init_val;
uint64_t data64[CRC32_DWORDS];
unsigned i, j;
size_t data_len;
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
printf("\n# CRC32 implementations equivalence test\n");
app/test: add crc32 algorithms equivalence check New function test_crc32_hash_alg_equiv() checks whether software, 4-byte operand and 8-byte operand versions of CRC32 hash function implementations return the same result value. Signed-off-by: Yerden Zhumabekov <e_zhumabekov@sts.kz> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-02-25 12:34:06 +00:00
for (i = 0; i < CRC32_ITERATIONS; i++) {
/* Randomizing data_len of data set */
data_len = (size_t) ((rte_rand() % sizeof(data64)) + 1);
init_val = (uint32_t) rte_rand();
/* Fill the data set */
for (j = 0; j < CRC32_DWORDS; j++)
data64[j] = rte_rand();
/* Calculate software CRC32 */
rte_hash_crc_set_alg(CRC32_SW);
hash_val = rte_hash_crc(data64, data_len, init_val);
/* Check against 4-byte-operand sse4.2 CRC32 if available */
rte_hash_crc_set_alg(CRC32_SSE42);
if (hash_val != rte_hash_crc(data64, data_len, init_val)) {
printf("Failed checking CRC32_SW against CRC32_SSE42\n");
break;
}
/* Check against 8-byte-operand sse4.2 CRC32 if available */
rte_hash_crc_set_alg(CRC32_SSE42_x64);
if (hash_val != rte_hash_crc(data64, data_len, init_val)) {
printf("Failed checking CRC32_SW against CRC32_SSE42_x64\n");
break;
}
hash: use armv8-a CRC32 instructions armv8-a has optional CRC32 extension, march=armv8-a+crc enables code generation for the ARMv8-A architecture together with the optional CRC32 extensions. added RTE_MACHINE_CPUFLAG_CRC32 to detect the availability of CRC32 extension in compile time. At run-time, The RTE_CPUFLAG_CRC32 can be used to find the availability. armv8-a+crc target support added in GCC 4.9, Used inline assembly and emulated __ARM_FEATURE_CRC32 to work with tool-chain < 4.9 Signed-off-by: Jerin Jacob <jerin.jacob@caviumnetworks.com>
2015-11-23 18:45:36 +00:00
/* Check against 8-byte-operand ARM64 CRC32 if available */
rte_hash_crc_set_alg(CRC32_ARM64);
if (hash_val != rte_hash_crc(data64, data_len, init_val)) {
printf("Failed checking CRC32_SW against CRC32_ARM64\n");
break;
}
app/test: add crc32 algorithms equivalence check New function test_crc32_hash_alg_equiv() checks whether software, 4-byte operand and 8-byte operand versions of CRC32 hash function implementations return the same result value. Signed-off-by: Yerden Zhumabekov <e_zhumabekov@sts.kz> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-02-25 12:34:06 +00:00
}
/* Resetting to best available algorithm */
rte_hash_crc_set_alg(CRC32_SSE42_x64);
if (i == CRC32_ITERATIONS)
return 0;
app/test: fix printf format test_hash.c: In function ‘test_crc32_hash_alg_equiv’: error: format ‘%lu’ expects argument of type ‘long unsigned int’, but argument 2 has type ‘size_t’ [-Werror=format] According to C99, for size_t type should use format "%zu" Signed-off-by: Michael Qiu <michael.qiu@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-03-06 03:53:32 +00:00
printf("Failed test data (hex, %zu bytes total):\n", data_len);
app/test: add crc32 algorithms equivalence check New function test_crc32_hash_alg_equiv() checks whether software, 4-byte operand and 8-byte operand versions of CRC32 hash function implementations return the same result value. Signed-off-by: Yerden Zhumabekov <e_zhumabekov@sts.kz> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-02-25 12:34:06 +00:00
for (j = 0; j < data_len; j++)
printf("%02X%c", ((uint8_t *)data64)[j],
((j+1) % 16 == 0 || j == data_len - 1) ? '\n' : ' ');
return -1;
}
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/*
* Test a hash function.
*/
static void run_hash_func_test(rte_hash_function f, uint32_t init_val,
uint32_t key_len)
{
hash: remove deprecated function and macros The function rte_jhash2() was renamed rte_jhash_32b and macros RTE_HASH_KEY_LENGTH_MAX and RTE_HASH_BUCKET_ENTRIES_MAX were tagged as deprecated, so they can be removed in 2.2. RTE_HASH_KEY_LENGTH is replaced in unit tests by an internal macro for the memory allocation of all keys used. The library version number is incremented. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2015-09-04 09:05:40 +00:00
static uint8_t key[MAX_KEYSIZE];
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
unsigned i;
for (i = 0; i < key_len; i++)
key[i] = (uint8_t) rte_rand();
/* just to be on the safe side */
if (!f)
return;
f(key, key_len, init_val);
}
/*
* Test all hash functions.
*/
static void run_hash_func_tests(void)
{
unsigned i, j, k;
app: use common macro RTE_DIM Use RTE_DIM macro to calculate array size. Suggested-by: David Marchand <david.marchand@redhat.com> Signed-off-by: Pavan Nikhilesh <pbhagavatula@marvell.com> Acked-by: David Marchand <david.marchand@redhat.com>
2020-01-24 04:55:42 +00:00
for (i = 0; i < RTE_DIM(hashtest_funcs); i++) {
for (j = 0; j < RTE_DIM(hashtest_initvals); j++) {
for (k = 0; k < RTE_DIM(hashtest_key_lens); k++) {
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
run_hash_func_test(hashtest_funcs[i],
hashtest_initvals[j],
hashtest_key_lens[k]);
}
}
}
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Basic sequence of operations for a single key:
* - add
* - lookup (hit)
* - delete
* - lookup (miss)
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
*
* Repeat the test case when 'free on delete' is disabled.
* - add
* - lookup (hit)
* - delete
* - lookup (miss)
* - free
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
*/
static int test_add_delete(void)
{
struct rte_hash *handle;
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
/* test with standard add/lookup/delete functions */
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
int pos0, expectedPos0;
ut_params.name = "test1";
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
pos0 = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos0);
RETURN_IF_ERROR(pos0 < 0, "failed to add key (pos0=%d)", pos0);
expectedPos0 = pos0;
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to find key (pos0=%d)", pos0);
pos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to delete key (pos0=%d)", pos0);
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: found key after deleting! (pos0=%d)", pos0);
rte_hash_free(handle);
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
/* repeat test with precomputed hash functions */
hash_sig_t hash_value;
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
int pos1, expectedPos1, delPos1;
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
ut_params.extra_flag = RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL;
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
ut_params.extra_flag = 0;
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
hash_value = rte_hash_hash(handle, &keys[0]);
pos1 = rte_hash_add_key_with_hash(handle, &keys[0], hash_value);
print_key_info("Add", &keys[0], pos1);
RETURN_IF_ERROR(pos1 < 0, "failed to add key (pos1=%d)", pos1);
expectedPos1 = pos1;
pos1 = rte_hash_lookup_with_hash(handle, &keys[0], hash_value);
print_key_info("Lkp", &keys[0], pos1);
RETURN_IF_ERROR(pos1 != expectedPos1,
"failed to find key (pos1=%d)", pos1);
pos1 = rte_hash_del_key_with_hash(handle, &keys[0], hash_value);
print_key_info("Del", &keys[0], pos1);
RETURN_IF_ERROR(pos1 != expectedPos1,
"failed to delete key (pos1=%d)", pos1);
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
delPos1 = pos1;
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
pos1 = rte_hash_lookup_with_hash(handle, &keys[0], hash_value);
print_key_info("Lkp", &keys[0], pos1);
RETURN_IF_ERROR(pos1 != -ENOENT,
"fail: found key after deleting! (pos1=%d)", pos1);
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
pos1 = rte_hash_free_key_with_position(handle, delPos1);
print_key_info("Free", &keys[0], delPos1);
RETURN_IF_ERROR(pos1 != 0,
"failed to free key (pos1=%d)", delPos1);
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return 0;
}
/*
* Sequence of operations for a single key:
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
* - delete: miss
* - add
* - lookup: hit
* - add: update
* - lookup: hit (updated data)
* - delete: hit
* - delete: miss
* - lookup: miss
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
*/
static int test_add_update_delete(void)
{
struct rte_hash *handle;
int pos0, expectedPos0;
ut_params.name = "test2";
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
pos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: found non-existent key (pos0=%d)", pos0);
pos0 = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos0);
RETURN_IF_ERROR(pos0 < 0, "failed to add key (pos0=%d)", pos0);
expectedPos0 = pos0;
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to find key (pos0=%d)", pos0);
pos0 = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to re-add key (pos0=%d)", pos0);
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to find key (pos0=%d)", pos0);
pos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to delete key (pos0=%d)", pos0);
pos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: deleted already deleted key (pos0=%d)", pos0);
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: found key after deleting! (pos0=%d)", pos0);
rte_hash_free(handle);
return 0;
}
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
/*
* Sequence of operations for a single key with 'disable free on del' set:
* - delete: miss
* - add
* - lookup: hit
* - add: update
* - lookup: hit (updated data)
* - delete: hit
* - delete: miss
* - lookup: miss
* - free: hit
* - lookup: miss
*/
static int test_add_update_delete_free(void)
{
struct rte_hash *handle;
int pos0, expectedPos0, delPos0, result;
ut_params.name = "test2";
ut_params.extra_flag = RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL;
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
ut_params.extra_flag = 0;
pos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: found non-existent key (pos0=%d)", pos0);
pos0 = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos0);
RETURN_IF_ERROR(pos0 < 0, "failed to add key (pos0=%d)", pos0);
expectedPos0 = pos0;
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to find key (pos0=%d)", pos0);
pos0 = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to re-add key (pos0=%d)", pos0);
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != expectedPos0,
"failed to find key (pos0=%d)", pos0);
delPos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], delPos0);
RETURN_IF_ERROR(delPos0 != expectedPos0,
"failed to delete key (pos0=%d)", delPos0);
pos0 = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: deleted already deleted key (pos0=%d)", pos0);
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: found key after deleting! (pos0=%d)", pos0);
result = rte_hash_free_key_with_position(handle, delPos0);
print_key_info("Free", &keys[0], delPos0);
RETURN_IF_ERROR(result != 0,
"failed to free key (pos1=%d)", delPos0);
pos0 = rte_hash_lookup(handle, &keys[0]);
print_key_info("Lkp", &keys[0], pos0);
RETURN_IF_ERROR(pos0 != -ENOENT,
"fail: found key after deleting! (pos0=%d)", pos0);
rte_hash_free(handle);
return 0;
}
test/hash: check freeing key with position This patch adds a unit test for rte_hash_free_key_with_position(). Suggested-by: Linfan <zhongdahulinfan@163.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2019-05-09 17:19:07 +00:00
/*
* Sequence of operations for a single key with 'rw concurrency lock free' set:
* - add
* - delete: hit
* - free: hit
* Repeat the test case when 'multi writer add' is enabled.
* - add
* - delete: hit
* - free: hit
*/
static int test_add_delete_free_lf(void)
{
/* Should match the #define LCORE_CACHE_SIZE value in rte_cuckoo_hash.h */
#define LCORE_CACHE_SIZE 64
struct rte_hash *handle;
hash_sig_t hash_value;
int pos, expectedPos, delPos;
uint8_t extra_flag;
uint32_t i, ip_src;
extra_flag = ut_params.extra_flag;
ut_params.extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF;
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
ut_params.extra_flag = extra_flag;
/*
* The number of iterations is at least the same as the number of slots
* rte_hash allocates internally. This is to reveal potential issues of
* not freeing keys successfully.
*/
for (i = 0; i < ut_params.entries + 1; i++) {
hash_value = rte_hash_hash(handle, &keys[0]);
pos = rte_hash_add_key_with_hash(handle, &keys[0], hash_value);
print_key_info("Add", &keys[0], pos);
RETURN_IF_ERROR(pos < 0, "failed to add key (pos=%d)", pos);
expectedPos = pos;
pos = rte_hash_del_key_with_hash(handle, &keys[0], hash_value);
print_key_info("Del", &keys[0], pos);
RETURN_IF_ERROR(pos != expectedPos,
"failed to delete key (pos=%d)", pos);
delPos = pos;
pos = rte_hash_free_key_with_position(handle, delPos);
print_key_info("Free", &keys[0], delPos);
RETURN_IF_ERROR(pos != 0,
"failed to free key (pos=%d)", delPos);
}
rte_hash_free(handle);
extra_flag = ut_params.extra_flag;
ut_params.extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF |
RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD;
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
ut_params.extra_flag = extra_flag;
ip_src = keys[0].ip_src;
/*
* The number of iterations is at least the same as the number of slots
* rte_hash allocates internally. This is to reveal potential issues of
* not freeing keys successfully.
*/
for (i = 0; i < ut_params.entries + (RTE_MAX_LCORE - 1) *
(LCORE_CACHE_SIZE - 1) + 1; i++) {
keys[0].ip_src++;
hash_value = rte_hash_hash(handle, &keys[0]);
pos = rte_hash_add_key_with_hash(handle, &keys[0], hash_value);
print_key_info("Add", &keys[0], pos);
RETURN_IF_ERROR(pos < 0, "failed to add key (pos=%d)", pos);
expectedPos = pos;
pos = rte_hash_del_key_with_hash(handle, &keys[0], hash_value);
print_key_info("Del", &keys[0], pos);
RETURN_IF_ERROR(pos != expectedPos,
"failed to delete key (pos=%d)", pos);
delPos = pos;
pos = rte_hash_free_key_with_position(handle, delPos);
print_key_info("Free", &keys[0], delPos);
RETURN_IF_ERROR(pos != 0,
"failed to free key (pos=%d)", delPos);
}
keys[0].ip_src = ip_src;
rte_hash_free(handle);
return 0;
}
hash: retrieve a key given its position The function rte_hash_get_key_with_position is added in this patch. As the position returned when adding a key is frequently used as an offset into an array of user data, this function performs the operation of retrieving a key given this offset. A possible use case would be to delete a key from the hash table when its entry in the array of data has certain value. For instance, the key could be a flow 5-tuple, and the value stored in the array a time stamp. Signed-off-by: Juan Antonio Montesinos <juan.antonio.montesinos.delgado@ericsson.com> Signed-off-by: Yari Adan Petralanda <yari.adan.petralanda@ericsson.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-07-04 08:59:52 +00:00
/*
* Sequence of operations for retrieving a key with its position
*
* - create table
* - add key
* - get the key with its position: hit
* - delete key
* - try to get the deleted key: miss
*
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
* Repeat the test case when 'free on delete' is disabled.
* - create table
* - add key
* - get the key with its position: hit
* - delete key
* - try to get the deleted key: hit
* - free key
* - try to get the deleted key: miss
*
hash: retrieve a key given its position The function rte_hash_get_key_with_position is added in this patch. As the position returned when adding a key is frequently used as an offset into an array of user data, this function performs the operation of retrieving a key given this offset. A possible use case would be to delete a key from the hash table when its entry in the array of data has certain value. For instance, the key could be a flow 5-tuple, and the value stored in the array a time stamp. Signed-off-by: Juan Antonio Montesinos <juan.antonio.montesinos.delgado@ericsson.com> Signed-off-by: Yari Adan Petralanda <yari.adan.petralanda@ericsson.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-07-04 08:59:52 +00:00
*/
static int test_hash_get_key_with_position(void)
{
struct rte_hash *handle = NULL;
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
int pos, expectedPos, delPos, result;
hash: retrieve a key given its position The function rte_hash_get_key_with_position is added in this patch. As the position returned when adding a key is frequently used as an offset into an array of user data, this function performs the operation of retrieving a key given this offset. A possible use case would be to delete a key from the hash table when its entry in the array of data has certain value. For instance, the key could be a flow 5-tuple, and the value stored in the array a time stamp. Signed-off-by: Juan Antonio Montesinos <juan.antonio.montesinos.delgado@ericsson.com> Signed-off-by: Yari Adan Petralanda <yari.adan.petralanda@ericsson.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-07-04 08:59:52 +00:00
void *key;
ut_params.name = "hash_get_key_w_pos";
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
pos = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos);
RETURN_IF_ERROR(pos < 0, "failed to add key (pos0=%d)", pos);
expectedPos = pos;
result = rte_hash_get_key_with_position(handle, pos, &key);
RETURN_IF_ERROR(result != 0, "error retrieving a key");
pos = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], pos);
RETURN_IF_ERROR(pos != expectedPos,
"failed to delete key (pos0=%d)", pos);
result = rte_hash_get_key_with_position(handle, pos, &key);
RETURN_IF_ERROR(result != -ENOENT, "non valid key retrieved");
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
rte_hash_free(handle);
ut_params.name = "hash_get_key_w_pos";
ut_params.extra_flag = RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL;
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
ut_params.extra_flag = 0;
pos = rte_hash_add_key(handle, &keys[0]);
print_key_info("Add", &keys[0], pos);
RETURN_IF_ERROR(pos < 0, "failed to add key (pos0=%d)", pos);
expectedPos = pos;
result = rte_hash_get_key_with_position(handle, pos, &key);
RETURN_IF_ERROR(result != 0, "error retrieving a key");
delPos = rte_hash_del_key(handle, &keys[0]);
print_key_info("Del", &keys[0], delPos);
RETURN_IF_ERROR(delPos != expectedPos,
"failed to delete key (pos0=%d)", delPos);
result = rte_hash_get_key_with_position(handle, delPos, &key);
RETURN_IF_ERROR(result != -ENOENT, "non valid key retrieved");
result = rte_hash_free_key_with_position(handle, delPos);
print_key_info("Free", &keys[0], delPos);
RETURN_IF_ERROR(result != 0,
"failed to free key (pos1=%d)", delPos);
result = rte_hash_get_key_with_position(handle, delPos, &key);
RETURN_IF_ERROR(result != -ENOENT, "non valid key retrieved");
hash: retrieve a key given its position The function rte_hash_get_key_with_position is added in this patch. As the position returned when adding a key is frequently used as an offset into an array of user data, this function performs the operation of retrieving a key given this offset. A possible use case would be to delete a key from the hash table when its entry in the array of data has certain value. For instance, the key could be a flow 5-tuple, and the value stored in the array a time stamp. Signed-off-by: Juan Antonio Montesinos <juan.antonio.montesinos.delgado@ericsson.com> Signed-off-by: Yari Adan Petralanda <yari.adan.petralanda@ericsson.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-07-04 08:59:52 +00:00
rte_hash_free(handle);
return 0;
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Sequence of operations for find existing hash table
*
* - create table
* - find existing table: hit
* - find non-existing table: miss
*
*/
static int test_hash_find_existing(void)
{
struct rte_hash *handle = NULL, *result = NULL;
/* Create hash table. */
ut_params.name = "hash_find_existing";
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
/* Try to find existing hash table */
result = rte_hash_find_existing("hash_find_existing");
RETURN_IF_ERROR(result != handle, "could not find existing hash table");
/* Try to find non-existing hash table */
result = rte_hash_find_existing("hash_find_non_existing");
RETURN_IF_ERROR(!(result == NULL), "found table that shouldn't exist");
/* Cleanup. */
rte_hash_free(handle);
return 0;
}
/*
* Sequence of operations for 5 keys
* - add keys
* - lookup keys: hit
* - add keys (update)
* - lookup keys: hit (updated data)
* - delete keys : hit
* - lookup keys: miss
*/
static int test_five_keys(void)
{
struct rte_hash *handle;
const void *key_array[5] = {0};
int pos[5];
int expected_pos[5];
unsigned i;
int ret;
ut_params.name = "test3";
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
/* Add */
for (i = 0; i < 5; i++) {
pos[i] = rte_hash_add_key(handle, &keys[i]);
print_key_info("Add", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] < 0,
"failed to add key (pos[%u]=%d)", i, pos[i]);
expected_pos[i] = pos[i];
}
/* Lookup */
for(i = 0; i < 5; i++)
key_array[i] = &keys[i];
hash: remove aliases for bulk lookup The function rte_hash_lookup_multi() was renamed rte_hash_lookup_bulk() in DPDK 1.4 and was kept as an undocumented alias. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2016-04-19 16:04:00 +00:00
ret = rte_hash_lookup_bulk(handle, &key_array[0], 5, (int32_t *)pos);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
if(ret == 0)
for(i = 0; i < 5; i++) {
print_key_info("Lkp", key_array[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to find key (pos[%u]=%d)", i, pos[i]);
}
/* Add - update */
for (i = 0; i < 5; i++) {
pos[i] = rte_hash_add_key(handle, &keys[i]);
print_key_info("Add", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to add key (pos[%u]=%d)", i, pos[i]);
}
/* Lookup */
for (i = 0; i < 5; i++) {
pos[i] = rte_hash_lookup(handle, &keys[i]);
print_key_info("Lkp", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to find key (pos[%u]=%d)", i, pos[i]);
}
/* Delete */
for (i = 0; i < 5; i++) {
pos[i] = rte_hash_del_key(handle, &keys[i]);
print_key_info("Del", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to delete key (pos[%u]=%d)", i, pos[i]);
}
/* Lookup */
for (i = 0; i < 5; i++) {
pos[i] = rte_hash_lookup(handle, &keys[i]);
print_key_info("Lkp", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != -ENOENT,
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
"found non-existent key (pos[%u]=%d)", i, pos[i]);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
}
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
/* Lookup multi */
hash: remove aliases for bulk lookup The function rte_hash_lookup_multi() was renamed rte_hash_lookup_bulk() in DPDK 1.4 and was kept as an undocumented alias. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2016-04-19 16:04:00 +00:00
ret = rte_hash_lookup_bulk(handle, &key_array[0], 5, (int32_t *)pos);
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
if (ret == 0)
for (i = 0; i < 5; i++) {
print_key_info("Lkp", key_array[i], pos[i]);
RETURN_IF_ERROR(pos[i] != -ENOENT,
"found not-existent key (pos[%u]=%d)", i, pos[i]);
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
rte_hash_free(handle);
return 0;
}
/*
* Add keys to the same bucket until bucket full.
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
* - add 5 keys to the same bucket (hash created with 4 keys per bucket):
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
* first 4 successful, 5th successful, pushing existing item in bucket
* - lookup the 5 keys: 5 hits
* - add the 5 keys again: 5 OK
* - lookup the 5 keys: 5 hits (updated data)
* - delete the 5 keys: 5 OK
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
* - lookup the 5 keys: 5 misses
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
*/
static int test_full_bucket(void)
{
struct rte_hash_parameters params_pseudo_hash = {
.name = "test4",
.entries = 64,
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
.key_len = sizeof(struct flow_key),
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.hash_func = pseudo_hash,
.hash_func_init_val = 0,
.socket_id = 0,
};
struct rte_hash *handle;
int pos[5];
int expected_pos[5];
unsigned i;
handle = rte_hash_create(&params_pseudo_hash);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
/* Fill bucket */
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
for (i = 0; i < 4; i++) {
pos[i] = rte_hash_add_key(handle, &keys[i]);
print_key_info("Add", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] < 0,
"failed to add key (pos[%u]=%d)", i, pos[i]);
expected_pos[i] = pos[i];
}
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
/*
* This should work and will push one of the items
* in the bucket because it is full
*/
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
pos[4] = rte_hash_add_key(handle, &keys[4]);
print_key_info("Add", &keys[4], pos[4]);
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
RETURN_IF_ERROR(pos[4] < 0,
"failed to add key (pos[4]=%d)", pos[4]);
expected_pos[4] = pos[4];
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/* Lookup */
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
for (i = 0; i < 5; i++) {
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
pos[i] = rte_hash_lookup(handle, &keys[i]);
print_key_info("Lkp", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to find key (pos[%u]=%d)", i, pos[i]);
}
/* Add - update */
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
for (i = 0; i < 5; i++) {
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
pos[i] = rte_hash_add_key(handle, &keys[i]);
print_key_info("Add", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to add key (pos[%u]=%d)", i, pos[i]);
}
/* Lookup */
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
for (i = 0; i < 5; i++) {
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
pos[i] = rte_hash_lookup(handle, &keys[i]);
print_key_info("Lkp", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to find key (pos[%u]=%d)", i, pos[i]);
}
/* Delete 1 key, check other keys are still found */
pos[1] = rte_hash_del_key(handle, &keys[1]);
print_key_info("Del", &keys[1], pos[1]);
RETURN_IF_ERROR(pos[1] != expected_pos[1],
"failed to delete key (pos[1]=%d)", pos[1]);
pos[3] = rte_hash_lookup(handle, &keys[3]);
print_key_info("Lkp", &keys[3], pos[3]);
RETURN_IF_ERROR(pos[3] != expected_pos[3],
"failed lookup after deleting key from same bucket "
"(pos[3]=%d)", pos[3]);
/* Go back to previous state */
pos[1] = rte_hash_add_key(handle, &keys[1]);
print_key_info("Add", &keys[1], pos[1]);
expected_pos[1] = pos[1];
RETURN_IF_ERROR(pos[1] < 0, "failed to add key (pos[1]=%d)", pos[1]);
/* Delete */
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
for (i = 0; i < 5; i++) {
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
pos[i] = rte_hash_del_key(handle, &keys[i]);
print_key_info("Del", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to delete key (pos[%u]=%d)", i, pos[i]);
}
/* Lookup */
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
for (i = 0; i < 5; i++) {
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
pos[i] = rte_hash_lookup(handle, &keys[i]);
print_key_info("Lkp", &keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != -ENOENT,
"fail: found non-existent key (pos[%u]=%d)", i, pos[i]);
}
rte_hash_free(handle);
/* Cover the NULL case. */
rte_hash_free(0);
return 0;
}
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
/*
* Similar to the test above (full bucket test), but for extendable buckets.
*/
static int test_extendable_bucket(void)
{
struct rte_hash_parameters params_pseudo_hash = {
.name = "test5",
.entries = 64,
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
.key_len = sizeof(struct flow_key),
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
.hash_func = pseudo_hash,
.hash_func_init_val = 0,
.socket_id = 0,
.extra_flag = RTE_HASH_EXTRA_FLAGS_EXT_TABLE
};
struct rte_hash *handle;
int pos[64];
int expected_pos[64];
unsigned int i;
struct flow_key rand_keys[64];
for (i = 0; i < 64; i++) {
rand_keys[i].port_dst = i;
rand_keys[i].port_src = i+1;
}
handle = rte_hash_create(&params_pseudo_hash);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
/* Fill bucket */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_add_key(handle, &rand_keys[i]);
print_key_info("Add", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] < 0,
"failed to add key (pos[%u]=%d)", i, pos[i]);
expected_pos[i] = pos[i];
}
/* Lookup */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_lookup(handle, &rand_keys[i]);
print_key_info("Lkp", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to find key (pos[%u]=%d)", i, pos[i]);
}
/* Add - update */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_add_key(handle, &rand_keys[i]);
print_key_info("Add", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to add key (pos[%u]=%d)", i, pos[i]);
}
/* Lookup */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_lookup(handle, &rand_keys[i]);
print_key_info("Lkp", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to find key (pos[%u]=%d)", i, pos[i]);
}
/* Delete 1 key, check other keys are still found */
pos[35] = rte_hash_del_key(handle, &rand_keys[35]);
print_key_info("Del", &rand_keys[35], pos[35]);
RETURN_IF_ERROR(pos[35] != expected_pos[35],
"failed to delete key (pos[1]=%d)", pos[35]);
pos[20] = rte_hash_lookup(handle, &rand_keys[20]);
print_key_info("Lkp", &rand_keys[20], pos[20]);
RETURN_IF_ERROR(pos[20] != expected_pos[20],
"failed lookup after deleting key from same bucket "
"(pos[20]=%d)", pos[20]);
/* Go back to previous state */
pos[35] = rte_hash_add_key(handle, &rand_keys[35]);
print_key_info("Add", &rand_keys[35], pos[35]);
expected_pos[35] = pos[35];
RETURN_IF_ERROR(pos[35] < 0, "failed to add key (pos[1]=%d)", pos[35]);
/* Delete */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_del_key(handle, &rand_keys[i]);
print_key_info("Del", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != expected_pos[i],
"failed to delete key (pos[%u]=%d)", i, pos[i]);
}
/* Lookup */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_lookup(handle, &rand_keys[i]);
print_key_info("Lkp", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] != -ENOENT,
"fail: found non-existent key (pos[%u]=%d)", i, pos[i]);
}
/* Add again */
for (i = 0; i < 64; i++) {
pos[i] = rte_hash_add_key(handle, &rand_keys[i]);
print_key_info("Add", &rand_keys[i], pos[i]);
RETURN_IF_ERROR(pos[i] < 0,
"failed to add key (pos[%u]=%d)", i, pos[i]);
expected_pos[i] = pos[i];
}
rte_hash_free(handle);
/* Cover the NULL case. */
rte_hash_free(0);
return 0;
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/******************************************************************************/
static int
fbk_hash_unit_test(void)
{
struct rte_fbk_hash_params params = {
.name = "fbk_hash_test",
.entries = LOCAL_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 4,
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_1 = {
.name = "invalid_1",
.entries = LOCAL_FBK_HASH_ENTRIES_MAX + 1, /* Not power of 2 */
.entries_per_bucket = 4,
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_2 = {
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.name = "invalid_2",
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.entries = 4,
.entries_per_bucket = 3, /* Not power of 2 */
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_3 = {
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.name = "invalid_3",
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.entries = 0, /* Entries is 0 */
.entries_per_bucket = 4,
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_4 = {
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.name = "invalid_4",
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.entries = LOCAL_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 0, /* Entries per bucket is 0 */
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_5 = {
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.name = "invalid_5",
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.entries = 4,
.entries_per_bucket = 8, /* Entries per bucket > entries */
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_6 = {
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.name = "invalid_6",
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.entries = RTE_FBK_HASH_ENTRIES_MAX * 2, /* Entries > max allowed */
.entries_per_bucket = 4,
.socket_id = 0,
};
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
struct rte_fbk_hash_params invalid_params_7 = {
.name = "invalid_7",
.entries = RTE_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = RTE_FBK_HASH_ENTRIES_PER_BUCKET_MAX * 2, /* Entries > max allowed */
.socket_id = 0,
};
struct rte_fbk_hash_params invalid_params_8 = {
.name = "invalid_7",
.entries = RTE_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 4,
.socket_id = RTE_MAX_NUMA_NODES + 1, /* invalid socket */
};
/* try to create two hashes with identical names
* in this case, trying to create a second one will not
* fail but will simply return pointer to the existing
* hash with that name. sort of like a "find hash by name" :-)
*/
struct rte_fbk_hash_params invalid_params_same_name_1 = {
.name = "same_name", /* hash with identical name */
.entries = 4,
.entries_per_bucket = 2,
.socket_id = 0,
};
/* trying to create this hash should return a pointer to an existing hash */
struct rte_fbk_hash_params invalid_params_same_name_2 = {
.name = "same_name", /* hash with identical name */
.entries = RTE_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 4,
.socket_id = 0,
};
/* this is a sanity check for "same name" test
* creating this hash will check if we are actually able to create
* multiple hashes with different names (instead of having just one).
*/
struct rte_fbk_hash_params different_name = {
.name = "different_name", /* different name */
app/test: decrease memory requirements for hash In hash autotest, the size of tables that should be successfully created is 32K entries (256KB), except for the table called "different_name", which is 1M entries (8MB). When memory is too fragmented (with 2M hugepages), the test can fail. To avoid allocation failures due to memory fragmentation, decrease the size of the table to 32K. Signed-off-by: Olivier Matz <olivier.matz@6wind.com>
2016-09-12 11:38:08 +00:00
.entries = LOCAL_FBK_HASH_ENTRIES_MAX,
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.entries_per_bucket = 4,
.socket_id = 0,
};
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
struct rte_fbk_hash_params params_jhash = {
.name = "valid",
.entries = LOCAL_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 4,
.socket_id = 0,
.hash_func = rte_jhash_1word, /* Tests for different hash_func */
.init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT,
};
struct rte_fbk_hash_params params_nohash = {
.name = "valid nohash",
.entries = LOCAL_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 4,
.socket_id = 0,
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
.hash_func = NULL, /* Tests for null hash_func */
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
.init_val = RTE_FBK_HASH_INIT_VAL_DEFAULT,
};
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
struct rte_fbk_hash_table *handle, *tmp;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
uint32_t keys[5] =
{0xc6e18639, 0xe67c201c, 0xd4c8cffd, 0x44728691, 0xd5430fa9};
uint16_t vals[5] = {28108, 5699, 38490, 2166, 61571};
int status;
unsigned i;
double used_entries;
/* Try creating hashes with invalid parameters */
hash: fix for multi-process apps Signed-off-by: Intel
2013-06-03 00:00:00 +00:00
printf("# Testing hash creation with invalid parameters "
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
"- expect error msgs\n");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
handle = rte_fbk_hash_create(&invalid_params_1);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
handle = rte_fbk_hash_create(&invalid_params_2);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
handle = rte_fbk_hash_create(&invalid_params_3);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
handle = rte_fbk_hash_create(&invalid_params_4);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
handle = rte_fbk_hash_create(&invalid_params_5);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
handle = rte_fbk_hash_create(&invalid_params_6);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
handle = rte_fbk_hash_create(&invalid_params_7);
RETURN_IF_ERROR_FBK(handle != NULL, "fbk hash creation should have failed");
test: skip some subtests in no-huge mode When running with '--no-huge' flag, tests failed with messages as: ACL context creation with invalid NUMA should have failed! fbk hash creation should have failed test_table_pipeline: Check pipeline invalid params failed. These cases test against invalid socket ID as input parameter, and expect error return. But function calls return success because invalid sock ID is overwritten to SOCKET_ID_ANY when in no-huge mode. The tests against invalid socket ID are skipped in no-huge mode. Fixes: 5640171c528a ("malloc: fix external heap allocation in no-huge mode") Cc: stable@dpdk.org Signed-off-by: Ruifeng Wang <ruifeng.wang@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Acked-by: Aaron Conole <aconole@redhat.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2020-03-23 19:59:23 +00:00
if (rte_eal_has_hugepages()) {
handle = rte_fbk_hash_create(&invalid_params_8);
RETURN_IF_ERROR_FBK(handle != NULL,
"fbk hash creation should have failed");
}
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
handle = rte_fbk_hash_create(&invalid_params_same_name_1);
RETURN_IF_ERROR_FBK(handle == NULL, "fbk hash creation should have succeeded");
tmp = rte_fbk_hash_create(&invalid_params_same_name_2);
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
if (tmp != NULL)
rte_fbk_hash_free(tmp);
RETURN_IF_ERROR_FBK(tmp != NULL, "fbk hash creation should have failed");
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
/* we are not freeing handle here because we need a hash list
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
* to be not empty for the next test */
/* create a hash in non-empty list - good for coverage */
tmp = rte_fbk_hash_create(&different_name);
RETURN_IF_ERROR_FBK(tmp == NULL, "fbk hash creation should have succeeded");
/* free both hashes */
rte_fbk_hash_free(handle);
rte_fbk_hash_free(tmp);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/* Create empty jhash hash. */
handle = rte_fbk_hash_create(&params_jhash);
RETURN_IF_ERROR_FBK(handle == NULL, "fbk jhash hash creation failed");
/* Cleanup. */
rte_fbk_hash_free(handle);
/* Create empty jhash hash. */
handle = rte_fbk_hash_create(&params_nohash);
RETURN_IF_ERROR_FBK(handle == NULL, "fbk nohash hash creation failed");
/* Cleanup. */
rte_fbk_hash_free(handle);
/* Create empty hash. */
handle = rte_fbk_hash_create(&params);
RETURN_IF_ERROR_FBK(handle == NULL, "fbk hash creation failed");
used_entries = rte_fbk_hash_get_load_factor(handle) * LOCAL_FBK_HASH_ENTRIES_MAX;
RETURN_IF_ERROR_FBK((unsigned)used_entries != 0, \
"load factor right after creation is not zero but it should be");
/* Add keys. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_add_key(handle, keys[i], vals[i]);
RETURN_IF_ERROR_FBK(status != 0, "fbk hash add failed");
}
used_entries = rte_fbk_hash_get_load_factor(handle) * LOCAL_FBK_HASH_ENTRIES_MAX;
RETURN_IF_ERROR_FBK((unsigned)used_entries != (unsigned)((((double)5)/LOCAL_FBK_HASH_ENTRIES_MAX)*LOCAL_FBK_HASH_ENTRIES_MAX), \
"load factor now is not as expected");
/* Find value of added keys. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_lookup(handle, keys[i]);
RETURN_IF_ERROR_FBK(status != vals[i],
"fbk hash lookup failed");
}
/* Change value of added keys. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_add_key(handle, keys[i], vals[4 - i]);
RETURN_IF_ERROR_FBK(status != 0, "fbk hash update failed");
}
/* Find new values. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_lookup(handle, keys[i]);
RETURN_IF_ERROR_FBK(status != vals[4-i],
"fbk hash lookup failed");
}
/* Delete keys individually. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_delete_key(handle, keys[i]);
RETURN_IF_ERROR_FBK(status != 0, "fbk hash delete failed");
}
used_entries = rte_fbk_hash_get_load_factor(handle) * LOCAL_FBK_HASH_ENTRIES_MAX;
RETURN_IF_ERROR_FBK((unsigned)used_entries != 0, \
"load factor right after deletion is not zero but it should be");
/* Lookup should now fail. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_lookup(handle, keys[i]);
RETURN_IF_ERROR_FBK(status == 0,
"fbk hash lookup should have failed");
}
/* Add keys again. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_add_key(handle, keys[i], vals[i]);
RETURN_IF_ERROR_FBK(status != 0, "fbk hash add failed");
}
/* Make sure they were added. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_lookup(handle, keys[i]);
RETURN_IF_ERROR_FBK(status != vals[i],
"fbk hash lookup failed");
}
/* Clear all entries. */
rte_fbk_hash_clear_all(handle);
/* Lookup should fail. */
for (i = 0; i < 5; i++) {
status = rte_fbk_hash_lookup(handle, keys[i]);
RETURN_IF_ERROR_FBK(status == 0,
"fbk hash lookup should have failed");
}
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* coverage */
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* fill up the hash_table */
for (i = 0; i < RTE_FBK_HASH_ENTRIES_MAX + 1; i++)
rte_fbk_hash_add_key(handle, i, (uint16_t) i);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* Find non-existent key in a full hashtable */
status = rte_fbk_hash_lookup(handle, RTE_FBK_HASH_ENTRIES_MAX + 1);
RETURN_IF_ERROR_FBK(status != -ENOENT,
"fbk hash lookup succeeded");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* Delete non-existent key in a full hashtable */
status = rte_fbk_hash_delete_key(handle, RTE_FBK_HASH_ENTRIES_MAX + 1);
RETURN_IF_ERROR_FBK(status != -ENOENT,
"fbk hash delete succeeded");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* Delete one key from a full hashtable */
status = rte_fbk_hash_delete_key(handle, 1);
RETURN_IF_ERROR_FBK(status != 0,
"fbk hash delete failed");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* Clear all entries. */
rte_fbk_hash_clear_all(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* Cleanup. */
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
rte_fbk_hash_free(handle);
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
/* Cover the NULL case. */
rte_fbk_hash_free(0);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return 0;
}
/*
* Sequence of operations for find existing fbk hash table
*
* - create table
* - find existing table: hit
* - find non-existing table: miss
*
*/
static int test_fbk_hash_find_existing(void)
{
struct rte_fbk_hash_params params = {
.name = "fbk_hash_find_existing",
.entries = LOCAL_FBK_HASH_ENTRIES_MAX,
.entries_per_bucket = 4,
.socket_id = 0,
};
struct rte_fbk_hash_table *handle = NULL, *result = NULL;
/* Create hash table. */
handle = rte_fbk_hash_create(&params);
RETURN_IF_ERROR_FBK(handle == NULL, "fbk hash creation failed");
/* Try to find existing fbk hash table */
result = rte_fbk_hash_find_existing("fbk_hash_find_existing");
RETURN_IF_ERROR_FBK(result != handle, "could not find existing fbk hash table");
/* Try to find non-existing fbk hash table */
result = rte_fbk_hash_find_existing("fbk_hash_find_non_existing");
RETURN_IF_ERROR_FBK(!(result == NULL), "found fbk table that shouldn't exist");
/* Cleanup. */
rte_fbk_hash_free(handle);
return 0;
}
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
#define BUCKET_ENTRIES 4
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Do tests for hash creation with bad parameters.
*/
static int test_hash_creation_with_bad_parameters(void)
{
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
struct rte_hash *handle, *tmp;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
struct rte_hash_parameters params;
handle = rte_hash_create(NULL);
if (handle != NULL) {
rte_hash_free(handle);
fix typos using codespell utility Fixing typos across dpdk source code using codespell utility. Skipped the ethdev driver's base code fixes to keep the base code intact. Signed-off-by: Jerin Jacob <jerin.jacob@caviumnetworks.com> Acked-by: John McNamara <john.mcnamara@intel.com>
2017-06-07 05:05:06 +00:00
printf("Impossible creating hash successfully without any parameter\n");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return -1;
}
memcpy(&params, &ut_params, sizeof(params));
params.name = "creation_with_bad_parameters_0";
params.entries = RTE_HASH_ENTRIES_MAX + 1;
handle = rte_hash_create(&params);
if (handle != NULL) {
rte_hash_free(handle);
fix typos using codespell utility Fixing typos across dpdk source code using codespell utility. Skipped the ethdev driver's base code fixes to keep the base code intact. Signed-off-by: Jerin Jacob <jerin.jacob@caviumnetworks.com> Acked-by: John McNamara <john.mcnamara@intel.com>
2017-06-07 05:05:06 +00:00
printf("Impossible creating hash successfully with entries in parameter exceeded\n");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return -1;
}
memcpy(&params, &ut_params, sizeof(params));
params.name = "creation_with_bad_parameters_2";
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
params.entries = BUCKET_ENTRIES - 1;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
handle = rte_hash_create(&params);
if (handle != NULL) {
rte_hash_free(handle);
fix typos using codespell utility Fixing typos across dpdk source code using codespell utility. Skipped the ethdev driver's base code fixes to keep the base code intact. Signed-off-by: Jerin Jacob <jerin.jacob@caviumnetworks.com> Acked-by: John McNamara <john.mcnamara@intel.com>
2017-06-07 05:05:06 +00:00
printf("Impossible creating hash successfully if entries less than bucket_entries in parameter\n");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return -1;
}
memcpy(&params, &ut_params, sizeof(params));
params.name = "creation_with_bad_parameters_3";
params.key_len = 0;
handle = rte_hash_create(&params);
if (handle != NULL) {
rte_hash_free(handle);
fix typos using codespell utility Fixing typos across dpdk source code using codespell utility. Skipped the ethdev driver's base code fixes to keep the base code intact. Signed-off-by: Jerin Jacob <jerin.jacob@caviumnetworks.com> Acked-by: John McNamara <john.mcnamara@intel.com>
2017-06-07 05:05:06 +00:00
printf("Impossible creating hash successfully if key_len in parameter is zero\n");
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return -1;
}
memcpy(&params, &ut_params, sizeof(params));
hash: replace with cuckoo hash implementation This patch replaces the existing hash library with another approach, using the Cuckoo Hash method to resolve collisions (open addressing), which pushes items from a full bucket when a new entry tries to be added in it, storing the evicted entry in an alternative location, using a secondary hash function. This gives the user the ability to store more entries when a bucket is full, in comparison with the previous implementation. Therefore, the unit test has been updated, as some scenarios have changed (such as the previous removed restriction). Also note that the API has not been changed, although new fields have been added in the rte_hash structure (structure is internal now). The main change when creating a new table is that the number of entries per bucket is fixed now, so its parameter is ignored now (still there to maintain the same parameters structure). The hash unit test has been updated to reflect these changes. As a last note, the maximum burst size in lookup_burst function hash been increased to 64, to improve performance. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:50 +00:00
params.name = "creation_with_bad_parameters_4";
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
params.socket_id = RTE_MAX_NUMA_NODES + 1;
handle = rte_hash_create(&params);
if (handle != NULL) {
rte_hash_free(handle);
fix typos using codespell utility Fixing typos across dpdk source code using codespell utility. Skipped the ethdev driver's base code fixes to keep the base code intact. Signed-off-by: Jerin Jacob <jerin.jacob@caviumnetworks.com> Acked-by: John McNamara <john.mcnamara@intel.com>
2017-06-07 05:05:06 +00:00
printf("Impossible creating hash successfully with invalid socket\n");
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
return -1;
}
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
/* test with same name should fail */
memcpy(&params, &ut_params, sizeof(params));
params.name = "same_name";
handle = rte_hash_create(&params);
if (handle == NULL) {
printf("Cannot create first hash table with 'same_name'\n");
return -1;
}
tmp = rte_hash_create(&params);
if (tmp != NULL) {
printf("Creation of hash table with same name should fail\n");
rte_hash_free(handle);
rte_hash_free(tmp);
return -1;
}
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
rte_hash_free(handle);
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
printf("# Test successful. No more errors expected\n");
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
return 0;
}
/*
* Do tests for hash creation with parameters that look incorrect
* but are actually valid.
*/
static int
test_hash_creation_with_good_parameters(void)
{
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
struct rte_hash *handle;
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
struct rte_hash_parameters params;
/* create with null hash function - should choose DEFAULT_HASH_FUNC */
memcpy(&params, &ut_params, sizeof(params));
hash: fix allocation of an existing object Change rte_hash*_create() functions to return NULL and set rte_errno to EEXIST when the object name already exists. This is the behavior described in the API documentation in the header file. These functions were returning a pointer to the existing object in that case, but it is a problem as the caller did not know if the object had to be freed or not. Doing this change also makes the hash API more consistent with the other APIs (mempool, rings, ...). Fixes: 916e4f4f4e ("memory: fix for multi process support") Signed-off-by: Olivier Matz <olivier.matz@6wind.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-04-06 13:27:59 +00:00
params.name = "name";
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
params.hash_func = NULL;
handle = rte_hash_create(&params);
if (handle == NULL) {
printf("Creating hash with null hash_func failed\n");
return -1;
}
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return 0;
}
app/test: shorten execution time The autotests are too long to be run often. This patch reduces the needed time of some tests in fast_test. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2016-05-04 15:15:05 +00:00
#define ITERATIONS 3
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
/*
* Test to see the average table utilization (entries added/max entries)
* before hitting a random entry that cannot be added
*/
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
static int test_average_table_utilization(uint32_t ext_table)
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
{
struct rte_hash *handle;
hash: remove deprecated function and macros The function rte_jhash2() was renamed rte_jhash_32b and macros RTE_HASH_KEY_LENGTH_MAX and RTE_HASH_BUCKET_ENTRIES_MAX were tagged as deprecated, so they can be removed in 2.2. RTE_HASH_KEY_LENGTH is replaced in unit tests by an internal macro for the memory allocation of all keys used. The library version number is incremented. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2015-09-04 09:05:40 +00:00
uint8_t simple_key[MAX_KEYSIZE];
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
unsigned i, j;
unsigned added_keys, average_keys_added = 0;
int ret;
hash: add API to query the key count Add a new function, rte_hash_count, to return the number of keys that are currently stored in the hash table. Corresponding test functions are added into hash_test and hash_multiwriter test. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2018-07-10 17:00:01 +00:00
unsigned int cnt;
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
printf("\n# Running test to determine average utilization"
"\n before adding elements begins to fail\n");
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (ext_table)
printf("ext table is enabled\n");
else
printf("ext table is disabled\n");
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
printf("Measuring performance, please wait");
fflush(stdout);
app/test: shorten execution time The autotests are too long to be run often. This patch reduces the needed time of some tests in fast_test. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2016-05-04 15:15:05 +00:00
ut_params.entries = 1 << 16;
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
ut_params.name = "test_average_utilization";
ut_params.hash_func = rte_jhash;
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (ext_table)
ut_params.extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
else
ut_params.extra_flag &= ~RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
handle = rte_hash_create(&ut_params);
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
for (j = 0; j < ITERATIONS; j++) {
ret = 0;
/* Add random entries until key cannot be added */
for (added_keys = 0; ret >= 0; added_keys++) {
for (i = 0; i < ut_params.key_len; i++)
simple_key[i] = rte_rand() % 255;
ret = rte_hash_add_key(handle, simple_key);
hash: add API to query the key count Add a new function, rte_hash_count, to return the number of keys that are currently stored in the hash table. Corresponding test functions are added into hash_test and hash_multiwriter test. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2018-07-10 17:00:01 +00:00
if (ret < 0)
break;
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
}
hash: add API to query the key count Add a new function, rte_hash_count, to return the number of keys that are currently stored in the hash table. Corresponding test functions are added into hash_test and hash_multiwriter test. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2018-07-10 17:00:01 +00:00
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
if (ret != -ENOSPC) {
printf("Unexpected error when adding keys\n");
rte_hash_free(handle);
return -1;
}
hash: add API to query the key count Add a new function, rte_hash_count, to return the number of keys that are currently stored in the hash table. Corresponding test functions are added into hash_test and hash_multiwriter test. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2018-07-10 17:00:01 +00:00
cnt = rte_hash_count(handle);
if (cnt != added_keys) {
printf("rte_hash_count returned wrong value %u, %u,"
"%u\n", j, added_keys, cnt);
rte_hash_free(handle);
return -1;
}
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (ext_table) {
if (cnt != ut_params.entries) {
printf("rte_hash_count returned wrong value "
"%u, %u, %u\n", j, added_keys, cnt);
rte_hash_free(handle);
return -1;
}
}
hash: add API to query the key count Add a new function, rte_hash_count, to return the number of keys that are currently stored in the hash table. Corresponding test functions are added into hash_test and hash_multiwriter test. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2018-07-10 17:00:01 +00:00
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
average_keys_added += added_keys;
/* Reset the table */
hash: add reset function Added reset function to be able to empty the table, without having to destroy and create it again. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:51 +00:00
rte_hash_reset(handle);
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
/* Print a dot to show progress on operations */
printf(".");
fflush(stdout);
}
average_keys_added /= ITERATIONS;
printf("\nAverage table utilization = %.2f%% (%u/%u)\n",
((double) average_keys_added / ut_params.entries * 100),
average_keys_added, ut_params.entries);
rte_hash_free(handle);
return 0;
}
app/test: shorten execution time The autotests are too long to be run often. This patch reduces the needed time of some tests in fast_test. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2016-05-04 15:15:05 +00:00
#define NUM_ENTRIES 256
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
static int test_hash_iteration(uint32_t ext_table)
hash: add iterate function Since now rte_hash structure is private, a new function has been added to let the user iterate through the hash table, returning next key and data associated on each iteration, plus the position where they were stored. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:53 +00:00
{
struct rte_hash *handle;
unsigned i;
hash: remove deprecated function and macros The function rte_jhash2() was renamed rte_jhash_32b and macros RTE_HASH_KEY_LENGTH_MAX and RTE_HASH_BUCKET_ENTRIES_MAX were tagged as deprecated, so they can be removed in 2.2. RTE_HASH_KEY_LENGTH is replaced in unit tests by an internal macro for the memory allocation of all keys used. The library version number is incremented. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com>
2015-09-04 09:05:40 +00:00
uint8_t keys[NUM_ENTRIES][MAX_KEYSIZE];
hash: add iterate function Since now rte_hash structure is private, a new function has been added to let the user iterate through the hash table, returning next key and data associated on each iteration, plus the position where they were stored. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:53 +00:00
const void *next_key;
void *next_data;
void *data[NUM_ENTRIES];
unsigned added_keys;
uint32_t iter = 0;
int ret = 0;
ut_params.entries = NUM_ENTRIES;
ut_params.name = "test_hash_iteration";
ut_params.hash_func = rte_jhash;
ut_params.key_len = 16;
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (ext_table)
ut_params.extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
else
ut_params.extra_flag &= ~RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
hash: add iterate function Since now rte_hash structure is private, a new function has been added to let the user iterate through the hash table, returning next key and data associated on each iteration, plus the position where they were stored. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:53 +00:00
handle = rte_hash_create(&ut_params);
RETURN_IF_ERROR(handle == NULL, "hash creation failed");
/* Add random entries until key cannot be added */
for (added_keys = 0; added_keys < NUM_ENTRIES; added_keys++) {
data[added_keys] = (void *) ((uintptr_t) rte_rand());
for (i = 0; i < ut_params.key_len; i++)
keys[added_keys][i] = rte_rand() % 255;
ret = rte_hash_add_key_data(handle, keys[added_keys], data[added_keys]);
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (ret < 0) {
if (ext_table) {
printf("Insertion failed for ext table\n");
goto err;
}
hash: add iterate function Since now rte_hash structure is private, a new function has been added to let the user iterate through the hash table, returning next key and data associated on each iteration, plus the position where they were stored. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:53 +00:00
break;
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
}
hash: add iterate function Since now rte_hash structure is private, a new function has been added to let the user iterate through the hash table, returning next key and data associated on each iteration, plus the position where they were stored. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:53 +00:00
}
/* Iterate through the hash table */
while (rte_hash_iterate(handle, &next_key, &next_data, &iter) >= 0) {
/* Search for the key in the list of keys added */
for (i = 0; i < NUM_ENTRIES; i++) {
if (memcmp(next_key, keys[i], ut_params.key_len) == 0) {
if (next_data != data[i]) {
printf("Data found in the hash table is"
"not the data added with the key\n");
goto err;
}
added_keys--;
break;
}
}
if (i == NUM_ENTRIES) {
printf("Key found in the hash table was not added\n");
goto err;
}
}
/* Check if all keys have been iterated */
if (added_keys != 0) {
printf("There were still %u keys to iterate\n", added_keys);
goto err;
}
rte_hash_free(handle);
return 0;
err:
rte_hash_free(handle);
return -1;
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
static uint8_t key[16] = {0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f};
static struct rte_hash_parameters hash_params_ex = {
.name = NULL,
.entries = 64,
.key_len = 0,
.hash_func = NULL,
.hash_func_init_val = 0,
.socket_id = 0,
};
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
/*
* Wrapper function around rte_jhash_32b.
* It is required because rte_jhash_32b() accepts the length
* as size of 4-byte units.
*/
static inline uint32_t
test_jhash_32b(const void *k, uint32_t length, uint32_t initval)
{
return rte_jhash_32b(k, length >> 2, initval);
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* add/delete key with jhash2
*/
static int
test_hash_add_delete_jhash2(void)
{
int ret = -1;
struct rte_hash *handle;
int32_t pos1, pos2;
hash_params_ex.name = "hash_test_jhash2";
hash_params_ex.key_len = 4;
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
hash_params_ex.hash_func = (rte_hash_function)test_jhash_32b;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
handle = rte_hash_create(&hash_params_ex);
if (handle == NULL) {
printf("test_hash_add_delete_jhash2 fail to create hash\n");
goto fail_jhash2;
}
pos1 = rte_hash_add_key(handle, (void *)&key[0]);
if (pos1 < 0) {
printf("test_hash_add_delete_jhash2 fail to add hash key\n");
goto fail_jhash2;
}
pos2 = rte_hash_del_key(handle, (void *)&key[0]);
if (pos2 < 0 || pos1 != pos2) {
printf("test_hash_add_delete_jhash2 delete different key from being added\n");
goto fail_jhash2;
}
ret = 0;
fail_jhash2:
remove unnecessary null checks Functions like free, rte_free, and rte_mempool_free already handle NULL pointer so the checks here are not necessary. Remove redundant NULL pointer checks before free functions found by nullfree.cocci Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
2022-02-09 19:17:15 +00:00
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return ret;
}
/*
* add/delete (2) key with jhash2
*/
static int
test_hash_add_delete_2_jhash2(void)
{
int ret = -1;
struct rte_hash *handle;
int32_t pos1, pos2;
hash_params_ex.name = "hash_test_2_jhash2";
hash_params_ex.key_len = 8;
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
hash_params_ex.hash_func = (rte_hash_function)test_jhash_32b;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
handle = rte_hash_create(&hash_params_ex);
if (handle == NULL)
goto fail_2_jhash2;
pos1 = rte_hash_add_key(handle, (void *)&key[0]);
if (pos1 < 0)
goto fail_2_jhash2;
pos2 = rte_hash_del_key(handle, (void *)&key[0]);
if (pos2 < 0 || pos1 != pos2)
goto fail_2_jhash2;
ret = 0;
fail_2_jhash2:
remove unnecessary null checks Functions like free, rte_free, and rte_mempool_free already handle NULL pointer so the checks here are not necessary. Remove redundant NULL pointer checks before free functions found by nullfree.cocci Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
2022-02-09 19:17:15 +00:00
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return ret;
}
static uint32_t
test_hash_jhash_1word(const void *key, uint32_t length, uint32_t initval)
{
const uint32_t *k = key;
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
RTE_SET_USED(length);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return rte_jhash_1word(k[0], initval);
}
static uint32_t
test_hash_jhash_2word(const void *key, uint32_t length, uint32_t initval)
{
const uint32_t *k = key;
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
RTE_SET_USED(length);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return rte_jhash_2words(k[0], k[1], initval);
}
static uint32_t
test_hash_jhash_3word(const void *key, uint32_t length, uint32_t initval)
{
const uint32_t *k = key;
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
RTE_SET_USED(length);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return rte_jhash_3words(k[0], k[1], k[2], initval);
}
/*
* add/delete key with jhash 1word
*/
static int
test_hash_add_delete_jhash_1word(void)
{
int ret = -1;
struct rte_hash *handle;
int32_t pos1, pos2;
hash_params_ex.name = "hash_test_jhash_1word";
hash_params_ex.key_len = 4;
hash_params_ex.hash_func = test_hash_jhash_1word;
handle = rte_hash_create(&hash_params_ex);
if (handle == NULL)
goto fail_jhash_1word;
pos1 = rte_hash_add_key(handle, (void *)&key[0]);
if (pos1 < 0)
goto fail_jhash_1word;
pos2 = rte_hash_del_key(handle, (void *)&key[0]);
if (pos2 < 0 || pos1 != pos2)
goto fail_jhash_1word;
ret = 0;
fail_jhash_1word:
remove unnecessary null checks Functions like free, rte_free, and rte_mempool_free already handle NULL pointer so the checks here are not necessary. Remove redundant NULL pointer checks before free functions found by nullfree.cocci Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
2022-02-09 19:17:15 +00:00
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return ret;
}
/*
* add/delete key with jhash 2word
*/
static int
test_hash_add_delete_jhash_2word(void)
{
int ret = -1;
struct rte_hash *handle;
int32_t pos1, pos2;
hash_params_ex.name = "hash_test_jhash_2word";
hash_params_ex.key_len = 8;
hash_params_ex.hash_func = test_hash_jhash_2word;
handle = rte_hash_create(&hash_params_ex);
if (handle == NULL)
goto fail_jhash_2word;
pos1 = rte_hash_add_key(handle, (void *)&key[0]);
if (pos1 < 0)
goto fail_jhash_2word;
pos2 = rte_hash_del_key(handle, (void *)&key[0]);
if (pos2 < 0 || pos1 != pos2)
goto fail_jhash_2word;
ret = 0;
fail_jhash_2word:
remove unnecessary null checks Functions like free, rte_free, and rte_mempool_free already handle NULL pointer so the checks here are not necessary. Remove redundant NULL pointer checks before free functions found by nullfree.cocci Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
2022-02-09 19:17:15 +00:00
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return ret;
}
/*
* add/delete key with jhash 3word
*/
static int
test_hash_add_delete_jhash_3word(void)
{
int ret = -1;
struct rte_hash *handle;
int32_t pos1, pos2;
hash_params_ex.name = "hash_test_jhash_3word";
hash_params_ex.key_len = 12;
hash_params_ex.hash_func = test_hash_jhash_3word;
handle = rte_hash_create(&hash_params_ex);
if (handle == NULL)
goto fail_jhash_3word;
pos1 = rte_hash_add_key(handle, (void *)&key[0]);
if (pos1 < 0)
goto fail_jhash_3word;
pos2 = rte_hash_del_key(handle, (void *)&key[0]);
if (pos2 < 0 || pos1 != pos2)
goto fail_jhash_3word;
ret = 0;
fail_jhash_3word:
remove unnecessary null checks Functions like free, rte_free, and rte_mempool_free already handle NULL pointer so the checks here are not necessary. Remove redundant NULL pointer checks before free functions found by nullfree.cocci Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
2022-02-09 19:17:15 +00:00
rte_hash_free(handle);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return ret;
}
test/hash: add RCU tests Add functional and performance tests for the integrated RCU QSBR. Suggested-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2020-10-21 22:50:06 +00:00
static struct rte_hash *g_handle;
static struct rte_rcu_qsbr *g_qsv;
static volatile uint8_t writer_done;
struct flow_key g_rand_keys[9];
/*
* rte_hash_rcu_qsbr_add positive and negative tests.
* - Add RCU QSBR variable to Hash
* - Add another RCU QSBR variable to Hash
* - Check returns
*/
static int
test_hash_rcu_qsbr_add(void)
{
size_t sz;
struct rte_rcu_qsbr *qsv2 = NULL;
int32_t status;
struct rte_hash_rcu_config rcu_cfg = {0};
struct rte_hash_parameters params;
printf("\n# Running RCU QSBR add tests\n");
memcpy(&params, &ut_params, sizeof(params));
params.name = "test_hash_rcu_qsbr_add";
params.extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF |
RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD;
g_handle = rte_hash_create(&params);
RETURN_IF_ERROR_RCU_QSBR(g_handle == NULL, "Hash creation failed");
/* Create RCU QSBR variable */
sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
g_qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
RETURN_IF_ERROR_RCU_QSBR(g_qsv == NULL,
"RCU QSBR variable creation failed");
status = rte_rcu_qsbr_init(g_qsv, RTE_MAX_LCORE);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"RCU QSBR variable initialization failed");
rcu_cfg.v = g_qsv;
/* Invalid QSBR mode */
rcu_cfg.mode = 0xff;
status = rte_hash_rcu_qsbr_add(g_handle, &rcu_cfg);
RETURN_IF_ERROR_RCU_QSBR(status == 0, "Invalid QSBR mode test failed");
rcu_cfg.mode = RTE_HASH_QSBR_MODE_DQ;
/* Attach RCU QSBR to hash table */
status = rte_hash_rcu_qsbr_add(g_handle, &rcu_cfg);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"Attach RCU QSBR to hash table failed");
/* Create and attach another RCU QSBR to hash table */
qsv2 = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
RETURN_IF_ERROR_RCU_QSBR(qsv2 == NULL,
"RCU QSBR variable creation failed");
rcu_cfg.v = qsv2;
rcu_cfg.mode = RTE_HASH_QSBR_MODE_SYNC;
status = rte_hash_rcu_qsbr_add(g_handle, &rcu_cfg);
rte_free(qsv2);
RETURN_IF_ERROR_RCU_QSBR(status == 0,
"Attach RCU QSBR to hash table succeeded where failure"
" is expected");
rte_hash_free(g_handle);
rte_free(g_qsv);
return 0;
}
/*
* rte_hash_rcu_qsbr_add DQ mode functional test.
* Reader and writer are in the same thread in this test.
* - Create hash which supports maximum 8 (9 if ext bkt is enabled) entries
* - Add RCU QSBR variable to hash
* - Add 8 hash entries and fill the bucket
* - If ext bkt is enabled, add 1 extra entry that is available in the ext bkt
* - Register a reader thread (not a real thread)
* - Reader lookup existing entry
* - Writer deletes the entry
* - Reader lookup the entry
* - Writer re-add the entry (no available free index)
* - Reader report quiescent state and unregister
* - Writer re-add the entry
* - Reader lookup the entry
*/
static int
test_hash_rcu_qsbr_dq_mode(uint8_t ext_bkt)
{
uint32_t total_entries = (ext_bkt == 0) ? 8 : 9;
uint8_t hash_extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF;
if (ext_bkt)
hash_extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
struct rte_hash_parameters params_pseudo_hash = {
.name = "test_hash_rcu_qsbr_dq_mode",
.entries = total_entries,
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
.key_len = sizeof(struct flow_key),
test/hash: add RCU tests Add functional and performance tests for the integrated RCU QSBR. Suggested-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2020-10-21 22:50:06 +00:00
.hash_func = pseudo_hash,
.hash_func_init_val = 0,
.socket_id = 0,
.extra_flag = hash_extra_flag,
};
int pos[total_entries];
int expected_pos[total_entries];
unsigned int i;
size_t sz;
int32_t status;
struct rte_hash_rcu_config rcu_cfg = {0};
g_qsv = NULL;
g_handle = NULL;
for (i = 0; i < total_entries; i++) {
g_rand_keys[i].port_dst = i;
g_rand_keys[i].port_src = i+1;
}
if (ext_bkt)
printf("\n# Running RCU QSBR DQ mode functional test with"
" ext bkt\n");
else
printf("\n# Running RCU QSBR DQ mode functional test\n");
g_handle = rte_hash_create(&params_pseudo_hash);
RETURN_IF_ERROR_RCU_QSBR(g_handle == NULL, "Hash creation failed");
/* Create RCU QSBR variable */
sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
g_qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
RETURN_IF_ERROR_RCU_QSBR(g_qsv == NULL,
"RCU QSBR variable creation failed");
status = rte_rcu_qsbr_init(g_qsv, RTE_MAX_LCORE);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"RCU QSBR variable initialization failed");
rcu_cfg.v = g_qsv;
rcu_cfg.mode = RTE_HASH_QSBR_MODE_DQ;
/* Attach RCU QSBR to hash table */
status = rte_hash_rcu_qsbr_add(g_handle, &rcu_cfg);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"Attach RCU QSBR to hash table failed");
/* Fill bucket */
for (i = 0; i < total_entries; i++) {
pos[i] = rte_hash_add_key(g_handle, &g_rand_keys[i]);
print_key_info("Add", &g_rand_keys[i], pos[i]);
RETURN_IF_ERROR_RCU_QSBR(pos[i] < 0,
"failed to add key (pos[%u]=%d)", i,
pos[i]);
expected_pos[i] = pos[i];
}
/* Register pseudo reader */
status = rte_rcu_qsbr_thread_register(g_qsv, 0);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"RCU QSBR thread registration failed");
rte_rcu_qsbr_thread_online(g_qsv, 0);
/* Lookup */
pos[0] = rte_hash_lookup(g_handle, &g_rand_keys[0]);
print_key_info("Lkp", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] != expected_pos[0],
"failed to find correct key (pos[%u]=%d)", 0,
pos[0]);
/* Writer update */
pos[0] = rte_hash_del_key(g_handle, &g_rand_keys[0]);
print_key_info("Del", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] != expected_pos[0],
"failed to del correct key (pos[%u]=%d)", 0,
pos[0]);
/* Lookup */
pos[0] = rte_hash_lookup(g_handle, &g_rand_keys[0]);
print_key_info("Lkp", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] != -ENOENT,
"found deleted key (pos[%u]=%d)", 0, pos[0]);
/* Fill bucket */
pos[0] = rte_hash_add_key(g_handle, &g_rand_keys[0]);
print_key_info("Add", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] != -ENOSPC,
"Added key successfully (pos[%u]=%d)", 0, pos[0]);
/* Reader quiescent */
rte_rcu_qsbr_quiescent(g_qsv, 0);
/* Fill bucket */
pos[0] = rte_hash_add_key(g_handle, &g_rand_keys[0]);
print_key_info("Add", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] < 0,
"failed to add key (pos[%u]=%d)", 0, pos[0]);
expected_pos[0] = pos[0];
rte_rcu_qsbr_thread_offline(g_qsv, 0);
(void)rte_rcu_qsbr_thread_unregister(g_qsv, 0);
/* Lookup */
pos[0] = rte_hash_lookup(g_handle, &g_rand_keys[0]);
print_key_info("Lkp", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] != expected_pos[0],
"failed to find correct key (pos[%u]=%d)", 0,
pos[0]);
rte_hash_free(g_handle);
rte_free(g_qsv);
return 0;
}
/* Report quiescent state interval every 1024 lookups. Larger critical
* sections in reader will result in writer polling multiple times.
*/
#define QSBR_REPORTING_INTERVAL 1024
#define WRITER_ITERATIONS 512
/*
* Reader thread using rte_hash data structure with RCU.
*/
static int
test_hash_rcu_qsbr_reader(void *arg)
{
int i;
RTE_SET_USED(arg);
/* Register this thread to report quiescent state */
(void)rte_rcu_qsbr_thread_register(g_qsv, 0);
rte_rcu_qsbr_thread_online(g_qsv, 0);
do {
for (i = 0; i < QSBR_REPORTING_INTERVAL; i++)
rte_hash_lookup(g_handle, &g_rand_keys[0]);
/* Update quiescent state */
rte_rcu_qsbr_quiescent(g_qsv, 0);
} while (!writer_done);
rte_rcu_qsbr_thread_offline(g_qsv, 0);
(void)rte_rcu_qsbr_thread_unregister(g_qsv, 0);
return 0;
}
/*
* rte_hash_rcu_qsbr_add sync mode functional test.
* 1 Reader and 1 writer. They cannot be in the same thread in this test.
* - Create hash which supports maximum 8 (9 if ext bkt is enabled) entries
* - Add RCU QSBR variable to hash
* - Register a reader thread. Reader keeps looking up a specific key.
* - Writer keeps adding and deleting a specific key.
*/
static int
test_hash_rcu_qsbr_sync_mode(uint8_t ext_bkt)
{
uint32_t total_entries = (ext_bkt == 0) ? 8 : 9;
uint8_t hash_extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF;
if (ext_bkt)
hash_extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE;
struct rte_hash_parameters params_pseudo_hash = {
.name = "test_hash_rcu_qsbr_sync_mode",
.entries = total_entries,
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
.key_len = sizeof(struct flow_key),
test/hash: add RCU tests Add functional and performance tests for the integrated RCU QSBR. Suggested-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2020-10-21 22:50:06 +00:00
.hash_func = pseudo_hash,
.hash_func_init_val = 0,
.socket_id = 0,
.extra_flag = hash_extra_flag,
};
int pos[total_entries];
int expected_pos[total_entries];
unsigned int i;
size_t sz;
int32_t status;
struct rte_hash_rcu_config rcu_cfg = {0};
g_qsv = NULL;
g_handle = NULL;
for (i = 0; i < total_entries; i++) {
g_rand_keys[i].port_dst = i;
g_rand_keys[i].port_src = i+1;
}
if (ext_bkt)
printf("\n# Running RCU QSBR sync mode functional test with"
" ext bkt\n");
else
printf("\n# Running RCU QSBR sync mode functional test\n");
g_handle = rte_hash_create(&params_pseudo_hash);
RETURN_IF_ERROR_RCU_QSBR(g_handle == NULL, "Hash creation failed");
/* Create RCU QSBR variable */
sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
g_qsv = (struct rte_rcu_qsbr *)rte_zmalloc_socket(NULL, sz,
RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
RETURN_IF_ERROR_RCU_QSBR(g_qsv == NULL,
"RCU QSBR variable creation failed");
status = rte_rcu_qsbr_init(g_qsv, RTE_MAX_LCORE);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"RCU QSBR variable initialization failed");
rcu_cfg.v = g_qsv;
rcu_cfg.mode = RTE_HASH_QSBR_MODE_SYNC;
/* Attach RCU QSBR to hash table */
status = rte_hash_rcu_qsbr_add(g_handle, &rcu_cfg);
RETURN_IF_ERROR_RCU_QSBR(status != 0,
"Attach RCU QSBR to hash table failed");
/* Launch reader thread */
rte_eal_remote_launch(test_hash_rcu_qsbr_reader, NULL,
rte_get_next_lcore(-1, 1, 0));
/* Fill bucket */
for (i = 0; i < total_entries; i++) {
pos[i] = rte_hash_add_key(g_handle, &g_rand_keys[i]);
print_key_info("Add", &g_rand_keys[i], pos[i]);
RETURN_IF_ERROR_RCU_QSBR(pos[i] < 0,
"failed to add key (pos[%u]=%d)", i, pos[i]);
expected_pos[i] = pos[i];
}
writer_done = 0;
/* Writer Update */
for (i = 0; i < WRITER_ITERATIONS; i++) {
expected_pos[0] = pos[0];
pos[0] = rte_hash_del_key(g_handle, &g_rand_keys[0]);
print_key_info("Del", &g_rand_keys[0], status);
RETURN_IF_ERROR_RCU_QSBR(pos[0] != expected_pos[0],
"failed to del correct key (pos[%u]=%d)"
, 0, pos[0]);
pos[0] = rte_hash_add_key(g_handle, &g_rand_keys[0]);
print_key_info("Add", &g_rand_keys[0], pos[0]);
RETURN_IF_ERROR_RCU_QSBR(pos[0] < 0,
"failed to add key (pos[%u]=%d)", 0,
pos[0]);
}
writer_done = 1;
/* Wait until reader exited. */
rte_eal_mp_wait_lcore();
rte_hash_free(g_handle);
rte_free(g_qsv);
return 0;
}
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
/*
* Do all unit and performance tests.
*/
app/test: convert all tests to register system Remove all tests from the builtin commands list and use the dynamic commands list register macro. Signed-off-by: David Marchand <david.marchand@6wind.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com> Acked-by: Neil Horman <nhorman@tuxdriver.com>
2014-08-18 11:29:23 +00:00
static int
test_hash(void)
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
{
test/hash: fix buffer overflow with jhash This patch fixes buffer overflow reported by ASAN, please reference https://bugs.dpdk.org/show_bug.cgi?id=818 Some tests for the rte_hash table use the rte_jhash_32b() as the hash function. This hash function interprets the length argument in units of 4 bytes. This patch adds a wrapper function around rte_jhash_32b() to reflect API differences regarding the length argument, effectively dividing it by 4. For some tests rte_jhash() is used with keys of length not a multiple of 4 bytes. From the rte_jhash() documentation: If input key is not aligned to four byte boundaries or a multiple of four bytes in length, the memory region just after may be read (but not used in the computation). This patch increases the size of the proto field of the flow_key struct up to uint32_t. Bugzilla ID: 818 Fixes: af75078fece3 ("first public release") Cc: stable@dpdk.org Signed-off-by: Vladimir Medvedkin <vladimir.medvedkin@intel.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2021-10-14 17:48:19 +00:00
RTE_BUILD_BUG_ON(sizeof(struct flow_key) % sizeof(uint32_t) != 0);
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
if (test_add_delete() < 0)
return -1;
if (test_hash_add_delete_jhash2() < 0)
return -1;
if (test_hash_add_delete_2_jhash2() < 0)
return -1;
if (test_hash_add_delete_jhash_1word() < 0)
return -1;
if (test_hash_add_delete_jhash_2word() < 0)
return -1;
if (test_hash_add_delete_jhash_3word() < 0)
return -1;
hash: retrieve a key given its position The function rte_hash_get_key_with_position is added in this patch. As the position returned when adding a key is frequently used as an offset into an array of user data, this function performs the operation of retrieving a key given this offset. A possible use case would be to delete a key from the hash table when its entry in the array of data has certain value. For instance, the key could be a flow 5-tuple, and the value stored in the array a time stamp. Signed-off-by: Juan Antonio Montesinos <juan.antonio.montesinos.delgado@ericsson.com> Signed-off-by: Yari Adan Petralanda <yari.adan.petralanda@ericsson.com> Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
2016-07-04 08:59:52 +00:00
if (test_hash_get_key_with_position() < 0)
return -1;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
if (test_hash_find_existing() < 0)
return -1;
if (test_add_update_delete() < 0)
return -1;
hash: support no free on delete rte_hash_lookup_xxx APIs return the index of slot in the key store. Application(reader) can use that index to reference other data structures in its scope. Because of this, the index should not be freed till the application completes using the index. RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL is introduced to support this. When this flag is enabled rte_hash_del_xxx APIs do not free the key-store index/internal memory associated with the deleted entry. The new API rte_hash_free_key_with_position should be called to free the key-store index/internal memory after calling rte_hash_del_xxx APIs. Suggested-by: Yipeng Wang <yipeng1.wang@intel.com> Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Reviewed-by: Gavin Hu <gavin.hu@arm.com> Reviewed-by: Yipeng Wang <yipeng1.wang@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-26 05:37:30 +00:00
if (test_add_update_delete_free() < 0)
return -1;
test/hash: check freeing key with position This patch adds a unit test for rte_hash_free_key_with_position(). Suggested-by: Linfan <zhongdahulinfan@163.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2019-05-09 17:19:07 +00:00
if (test_add_delete_free_lf() < 0)
return -1;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
if (test_five_keys() < 0)
return -1;
if (test_full_bucket() < 0)
return -1;
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (test_extendable_bucket() < 0)
return -1;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
if (test_fbk_hash_find_existing() < 0)
return -1;
if (fbk_hash_unit_test() < 0)
return -1;
if (test_hash_creation_with_bad_parameters() < 0)
return -1;
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
if (test_hash_creation_with_good_parameters() < 0)
return -1;
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
/* ext table disabled */
if (test_average_table_utilization(0) < 0)
return -1;
if (test_hash_iteration(0) < 0)
return -1;
/* ext table enabled */
if (test_average_table_utilization(1) < 0)
app/test: improve hash unit tests Add new unit test for calculating the average table utilization, using random keys, based on number of entries that can be added until we encounter one that cannot be added (bucket if full). Also, replace current hash_perf unit test to see performance more clearly. The current hash_perf unit test takes too long and add keys that may or may not fit in the table and look up/delete that may not be in the table. This new unit test gets a set of keys that we know that fits in the table, and then measure the time to add/look up/delete them. Note that performance numbers include time to take a random key from a pre-made array of keys, plus a quick check of return value. Also, as stated above, expect higher numbers, as all operations in the new unit tests will be successful, which means that it will take more time, than mixing both successful and unsuccesful operations. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-09 16:54:30 +00:00
return -1;
test/hash: add extendable bucket This commit changes the current rte_hash unit test to test the extendable table feature and performance. Signed-off-by: Yipeng Wang <yipeng1.wang@intel.com> Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Acked-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2018-10-22 18:39:47 +00:00
if (test_hash_iteration(1) < 0)
hash: add iterate function Since now rte_hash structure is private, a new function has been added to let the user iterate through the hash table, returning next key and data associated on each iteration, plus the position where they were stored. Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-07-11 00:18:53 +00:00
return -1;
app: split performance tests Signed-off-by: Intel
2012-12-19 23:00:00 +00:00
run_hash_func_tests();
app/test: add crc32 algorithms equivalence check New function test_crc32_hash_alg_equiv() checks whether software, 4-byte operand and 8-byte operand versions of CRC32 hash function implementations return the same result value. Signed-off-by: Yerden Zhumabekov <e_zhumabekov@sts.kz> Acked-by: Bruce Richardson <bruce.richardson@intel.com>
2015-02-25 12:34:06 +00:00
if (test_crc32_hash_alg_equiv() < 0)
return -1;
test/hash: add RCU tests Add functional and performance tests for the integrated RCU QSBR. Suggested-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com> Signed-off-by: Dharmik Thakkar <dharmik.thakkar@arm.com> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com> Acked-by: Yipeng Wang <yipeng1.wang@intel.com>
2020-10-21 22:50:06 +00:00
if (test_hash_rcu_qsbr_add() < 0)
return -1;
if (test_hash_rcu_qsbr_dq_mode(0) < 0)
return -1;
if (test_hash_rcu_qsbr_dq_mode(1) < 0)
return -1;
if (test_hash_rcu_qsbr_sync_mode(0) < 0)
return -1;
if (test_hash_rcu_qsbr_sync_mode(1) < 0)
return -1;
first public release version 1.2.3 Signed-off-by: Intel
2012-09-04 12:54:00 +00:00
return 0;
}
app/test: rework command registration The tests are registered with their command name by adding a structure to a list. The structure of each test was declared in each test file and passed to the register macro. This rework generate the structure inside the register macro. Signed-off-by: Thomas Monjalon <thomas.monjalon@6wind.com> Reviewed-by: Jan Viktorin <viktorin@rehivetech.com>
2016-07-13 12:38:13 +00:00
REGISTER_TEST_COMMAND(hash_autotest, test_hash);
Reference in New Issue Copy Permalink