From 8d01b9cd70a67cdafd5b965a70420c3bd7fb3f82 Mon Sep 17 00:00:00 2001 From: Luca Boccassi Date: Thu, 1 Nov 2018 11:59:50 +0000 Subject: New upstream version 18.11-rc1 Change-Id: Iaa71986dd6332e878d8f4bf493101b2bbc6313bb Signed-off-by: Luca Boccassi --- test/test-pipeline/init.c | 2 +- test/test/Makefile | 8 +- test/test/autotest_data.py | 40 +- test/test/meson.build | 24 +- test/test/test.c | 33 +- test/test/test_acl.h | 18 +- test/test/test_alarm.c | 5 +- test/test/test_bitmap.c | 18 + test/test/test_cryptodev.c | 714 +++++++++++++-- test/test/test_cryptodev.h | 2 + test/test/test_cryptodev_aes_test_vectors.h | 147 +++- test/test/test_cryptodev_blockcipher.c | 16 +- test/test/test_cryptodev_blockcipher.h | 2 + test/test/test_cryptodev_des_test_vectors.h | 26 +- test/test/test_cryptodev_hash_test_vectors.h | 104 ++- test/test/test_cycles.c | 51 +- test/test/test_event_eth_rx_adapter.c | 70 +- test/test/test_event_eth_tx_adapter.c | 699 +++++++++++++++ test/test/test_event_timer_adapter.c | 2 +- test/test/test_eventdev.c | 21 +- test/test/test_external_mem.c | 390 ++++++++ test/test/test_hash.c | 299 ++++++- test/test/test_hash_multiwriter.c | 3 +- test/test/test_hash_perf.c | 127 ++- test/test/test_hash_readwrite.c | 156 +++- test/test/test_hash_readwrite_lf.c | 1220 ++++++++++++++++++++++++++ test/test/test_hash_scaling.c | 191 ---- test/test/test_kni.c | 135 ++- test/test/test_kvargs.c | 21 + test/test/test_link_bonding_mode4.c | 1 - test/test/test_malloc.c | 3 + test/test/test_memzone.c | 3 + test/test/test_metrics.c | 313 +++++++ test/test/test_pmd_perf.c | 1 - test/test/test_pmd_ring.c | 326 ++++--- test/test/test_timer_racecond.c | 2 +- test/test/virtual_pmd.c | 1 - 37 files changed, 4521 insertions(+), 673 deletions(-) create mode 100644 test/test/test_event_eth_tx_adapter.c create mode 100644 test/test/test_external_mem.c create mode 100644 test/test/test_hash_readwrite_lf.c delete mode 100644 test/test/test_hash_scaling.c create mode 100644 test/test/test_metrics.c (limited to 'test') diff --git a/test/test-pipeline/init.c b/test/test-pipeline/init.c index f33216c9..b75688a8 100644 --- a/test/test-pipeline/init.c +++ b/test/test-pipeline/init.c @@ -70,7 +70,7 @@ struct app_params app = { static struct rte_eth_conf port_conf = { .rxmode = { .split_hdr_size = 0, - .offloads = DEV_RX_OFFLOAD_CHECKSUM | DEV_RX_OFFLOAD_CRC_STRIP, + .offloads = DEV_RX_OFFLOAD_CHECKSUM, }, .rx_adv_conf = { .rss_conf = { diff --git a/test/test/Makefile b/test/test/Makefile index e6967bab..ab4fec34 100644 --- a/test/test/Makefile +++ b/test/test/Makefile @@ -71,6 +71,7 @@ SRCS-y += test_bitmap.c SRCS-y += test_reciprocal_division.c SRCS-y += test_reciprocal_division_perf.c SRCS-y += test_fbarray.c +SRCS-y += test_external_mem.c SRCS-y += test_ring.c SRCS-y += test_ring_perf.c @@ -112,9 +113,9 @@ SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash.c SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_thash.c SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_perf.c SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_functions.c -SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_scaling.c SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_multiwriter.c SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_readwrite.c +SRCS-$(CONFIG_RTE_LIBRTE_HASH) += test_hash_readwrite_lf.c SRCS-$(CONFIG_RTE_LIBRTE_LPM) += test_lpm.c SRCS-$(CONFIG_RTE_LIBRTE_LPM) += test_lpm_perf.c @@ -183,6 +184,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev_blockcipher.c SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev.c SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev_asym.c +SRCS-$(CONFIG_RTE_LIBRTE_METRICS) += test_metrics.c + ifeq ($(CONFIG_RTE_COMPRESSDEV_TEST),y) SRCS-$(CONFIG_RTE_LIBRTE_COMPRESSDEV) += test_compressdev.c endif @@ -191,6 +194,7 @@ ifeq ($(CONFIG_RTE_LIBRTE_EVENTDEV),y) SRCS-y += test_eventdev.c SRCS-y += test_event_ring.c SRCS-y += test_event_eth_rx_adapter.c +SRCS-y += test_event_eth_tx_adapter.c SRCS-y += test_event_timer_adapter.c SRCS-y += test_event_crypto_adapter.c endif @@ -208,8 +212,6 @@ CFLAGS += -DALLOW_EXPERIMENTAL_API CFLAGS += -O3 CFLAGS += $(WERROR_FLAGS) -CFLAGS += -D_GNU_SOURCE - LDLIBS += -lm ifeq ($(CONFIG_RTE_COMPRESSDEV_TEST),y) ifeq ($(CONFIG_RTE_LIBRTE_COMPRESSDEV),y) diff --git a/test/test/autotest_data.py b/test/test/autotest_data.py index f68d9b11..0fb7866d 100644 --- a/test/test/autotest_data.py +++ b/test/test/autotest_data.py @@ -278,6 +278,12 @@ parallel_test_list = [ "Func": default_autotest, "Report": None, }, + { + "Name": "Sleep delay", + "Command": "delay_us_sleep_autotest", + "Func": default_autotest, + "Report": None, + }, { "Name": "Rawdev autotest", "Command": "rawdev_autotest", @@ -344,12 +350,6 @@ parallel_test_list = [ "Func": default_autotest, "Report": None, }, - { - "Name": "Hash scaling autotest", - "Command": "hash_scaling_autotest", - "Func": default_autotest, - "Report": None, - }, { "Name": "Hash multiwriter autotest", "Command": "hash_multiwriter_autotest", @@ -477,8 +477,20 @@ parallel_test_list = [ "Report": None, }, { - "Name": "Fbarray autotest", - "Command": "fbarray_autotest", + "Name": "Fbarray autotest", + "Command": "fbarray_autotest", + "Func": default_autotest, + "Report": None, + }, + { + "Name": "External memory autotest", + "Command": "external_mem_autotest", + "Func": default_autotest, + "Report": None, + }, + { + "Name": "Metrics autotest", + "Command": "metrics_autotest", "Func": default_autotest, "Report": None, }, @@ -573,6 +585,18 @@ non_parallel_test_list = [ "Func": default_autotest, "Report": None, }, + { + "Name": "Hash read-write concurrency autotest", + "Command": "hash_readwrite_autotest", + "Func": default_autotest, + "Report": None, + }, + { + "Name": "Hash read-write lock-free concurrency autotest", + "Command": "hash_readwrite_lf_autotest", + "Func": default_autotest, + "Report": None, + }, { "Name": "Power autotest", "Command": "power_autotest", diff --git a/test/test/meson.build b/test/test/meson.build index b1dd6eca..554e9945 100644 --- a/test/test/meson.build +++ b/test/test/meson.build @@ -33,15 +33,20 @@ test_sources = files('commands.c', 'test_efd.c', 'test_efd_perf.c', 'test_errno.c', + 'test_event_crypto_adapter.c', + 'test_event_eth_rx_adapter.c', 'test_event_ring.c', + 'test_event_eth_tx_adapter.c', + 'test_event_timer_adapter.c', 'test_eventdev.c', 'test_func_reentrancy.c', 'test_flow_classify.c', 'test_hash.c', 'test_hash_functions.c', 'test_hash_multiwriter.c', + 'test_hash_readwrite.c', 'test_hash_perf.c', - 'test_hash_scaling.c', + 'test_hash_readwrite_lf.c', 'test_interrupts.c', 'test_kni.c', 'test_kvargs.c', @@ -63,6 +68,7 @@ test_sources = files('commands.c', 'test_mempool_perf.c', 'test_memzone.c', 'test_meter.c', + 'test_metrics.c', 'test_mp_secondary.c', 'test_per_lcore.c', 'test_pmd_perf.c', @@ -111,6 +117,7 @@ test_deps = ['acl', 'hash', 'lpm', 'member', + 'metrics', 'pipeline', 'port', 'reorder', @@ -141,8 +148,10 @@ test_names = [ 'cryptodev_sw_mvsam_autotest', 'cryptodev_dpaa2_sec_autotest', 'cryptodev_dpaa_sec_autotest', + 'cryptodev_octeontx_autotest', 'cycles_autotest', 'debug_autotest', + 'delay_us_sleep_autotest', 'devargs_autotest', 'distributor_autotest', 'distributor_perf_autotest', @@ -151,17 +160,24 @@ test_names = [ 'efd_autotest', 'efd_perf_autotest', 'errno_autotest', + 'event_crypto_adapter_autotest', + 'event_eth_rx_adapter_autotest', + 'event_eth_rx_intr_adapter_autotest', 'event_ring_autotest', + 'event_eth_tx_adapter_autotest', + 'event_timer_adapter_autotest', 'eventdev_common_autotest', 'eventdev_octeontx_autotest', 'eventdev_sw_autotest', + 'external_mem_autotest', 'func_reentrancy_autotest', 'flow_classify_autotest', - 'hash_scaling_autotest', 'hash_autotest', 'hash_functions_autotest', 'hash_multiwriter_autotest', 'hash_perf_autotest', + 'hash_readwrite_autotest', + 'hash_readwrite_lf_autotest', 'interrupt_autotest', 'kni_autotest', 'kvargs_autotest', @@ -183,6 +199,7 @@ test_names = [ 'mempool_perf_autotest', 'memzone_autotest', 'meter_autotest', + 'metrics_autotest', 'multiprocess_autotest', 'per_lcore_autotest', 'pmd_perf_autotest', @@ -242,6 +259,9 @@ if cc.has_argument('-Wno-format-truncation') cflags += '-Wno-format-truncation' endif +# specify -D_GNU_SOURCE unconditionally +default_cflags += '-D_GNU_SOURCE' + test_dep_objs = [] compress_test_dep = dependency('zlib', required: false) if compress_test_dep.found() diff --git a/test/test/test.c b/test/test/test.c index 44dfe20e..ffa9c366 100644 --- a/test/test/test.c +++ b/test/test/test.c @@ -84,22 +84,29 @@ main(int argc, char **argv) int ret; ret = rte_eal_init(argc, argv); - if (ret < 0) - return -1; + if (ret < 0) { + ret = -1; + goto out; + } #ifdef RTE_LIBRTE_TIMER rte_timer_subsystem_init(); #endif - if (commands_init() < 0) - return -1; + if (commands_init() < 0) { + ret = -1; + goto out; + } argv += ret; prgname = argv[0]; - if ((recursive_call = getenv(RECURSIVE_ENV_VAR)) != NULL) - return do_recursive_call(); + recursive_call = getenv(RECURSIVE_ENV_VAR); + if (recursive_call != NULL) { + ret = do_recursive_call(); + goto out; + } #ifdef RTE_LIBEAL_USE_HPET if (rte_eal_hpet_init(1) < 0) @@ -111,7 +118,8 @@ main(int argc, char **argv) #ifdef RTE_LIBRTE_CMDLINE cl = cmdline_stdin_new(main_ctx, "RTE>>"); if (cl == NULL) { - return -1; + ret = -1; + goto out; } char *dpdk_test = getenv("DPDK_TEST"); @@ -120,18 +128,23 @@ main(int argc, char **argv) snprintf(buf, sizeof(buf), "%s\n", dpdk_test); if (cmdline_in(cl, buf, strlen(buf)) < 0) { printf("error on cmdline input\n"); - return -1; + ret = -1; + goto out; } cmdline_stdin_exit(cl); - return last_test_result; + ret = last_test_result; + goto out; } /* if no DPDK_TEST env variable, go interactive */ cmdline_interact(cl); cmdline_stdin_exit(cl); #endif + ret = 0; - return 0; +out: + rte_eal_cleanup(); + return ret; } diff --git a/test/test/test_acl.h b/test/test/test_acl.h index c4811c8f..bbb0447a 100644 --- a/test/test/test_acl.h +++ b/test/test/test_acl.h @@ -80,34 +80,40 @@ enum { struct rte_acl_ipv4vlan_rule invalid_layout_rules[] = { /* test src and dst address */ { - .data = {.userdata = 1, .category_mask = 1}, + .data = {.userdata = 1, .category_mask = 1, + .priority = 1}, .src_addr = IPv4(10,0,0,0), .src_mask_len = 24, }, { - .data = {.userdata = 2, .category_mask = 1}, + .data = {.userdata = 2, .category_mask = 1, + .priority = 1}, .dst_addr = IPv4(10,0,0,0), .dst_mask_len = 24, }, /* test src and dst ports */ { - .data = {.userdata = 3, .category_mask = 1}, + .data = {.userdata = 3, .category_mask = 1, + .priority = 1}, .dst_port_low = 100, .dst_port_high = 100, }, { - .data = {.userdata = 4, .category_mask = 1}, + .data = {.userdata = 4, .category_mask = 1, + .priority = 1}, .src_port_low = 100, .src_port_high = 100, }, /* test proto */ { - .data = {.userdata = 5, .category_mask = 1}, + .data = {.userdata = 5, .category_mask = 1, + .priority = 1}, .proto = 0xf, .proto_mask = 0xf }, { - .data = {.userdata = 6, .category_mask = 1}, + .data = {.userdata = 6, .category_mask = 1, + .priority = 1}, .dst_port_low = 0xf, .dst_port_high = 0xf, } diff --git a/test/test/test_alarm.c b/test/test/test_alarm.c index f566947f..d1284b37 100644 --- a/test/test/test_alarm.c +++ b/test/test/test_alarm.c @@ -178,7 +178,10 @@ static int test_alarm(void) { int count = 0; - +#ifdef RTE_EXEC_ENV_BSDAPP + printf("The alarm API is not supported on FreeBSD\n"); + return 0; +#endif /* check if the callback will be called */ printf("check if the callback will be called\n"); flag = 0; diff --git a/test/test/test_bitmap.c b/test/test/test_bitmap.c index c3169e9d..95c51848 100644 --- a/test/test/test_bitmap.c +++ b/test/test/test_bitmap.c @@ -101,6 +101,7 @@ test_bitmap_slab_set_get(struct rte_bitmap *bmp) static int test_bitmap_set_get_clear(struct rte_bitmap *bmp) { + uint64_t val; int i; rte_bitmap_reset(bmp); @@ -124,6 +125,23 @@ test_bitmap_set_get_clear(struct rte_bitmap *bmp) } } + rte_bitmap_reset(bmp); + + /* Alternate slab set test */ + for (i = 0; i < MAX_BITS; i++) { + if (i % RTE_BITMAP_SLAB_BIT_SIZE) + rte_bitmap_set(bmp, i); + } + + for (i = 0; i < MAX_BITS; i++) { + val = rte_bitmap_get(bmp, i); + if (((i % RTE_BITMAP_SLAB_BIT_SIZE) && !val) || + (!(i % RTE_BITMAP_SLAB_BIT_SIZE) && val)) { + printf("Failed to get set bit.\n"); + return TEST_FAILED; + } + } + return TEST_SUCCESS; } diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c index a6044b26..84065eb4 100644 --- a/test/test/test_cryptodev.c +++ b/test/test/test_cryptodev.c @@ -635,7 +635,7 @@ test_device_configure_invalid_queue_pair_ids(void) /* valid - max value queue pairs */ - ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE; + ts_params->conf.nb_queue_pairs = orig_nb_qps; TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], &ts_params->conf), @@ -667,7 +667,7 @@ test_device_configure_invalid_queue_pair_ids(void) /* invalid - max value + 1 queue pairs */ - ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1; + ts_params->conf.nb_queue_pairs = orig_nb_qps + 1; TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], &ts_params->conf), @@ -819,7 +819,7 @@ test_queue_pair_descriptor_setup(void) /* test invalid queue pair id */ qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */ - qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */ + qp_id = ts_params->conf.nb_queue_pairs; /*invalid */ TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( ts_params->valid_devs[0], @@ -1876,6 +1876,64 @@ test_AES_cipheronly_virtio_all(void) return TEST_SUCCESS; } +static int +test_AES_chain_caam_jr_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), + BLKCIPHER_AES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_cipheronly_caam_jr_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), + BLKCIPHER_AES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_authonly_caam_jr_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), + BLKCIPHER_AUTHONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + + static int test_AES_chain_dpaa_sec_all(void) { @@ -2142,6 +2200,96 @@ test_3DES_cipheronly_mrvl_all(void) return TEST_SUCCESS; } +static int +test_AES_chain_octeontx_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), + BLKCIPHER_AES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_AES_cipheronly_octeontx_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), + BLKCIPHER_AES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_chain_octeontx_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), + BLKCIPHER_3DES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_cipheronly_octeontx_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), + BLKCIPHER_3DES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_authonly_octeontx_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)), + BLKCIPHER_AUTHONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + /* ***** SNOW 3G Tests ***** */ static int create_wireless_algo_hash_session(uint8_t dev_id, @@ -5058,6 +5206,44 @@ test_DES_docsis_mb_all(void) return TEST_SUCCESS; } +static int +test_3DES_chain_caam_jr_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), + BLKCIPHER_3DES_CHAIN_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + +static int +test_3DES_cipheronly_caam_jr_all(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + int status; + + status = test_blockcipher_all_tests(ts_params->mbuf_pool, + ts_params->op_mpool, + ts_params->session_mpool, + ts_params->valid_devs[0], + rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)), + BLKCIPHER_3DES_CIPHERONLY_TYPE); + + TEST_ASSERT_EQUAL(status, 0, "Test failed"); + + return TEST_SUCCESS; +} + static int test_3DES_chain_dpaa_sec_all(void) { @@ -9042,57 +9228,6 @@ static struct unit_test_suite cryptodev_aesni_mb_testsuite = { .setup = testsuite_setup, .teardown = testsuite_teardown, .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_cipheronly_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_mb_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_2), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_3), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_decryption_test_case_128_3), - - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; - -static struct unit_test_suite cryptodev_openssl_testsuite = { - .suite_name = "Crypto Device OPENSSL Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), - TEST_CASE_ST(ut_setup, ut_teardown, - test_multi_session_random_usage), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_chain_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_cipheronly_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_chain_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_3DES_cipheronly_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_cipheronly_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_DES_docsis_openssl_all), - TEST_CASE_ST(ut_setup, ut_teardown, - test_authonly_openssl_all), - - /** AES GCM Authenticated Encryption */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_encryption_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, @@ -9124,7 +9259,6 @@ static struct unit_test_suite cryptodev_openssl_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_authenticated_decryption_test_case_7), - /** AES GCM Authenticated Encryption 192 bits key */ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_encryption_test_case_192_1), @@ -9189,33 +9323,199 @@ static struct unit_test_suite cryptodev_openssl_testsuite = { TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GCM_auth_decryption_test_case_256_7), - /** AES GMAC Authentication */ - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_1), - TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_1), + /** AES GCM Authenticated Encryption big aad size */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_2), + test_AES_GCM_auth_encryption_test_case_aad_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_2), + test_AES_GCM_auth_encryption_test_case_aad_2), + + /** AES GCM Authenticated Decryption big aad size */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_3), + test_AES_GCM_auth_decryption_test_case_aad_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_3), + test_AES_GCM_auth_decryption_test_case_aad_2), + + /** Session-less tests */ TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_test_case_4), + test_AES_GCM_authenticated_encryption_sessionless_test_case_1), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_GMAC_authentication_verify_test_case_4), + test_AES_GCM_authenticated_decryption_sessionless_test_case_1), - /** AES CCM Authenticated Encryption 128 bits key */ + + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all), + TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_1), + test_DES_cipheronly_mb_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_2), + test_DES_docsis_mb_all), TEST_CASE_ST(ut_setup, ut_teardown, - test_AES_CCM_authenticated_encryption_test_case_128_3), - - /** AES CCM Authenticated Decryption 128 bits key*/ + test_3DES_cipheronly_mb_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_128_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_128_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_decryption_test_case_128_3), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static struct unit_test_suite cryptodev_openssl_testsuite = { + .suite_name = "Crypto Device OPENSSL Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), + TEST_CASE_ST(ut_setup, ut_teardown, + test_multi_session_random_usage), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_chain_openssl_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_cipheronly_openssl_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_3DES_chain_openssl_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_3DES_cipheronly_openssl_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_DES_cipheronly_openssl_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_DES_docsis_openssl_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_authonly_openssl_all), + + /** AES GCM Authenticated Encryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_7), + + /** AES GCM Authenticated Decryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_7), + + + /** AES GCM Authenticated Encryption 192 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_192_7), + + /** AES GCM Authenticated Decryption 192 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_192_7), + + /** AES GCM Authenticated Encryption 256 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_encryption_test_case_256_7), + + /** AES GCM Authenticated Decryption 256 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_auth_decryption_test_case_256_7), + + /** AES GMAC Authentication */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_4), + + /** AES CCM Authenticated Encryption 128 bits key */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_CCM_authenticated_encryption_test_case_128_3), + + /** AES CCM Authenticated Decryption 128 bits key*/ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_CCM_authenticated_decryption_test_case_128_1), TEST_CASE_ST(ut_setup, ut_teardown, @@ -9604,6 +9904,31 @@ static struct unit_test_suite cryptodev_sw_zuc_testsuite = { } }; +static struct unit_test_suite cryptodev_caam_jr_testsuite = { + .suite_name = "Crypto CAAM JR Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, + test_device_configure_invalid_dev_id), + TEST_CASE_ST(ut_setup, ut_teardown, + test_multi_session), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_chain_caam_jr_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_3DES_chain_caam_jr_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_cipheronly_caam_jr_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_3DES_cipheronly_caam_jr_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_authonly_caam_jr_all), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + static struct unit_test_suite cryptodev_dpaa_sec_testsuite = { .suite_name = "Crypto DPAA_SEC Unit Test Suite", .setup = testsuite_setup, @@ -9951,6 +10276,218 @@ static struct unit_test_suite cryptodev_ccp_testsuite = { } }; +static struct unit_test_suite cryptodev_octeontx_testsuite = { + .suite_name = "Crypto Device OCTEONTX Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_chain_octeontx_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_cipheronly_octeontx_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_3DES_chain_octeontx_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_3DES_cipheronly_octeontx_all), + TEST_CASE_ST(ut_setup, ut_teardown, + test_authonly_octeontx_all), + + /** AES GCM Authenticated Encryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_encryption_test_case_7), + + /** AES GCM Authenticated Decryption */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GCM_authenticated_decryption_test_case_7), + /** AES GMAC Authentication */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_verify_test_case_3), + + /** SNOW 3G encrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_5), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_encryption_test_case_1_oop_sgl), + + /** SNOW 3G decrypt only (UEA2) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_decryption_test_case_5), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_generate_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_snow3g_hash_verify_test_case_3), + + /** ZUC encrypt only (EEA3) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_6_sgl), + + /** KASUMI encrypt only (UEA1) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_oop_sgl), + /** KASUMI decrypt only (UEA1) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_5), + + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_encryption_test_case_1_oop), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_decryption_test_case_1_oop), + + /** KASUMI hash only (UIA1) */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_generate_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_generate_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_generate_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_generate_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_generate_test_case_5), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_generate_test_case_6), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_1), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_2), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_3), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_4), + TEST_CASE_ST(ut_setup, ut_teardown, + test_kasumi_hash_verify_test_case_5), + + /** NULL tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_cipher_only_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_auth_only_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_cipher_auth_operation), + TEST_CASE_ST(ut_setup, ut_teardown, + test_null_auth_cipher_operation), + + /** Negative tests */ + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_HMAC_SHA1_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_AES128_GMAC_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + authentication_verify_AES128_GMAC_fail_tag_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), + TEST_CASE_ST(ut_setup, ut_teardown, + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + static int test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) { @@ -10203,6 +10740,37 @@ test_cryptodev_ccp(void) return unit_test_suite_runner(&cryptodev_ccp_testsuite); } +static int +test_cryptodev_octeontx(void) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)); + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is " + "enabled in config file to run this " + "testsuite.\n"); + return TEST_FAILED; + } + return unit_test_suite_runner(&cryptodev_octeontx_testsuite); +} + +static int +test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/) +{ + gbl_driver_id = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)); + + if (gbl_driver_id == -1) { + RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if " + "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled " + "in config file to run this testsuite.\n"); + return TEST_FAILED; + } + + return unit_test_suite_runner(&cryptodev_caam_jr_testsuite); +} + REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); @@ -10217,3 +10785,5 @@ REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec); REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec); REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp); REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio); +REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx); +REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr); diff --git a/test/test/test_cryptodev.h b/test/test/test_cryptodev.h index 1bd44dcd..a73a49e7 100644 --- a/test/test/test_cryptodev.h +++ b/test/test/test_cryptodev.h @@ -64,6 +64,8 @@ #define CRYPTODEV_NAME_MVSAM_PMD crypto_mvsam #define CRYPTODEV_NAME_CCP_PMD crypto_ccp #define CRYPTODEV_NAME_VIRTIO_PMD crypto_virtio +#define CRYPTODEV_NAME_OCTEONTX_SYM_PMD crypto_octeontx +#define CRYPTODEV_NAME_CAAM_JR_PMD crypto_caam_jr /** * Write (spread) data from buffer to mbuf data diff --git a/test/test/test_cryptodev_aes_test_vectors.h b/test/test/test_cryptodev_aes_test_vectors.h index 1c4dc664..fff28bc9 100644 --- a/test/test/test_cryptodev_aes_test_vectors.h +++ b/test/test/test_cryptodev_aes_test_vectors.h @@ -1171,6 +1171,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, @@ -1185,6 +1186,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, @@ -1225,6 +1227,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, @@ -1239,6 +1242,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, @@ -1253,8 +1257,10 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest " @@ -1262,7 +1268,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .test_data = &aes_test_data_13, .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA1 Encryption Digest " @@ -1276,7 +1283,9 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest " @@ -1290,8 +1299,10 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest " @@ -1300,7 +1311,9 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC, .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest " @@ -1308,7 +1321,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .test_data = &aes_test_data_13, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA256 Encryption Digest", @@ -1321,8 +1335,10 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA256 Encryption Digest " @@ -1330,7 +1346,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .test_data = &aes_test_data_12, .op_mask = BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA256 Decryption Digest " @@ -1345,7 +1362,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA256 Decryption Digest " @@ -1353,7 +1371,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .test_data = &aes_test_data_12, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA512 Encryption Digest", @@ -1365,8 +1384,10 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA512 Encryption Digest " @@ -1376,7 +1397,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA512 Encryption Digest " @@ -1387,7 +1409,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_FEATURE_SG | BLOCKCIPHER_TEST_FEATURE_OOP, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | - BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL + BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA512 Decryption Digest " @@ -1400,8 +1423,10 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA512 Decryption Digest " @@ -1415,7 +1440,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER + BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC XCBC Encryption Digest", @@ -1443,7 +1469,9 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA1 Decryption Digest " @@ -1455,7 +1483,9 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA224 Encryption Digest", @@ -1467,7 +1497,9 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA224 Decryption Digest " @@ -1480,7 +1512,9 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC HMAC-SHA384 Encryption Digest", @@ -1492,6 +1526,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, @@ -1506,6 +1541,7 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, @@ -1517,7 +1553,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 | BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = @@ -1528,7 +1565,8 @@ static const struct blockcipher_test_case aes_chain_test_cases[] = { .feature_mask = BLOCKCIPHER_TEST_FEATURE_SESSIONLESS, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8 | BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, }; @@ -1543,9 +1581,11 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO + BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CBC Decryption", @@ -1557,9 +1597,11 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO + BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CBC Encryption", @@ -1571,8 +1613,10 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO + BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CBC Encryption Scater gather", @@ -1582,7 +1626,9 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_FEATURE_OOP, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CBC Decryption", @@ -1594,8 +1640,10 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO + BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CBC Decryption Scatter Gather", @@ -1603,7 +1651,9 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_DECRYPT, .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-256-CBC Encryption", @@ -1615,9 +1665,11 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO + BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-256-CBC Decryption", @@ -1629,9 +1681,11 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO + BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-256-CBC OOP Encryption", @@ -1642,6 +1696,7 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO }, @@ -1654,6 +1709,7 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO }, @@ -1667,8 +1723,10 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CTR Decryption", @@ -1680,8 +1738,10 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CTR Encryption", @@ -1693,7 +1753,9 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CTR Decryption", @@ -1705,7 +1767,9 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-256-CTR Encryption", @@ -1717,8 +1781,10 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-256-CTR Decryption", @@ -1730,26 +1796,31 @@ static const struct blockcipher_test_case aes_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-128-CTR Encryption (12-byte IV)", .test_data = &aes_test_data_1_IV_12_bytes, .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-192-CTR Encryption (12-byte IV)", .test_data = &aes_test_data_2_IV_12_bytes, .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "AES-256-CTR Encryption (12-byte IV)", .test_data = &aes_test_data_3_IV_12_bytes, .op_mask = BLOCKCIPHER_TEST_OP_ENCRYPT, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX } }; diff --git a/test/test/test_cryptodev_blockcipher.c b/test/test/test_cryptodev_blockcipher.c index f2701f8f..1c3f29f6 100644 --- a/test/test/test_cryptodev_blockcipher.c +++ b/test/test/test_cryptodev_blockcipher.c @@ -68,10 +68,14 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t, RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)); int dpaa_sec_pmd = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)); + int caam_jr_pmd = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)); int mrvl_pmd = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)); int virtio_pmd = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)); + int octeontx_pmd = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)); int nb_segs = 1; @@ -109,12 +113,14 @@ test_blockcipher_one_case(const struct blockcipher_test_case *t, if (driver_id == dpaa2_sec_pmd || driver_id == dpaa_sec_pmd || + driver_id == caam_jr_pmd || driver_id == qat_pmd || driver_id == openssl_pmd || driver_id == armv8_pmd || driver_id == mrvl_pmd || driver_id == ccp_pmd || - driver_id == virtio_pmd) { /* Fall through */ + driver_id == virtio_pmd || + driver_id == octeontx_pmd) { /* Fall through */ digest_len = tdata->digest.len; } else if (driver_id == aesni_mb_pmd || driver_id == scheduler_pmd) { @@ -628,6 +634,8 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool, RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)); int dpaa_sec_pmd = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)); + int caam_jr_pmd = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)); int scheduler_pmd = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)); int armv8_pmd = rte_cryptodev_driver_id_get( @@ -640,6 +648,8 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool, RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)); int virtio_pmd = rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)); + int octeontx_pmd = rte_cryptodev_driver_id_get( + RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)); switch (test_type) { case BLKCIPHER_AES_CHAIN_TYPE: @@ -702,10 +712,14 @@ test_blockcipher_all_tests(struct rte_mempool *mbuf_pool, target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_CCP; else if (driver_id == dpaa_sec_pmd) target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC; + else if (driver_id == caam_jr_pmd) + target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR; else if (driver_id == mrvl_pmd) target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MVSAM; else if (driver_id == virtio_pmd) target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO; + else if (driver_id == octeontx_pmd) + target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX; else TEST_ASSERT(0, "Unrecognized cryptodev type"); diff --git a/test/test/test_cryptodev_blockcipher.h b/test/test/test_cryptodev_blockcipher.h index 6f7c8929..f8bd8583 100644 --- a/test/test/test_cryptodev_blockcipher.h +++ b/test/test/test_cryptodev_blockcipher.h @@ -29,6 +29,8 @@ #define BLOCKCIPHER_TEST_TARGET_PMD_MVSAM 0x0080 /* Marvell flag */ #define BLOCKCIPHER_TEST_TARGET_PMD_CCP 0x0040 /* CCP flag */ #define BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO 0x0200 /* VIRTIO flag */ +#define BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX 0x0100 /* OCTEON TX flag */ +#define BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR 0x0400 /* CAAM_JR flag */ #define BLOCKCIPHER_TEST_OP_CIPHER (BLOCKCIPHER_TEST_OP_ENCRYPT | \ BLOCKCIPHER_TEST_OP_DECRYPT) diff --git a/test/test/test_cryptodev_des_test_vectors.h b/test/test/test_cryptodev_des_test_vectors.h index 10334560..f1b8cbd4 100644 --- a/test/test/test_cryptodev_des_test_vectors.h +++ b/test/test/test_cryptodev_des_test_vectors.h @@ -1069,6 +1069,7 @@ static const struct blockcipher_test_case triple_des_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, { @@ -1079,6 +1080,7 @@ static const struct blockcipher_test_case triple_des_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP }, { @@ -1103,8 +1105,10 @@ static const struct blockcipher_test_case triple_des_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "3DES-192-CBC HMAC-SHA1 Decryption Digest Verify", @@ -1114,8 +1118,10 @@ static const struct blockcipher_test_case triple_des_chain_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | - BLOCKCIPHER_TEST_TARGET_PMD_CCP + BLOCKCIPHER_TEST_TARGET_PMD_CCP | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "3DES-192-CBC SHA1 Encryption Digest", @@ -1193,7 +1199,8 @@ static const struct blockcipher_test_case triple_des_chain_test_cases[] = { .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR }, { .test_descr = "3DES-128-CBC HMAC-SHA1 Decryption Digest" @@ -1204,7 +1211,8 @@ static const struct blockcipher_test_case triple_des_chain_test_cases[] = { .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR }, { .test_descr = "3DES-128-CBC HMAC-SHA1 Encryption Digest" @@ -1252,6 +1260,7 @@ static const struct blockcipher_test_case triple_des_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | BLOCKCIPHER_TEST_TARGET_PMD_MB }, @@ -1263,6 +1272,7 @@ static const struct blockcipher_test_case triple_des_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | BLOCKCIPHER_TEST_TARGET_PMD_MB }, @@ -1274,9 +1284,11 @@ static const struct blockcipher_test_case triple_des_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MB + BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "3DES-192-CBC Decryption", @@ -1286,9 +1298,11 @@ static const struct blockcipher_test_case triple_des_cipheronly_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MB + BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "3DES-128-CTR Encryption", diff --git a/test/test/test_cryptodev_hash_test_vectors.h b/test/test/test_cryptodev_hash_test_vectors.h index cf86dbb1..a02dfb3c 100644 --- a/test/test/test_cryptodev_hash_test_vectors.h +++ b/test/test/test_cryptodev_hash_test_vectors.h @@ -373,14 +373,16 @@ static const struct blockcipher_test_case hash_test_cases[] = { .test_data = &md5_test_vector, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "MD5 Digest Verify", .test_data = &md5_test_vector, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-MD5 Digest", @@ -391,8 +393,10 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-MD5 Digest Verify", @@ -403,8 +407,10 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA1 Digest", @@ -412,7 +418,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA1 Digest Verify", @@ -420,7 +427,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA1 Digest", @@ -431,9 +439,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA1 Digest Scatter Gather", @@ -441,7 +451,9 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA1 Digest Verify", @@ -452,9 +464,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA1 Digest Verify Scatter Gather", @@ -462,7 +476,9 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .feature_mask = BLOCKCIPHER_TEST_FEATURE_SG, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | - BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC + BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA224 Digest", @@ -470,7 +486,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA224 Digest Verify", @@ -478,7 +495,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA224 Digest", @@ -489,8 +507,10 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_QAT + BLOCKCIPHER_TEST_TARGET_PMD_QAT | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA224 Digest Verify", @@ -501,8 +521,10 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_QAT + BLOCKCIPHER_TEST_TARGET_PMD_QAT | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA256 Digest", @@ -510,7 +532,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA256 Digest Verify", @@ -518,7 +541,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA256 Digest", @@ -529,9 +553,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA256 Digest Verify", @@ -542,9 +568,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA384 Digest", @@ -552,7 +580,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA384 Digest Verify", @@ -560,7 +589,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA384 Digest", @@ -571,9 +601,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA384 Digest Verify", @@ -584,9 +616,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA512 Digest", @@ -594,7 +628,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "SHA512 Digest Verify", @@ -602,7 +637,8 @@ static const struct blockcipher_test_case hash_test_cases[] = { .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA512 Digest", @@ -613,9 +649,11 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "HMAC-SHA512 Digest Verify", @@ -626,33 +664,39 @@ static const struct blockcipher_test_case hash_test_cases[] = { BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER | BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC | BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC | + BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR | BLOCKCIPHER_TEST_TARGET_PMD_QAT | BLOCKCIPHER_TEST_TARGET_PMD_CCP | - BLOCKCIPHER_TEST_TARGET_PMD_MVSAM + BLOCKCIPHER_TEST_TARGET_PMD_MVSAM | + BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX }, { .test_descr = "CMAC Digest 12B", .test_data = &cmac_test_vector_12, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_QAT }, { .test_descr = "CMAC Digest Verify 12B", .test_data = &cmac_test_vector_12, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_QAT }, { .test_descr = "CMAC Digest 16B", .test_data = &cmac_test_vector, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_GEN, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_QAT }, { .test_descr = "CMAC Digest Verify 16B", .test_data = &cmac_test_vector, .op_mask = BLOCKCIPHER_TEST_OP_AUTH_VERIFY, - .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB + .pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB | + BLOCKCIPHER_TEST_TARGET_PMD_QAT } }; diff --git a/test/test/test_cycles.c b/test/test/test_cycles.c index 149f60b0..c78e6a5b 100644 --- a/test/test/test_cycles.c +++ b/test/test/test_cycles.c @@ -23,6 +23,30 @@ * of cycles is correct with regard to the frequency of the timer. */ +static int +check_wait_one_second(void) +{ + uint64_t cycles, prev_cycles; + uint64_t hz = rte_get_timer_hz(); + uint64_t max_inc = (hz / 100); /* 10 ms max between 2 reads */ + + /* check that waiting 1 second is precise */ + prev_cycles = rte_get_timer_cycles(); + rte_delay_us(1000000); + cycles = rte_get_timer_cycles(); + + if ((uint64_t)(cycles - prev_cycles) > (hz + max_inc)) { + printf("delay_us is not accurate: too long\n"); + return -1; + } + if ((uint64_t)(cycles - prev_cycles) < (hz - max_inc)) { + printf("delay_us is not accurate: too short\n"); + return -1; + } + + return 0; +} + static int test_cycles(void) { @@ -43,24 +67,23 @@ test_cycles(void) prev_cycles = cycles; } - /* check that waiting 1 second is precise */ - prev_cycles = rte_get_timer_cycles(); - rte_delay_us(1000000); - cycles = rte_get_timer_cycles(); + return check_wait_one_second(); +} - if ((uint64_t)(cycles - prev_cycles) > (hz + max_inc)) { - printf("delay_us is not accurate: too long\n"); - return -1; - } - if ((uint64_t)(cycles - prev_cycles) < (hz - max_inc)) { - printf("delay_us is not accurate: too short\n"); - return -1; - } +REGISTER_TEST_COMMAND(cycles_autotest, test_cycles); - return 0; +/* + * One second precision test with rte_delay_us_sleep. + */ + +static int +test_delay_us_sleep(void) +{ + rte_delay_us_callback_register(rte_delay_us_sleep); + return check_wait_one_second(); } -REGISTER_TEST_COMMAND(cycles_autotest, test_cycles); +REGISTER_TEST_COMMAND(delay_us_sleep_autotest, test_delay_us_sleep); /* * rte_delay_us_callback test diff --git a/test/test/test_event_eth_rx_adapter.c b/test/test/test_event_eth_rx_adapter.c index 2337e543..1d3be82b 100644 --- a/test/test/test_event_eth_rx_adapter.c +++ b/test/test/test_event_eth_rx_adapter.c @@ -32,7 +32,7 @@ struct event_eth_rx_adapter_test_params { static struct event_eth_rx_adapter_test_params default_params; static inline int -port_init_common(uint8_t port, const struct rte_eth_conf *port_conf, +port_init_common(uint16_t port, const struct rte_eth_conf *port_conf, struct rte_mempool *mp) { const uint16_t rx_ring_size = 512, tx_ring_size = 512; @@ -94,12 +94,11 @@ port_init_common(uint8_t port, const struct rte_eth_conf *port_conf, } static inline int -port_init_rx_intr(uint8_t port, struct rte_mempool *mp) +port_init_rx_intr(uint16_t port, struct rte_mempool *mp) { static const struct rte_eth_conf port_conf_default = { .rxmode = { - .mq_mode = ETH_MQ_RX_RSS, - .max_rx_pkt_len = ETHER_MAX_LEN + .mq_mode = ETH_MQ_RX_NONE, }, .intr_conf = { .rxq = 1, @@ -110,20 +109,12 @@ port_init_rx_intr(uint8_t port, struct rte_mempool *mp) } static inline int -port_init(uint8_t port, struct rte_mempool *mp) +port_init(uint16_t port, struct rte_mempool *mp) { static const struct rte_eth_conf port_conf_default = { .rxmode = { - .mq_mode = ETH_MQ_RX_RSS, - .max_rx_pkt_len = ETHER_MAX_LEN + .mq_mode = ETH_MQ_RX_NONE, }, - .rx_adv_conf = { - .rss_conf = { - .rss_hf = ETH_RSS_IP | - ETH_RSS_TCP | - ETH_RSS_UDP, - } - } }; return port_init_common(port, &port_conf_default, mp); @@ -319,6 +310,8 @@ adapter_create(void) struct rte_event_dev_info dev_info; struct rte_event_port_conf rx_p_conf; + memset(&rx_p_conf, 0, sizeof(rx_p_conf)); + err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); TEST_ASSERT(err == 0, "Expected 0 got %d", err); @@ -496,14 +489,11 @@ adapter_multi_eth_add_del(void) err = init_ports(rte_eth_dev_count_total()); TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); - /* creating new instance for all newly added eth devices */ - adapter_create(); - /* eth_rx_adapter_queue_add for n ports */ port_index = 0; for (; port_index < rte_eth_dev_count_total(); port_index += 1) { err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, - port_index, 0, + port_index, -1, &queue_config); TEST_ASSERT(err == 0, "Expected 0 got %d", err); } @@ -512,12 +502,10 @@ adapter_multi_eth_add_del(void) port_index = 0; for (; port_index < rte_eth_dev_count_total(); port_index += 1) { err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, - port_index, 0); + port_index, -1); TEST_ASSERT(err == 0, "Expected 0 got %d", err); } - adapter_free(); - return TEST_SUCCESS; } @@ -547,11 +535,13 @@ adapter_intr_queue_add_del(void) /* weight = 0 => interrupt mode */ queue_config.servicing_weight = 0; - /* add queue 0 */ - err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, - TEST_ETHDEV_ID, 0, - &queue_config); - TEST_ASSERT(err == 0, "Expected 0 got %d", err); + if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { + /* add queue 0 */ + err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, + TEST_ETHDEV_ID, 0, + &queue_config); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + } /* add all queues */ queue_config.servicing_weight = 0; @@ -561,11 +551,13 @@ adapter_intr_queue_add_del(void) &queue_config); TEST_ASSERT(err == 0, "Expected 0 got %d", err); - /* del queue 0 */ - err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, - TEST_ETHDEV_ID, - 0); - TEST_ASSERT(err == 0, "Expected 0 got %d", err); + if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { + /* del queue 0 */ + err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, + TEST_ETHDEV_ID, + 0); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + } /* del remaining queues */ err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, @@ -583,11 +575,14 @@ adapter_intr_queue_add_del(void) /* intr -> poll mode queue */ queue_config.servicing_weight = 1; - err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, - TEST_ETHDEV_ID, - 0, - &queue_config); - TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) { + err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, + TEST_ETHDEV_ID, + 0, + &queue_config); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + } err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, @@ -682,7 +677,8 @@ static struct unit_test_suite event_eth_rx_tests = { TEST_CASE_ST(NULL, NULL, adapter_create_free), TEST_CASE_ST(adapter_create, adapter_free, adapter_queue_add_del), - TEST_CASE_ST(NULL, NULL, adapter_multi_eth_add_del), + TEST_CASE_ST(adapter_create, adapter_free, + adapter_multi_eth_add_del), TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop), TEST_CASE_ST(adapter_create, adapter_free, adapter_stats), TEST_CASES_END() /**< NULL terminate unit test array */ diff --git a/test/test/test_event_eth_tx_adapter.c b/test/test/test_event_eth_tx_adapter.c new file mode 100644 index 00000000..c26c5152 --- /dev/null +++ b/test/test/test_event_eth_tx_adapter.c @@ -0,0 +1,699 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Intel Corporation + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "test.h" + +#define MAX_NUM_QUEUE RTE_PMD_RING_MAX_RX_RINGS +#define TEST_INST_ID 0 +#define TEST_DEV_ID 0 +#define SOCKET0 0 +#define RING_SIZE 256 +#define ETH_NAME_LEN 32 +#define NUM_ETH_PAIR 1 +#define NUM_ETH_DEV (2 * NUM_ETH_PAIR) +#define NB_MBUF 512 +#define PAIR_PORT_INDEX(p) ((p) + NUM_ETH_PAIR) +#define PORT(p) default_params.port[(p)] +#define TEST_ETHDEV_ID PORT(0) +#define TEST_ETHDEV_PAIR_ID PORT(PAIR_PORT_INDEX(0)) + +#define EDEV_RETRY 0xffff + +struct event_eth_tx_adapter_test_params { + struct rte_mempool *mp; + uint16_t rx_rings, tx_rings; + struct rte_ring *r[NUM_ETH_DEV][MAX_NUM_QUEUE]; + int port[NUM_ETH_DEV]; +}; + +static int event_dev_delete; +static struct event_eth_tx_adapter_test_params default_params; +static uint64_t eid = ~0ULL; +static uint32_t tid; + +static inline int +port_init_common(uint8_t port, const struct rte_eth_conf *port_conf, + struct rte_mempool *mp) +{ + const uint16_t rx_ring_size = RING_SIZE, tx_ring_size = RING_SIZE; + int retval; + uint16_t q; + + if (!rte_eth_dev_is_valid_port(port)) + return -1; + + default_params.rx_rings = MAX_NUM_QUEUE; + default_params.tx_rings = MAX_NUM_QUEUE; + + /* Configure the Ethernet device. */ + retval = rte_eth_dev_configure(port, default_params.rx_rings, + default_params.tx_rings, port_conf); + if (retval != 0) + return retval; + + for (q = 0; q < default_params.rx_rings; q++) { + retval = rte_eth_rx_queue_setup(port, q, rx_ring_size, + rte_eth_dev_socket_id(port), NULL, mp); + if (retval < 0) + return retval; + } + + for (q = 0; q < default_params.tx_rings; q++) { + retval = rte_eth_tx_queue_setup(port, q, tx_ring_size, + rte_eth_dev_socket_id(port), NULL); + if (retval < 0) + return retval; + } + + /* Start the Ethernet port. */ + retval = rte_eth_dev_start(port); + if (retval < 0) + return retval; + + /* Display the port MAC address. */ + struct ether_addr addr; + rte_eth_macaddr_get(port, &addr); + printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8 + " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n", + (unsigned int)port, + addr.addr_bytes[0], addr.addr_bytes[1], + addr.addr_bytes[2], addr.addr_bytes[3], + addr.addr_bytes[4], addr.addr_bytes[5]); + + /* Enable RX in promiscuous mode for the Ethernet device. */ + rte_eth_promiscuous_enable(port); + + return 0; +} + +static inline int +port_init(uint8_t port, struct rte_mempool *mp) +{ + struct rte_eth_conf conf = { 0 }; + return port_init_common(port, &conf, mp); +} + +#define RING_NAME_LEN 20 +#define DEV_NAME_LEN 20 + +static int +init_ports(void) +{ + char ring_name[ETH_NAME_LEN]; + unsigned int i, j; + struct rte_ring * const *c1; + struct rte_ring * const *c2; + int err; + + if (!default_params.mp) + default_params.mp = rte_pktmbuf_pool_create("mbuf_pool", + NB_MBUF, 32, + 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); + + if (!default_params.mp) + return -ENOMEM; + + for (i = 0; i < NUM_ETH_DEV; i++) { + for (j = 0; j < MAX_NUM_QUEUE; j++) { + snprintf(ring_name, sizeof(ring_name), "R%u%u", i, j); + default_params.r[i][j] = rte_ring_create(ring_name, + RING_SIZE, + SOCKET0, + RING_F_SP_ENQ | RING_F_SC_DEQ); + TEST_ASSERT((default_params.r[i][j] != NULL), + "Failed to allocate ring"); + } + } + + /* + * To create two pseudo-Ethernet ports where the traffic is + * switched between them, that is, traffic sent to port 1 is + * read back from port 2 and vice-versa + */ + for (i = 0; i < NUM_ETH_PAIR; i++) { + char dev_name[DEV_NAME_LEN]; + int p; + + c1 = default_params.r[i]; + c2 = default_params.r[PAIR_PORT_INDEX(i)]; + + snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i, i + NUM_ETH_PAIR); + p = rte_eth_from_rings(dev_name, c1, MAX_NUM_QUEUE, + c2, MAX_NUM_QUEUE, SOCKET0); + TEST_ASSERT(p >= 0, "Port creation failed %s", dev_name); + err = port_init(p, default_params.mp); + TEST_ASSERT(err == 0, "Port init failed %s", dev_name); + default_params.port[i] = p; + + snprintf(dev_name, DEV_NAME_LEN, "%u-%u", i + NUM_ETH_PAIR, i); + p = rte_eth_from_rings(dev_name, c2, MAX_NUM_QUEUE, + c1, MAX_NUM_QUEUE, SOCKET0); + TEST_ASSERT(p > 0, "Port creation failed %s", dev_name); + err = port_init(p, default_params.mp); + TEST_ASSERT(err == 0, "Port init failed %s", dev_name); + default_params.port[PAIR_PORT_INDEX(i)] = p; + } + + return 0; +} + +static void +deinit_ports(void) +{ + uint16_t i, j; + char name[ETH_NAME_LEN]; + + for (i = 0; i < RTE_DIM(default_params.port); i++) { + rte_eth_dev_stop(default_params.port[i]); + rte_eth_dev_get_name_by_port(default_params.port[i], name); + rte_vdev_uninit(name); + for (j = 0; j < RTE_DIM(default_params.r[i]); j++) + rte_ring_free(default_params.r[i][j]); + } +} + +static int +testsuite_setup(void) +{ + const char *vdev_name = "event_sw0"; + + int err = init_ports(); + TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err); + + if (rte_event_dev_count() == 0) { + printf("Failed to find a valid event device," + " testing with event_sw0 device\n"); + err = rte_vdev_init(vdev_name, NULL); + TEST_ASSERT(err == 0, "vdev %s creation failed %d\n", + vdev_name, err); + event_dev_delete = 1; + } + return err; +} + +#define DEVICE_ID_SIZE 64 + +static void +testsuite_teardown(void) +{ + deinit_ports(); + rte_mempool_free(default_params.mp); + default_params.mp = NULL; + if (event_dev_delete) + rte_vdev_uninit("event_sw0"); +} + +static int +tx_adapter_create(void) +{ + int err; + struct rte_event_dev_info dev_info; + struct rte_event_port_conf tx_p_conf; + uint8_t priority; + uint8_t queue_id; + + struct rte_event_dev_config config = { + .nb_event_queues = 1, + .nb_event_ports = 1, + }; + + struct rte_event_queue_conf wkr_q_conf = { + .schedule_type = RTE_SCHED_TYPE_ORDERED, + .priority = RTE_EVENT_DEV_PRIORITY_NORMAL, + .nb_atomic_flows = 1024, + .nb_atomic_order_sequences = 1024, + }; + + memset(&tx_p_conf, 0, sizeof(tx_p_conf)); + err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); + config.nb_event_queue_flows = dev_info.max_event_queue_flows; + config.nb_event_port_dequeue_depth = + dev_info.max_event_port_dequeue_depth; + config.nb_event_port_enqueue_depth = + dev_info.max_event_port_enqueue_depth; + config.nb_events_limit = + dev_info.max_num_events; + + err = rte_event_dev_configure(TEST_DEV_ID, &config); + TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", + err); + + queue_id = 0; + err = rte_event_queue_setup(TEST_DEV_ID, 0, &wkr_q_conf); + TEST_ASSERT(err == 0, "Event queue setup failed %d\n", err); + + err = rte_event_port_setup(TEST_DEV_ID, 0, NULL); + TEST_ASSERT(err == 0, "Event port setup failed %d\n", err); + + priority = RTE_EVENT_DEV_PRIORITY_LOWEST; + err = rte_event_port_link(TEST_DEV_ID, 0, &queue_id, &priority, 1); + TEST_ASSERT(err == 1, "Error linking port %s\n", + rte_strerror(rte_errno)); + err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + tx_p_conf.new_event_threshold = dev_info.max_num_events; + tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; + tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; + err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, + &tx_p_conf); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + return err; +} + +static void +tx_adapter_free(void) +{ + rte_event_eth_tx_adapter_free(TEST_INST_ID); +} + +static int +tx_adapter_create_free(void) +{ + int err; + struct rte_event_dev_info dev_info; + struct rte_event_port_conf tx_p_conf; + + err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + tx_p_conf.new_event_threshold = dev_info.max_num_events; + tx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth; + tx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth; + + err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, + NULL); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + err = rte_event_eth_tx_adapter_create(TEST_INST_ID, TEST_DEV_ID, + &tx_p_conf); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_create(TEST_INST_ID, + TEST_DEV_ID, &tx_p_conf); + TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err); + + err = rte_event_eth_tx_adapter_free(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_free(TEST_INST_ID); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); + + err = rte_event_eth_tx_adapter_free(1); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err); + + return TEST_SUCCESS; +} + +static int +tx_adapter_queue_add_del(void) +{ + int err; + uint32_t cap; + + err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, + &cap); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, + rte_eth_dev_count_total(), + -1); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, + TEST_ETHDEV_ID, + 0); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, + TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, + TEST_ETHDEV_ID, + 0); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, + TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, + TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_queue_add(1, TEST_ETHDEV_ID, -1); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + err = rte_event_eth_tx_adapter_queue_del(1, TEST_ETHDEV_ID, -1); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + return TEST_SUCCESS; +} + +static int +tx_adapter_start_stop(void) +{ + int err; + + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_start(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_stop(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_start(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_stop(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_start(1); + + err = rte_event_eth_tx_adapter_stop(1); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + return TEST_SUCCESS; +} + + +static int +tx_adapter_single(uint16_t port, uint16_t tx_queue_id, + struct rte_mbuf *m, uint8_t qid, + uint8_t sched_type) +{ + struct rte_event event; + struct rte_mbuf *r; + int ret; + unsigned int l; + + event.queue_id = qid; + event.op = RTE_EVENT_OP_NEW; + event.event_type = RTE_EVENT_TYPE_CPU; + event.sched_type = sched_type; + event.mbuf = m; + + m->port = port; + rte_event_eth_tx_adapter_txq_set(m, tx_queue_id); + + l = 0; + while (rte_event_enqueue_burst(TEST_DEV_ID, 0, &event, 1) != 1) { + l++; + if (l > EDEV_RETRY) + break; + } + + TEST_ASSERT(l < EDEV_RETRY, "Unable to enqueue to eventdev"); + l = 0; + while (l++ < EDEV_RETRY) { + + if (eid != ~0ULL) { + ret = rte_service_run_iter_on_app_lcore(eid, 0); + TEST_ASSERT(ret == 0, "failed to run service %d", ret); + } + + ret = rte_service_run_iter_on_app_lcore(tid, 0); + TEST_ASSERT(ret == 0, "failed to run service %d", ret); + + if (rte_eth_rx_burst(TEST_ETHDEV_PAIR_ID, tx_queue_id, + &r, 1)) { + TEST_ASSERT_EQUAL(r, m, "mbuf comparison failed" + " expected %p received %p", m, r); + return 0; + } + } + + TEST_ASSERT(0, "Failed to receive packet"); + return -1; +} + +static int +tx_adapter_service(void) +{ + struct rte_event_eth_tx_adapter_stats stats; + uint32_t i; + int err; + uint8_t ev_port, ev_qid; + struct rte_mbuf bufs[RING_SIZE]; + struct rte_mbuf *pbufs[RING_SIZE]; + struct rte_event_dev_info dev_info; + struct rte_event_dev_config dev_conf; + struct rte_event_queue_conf qconf; + uint32_t qcnt, pcnt; + uint16_t q; + int internal_port; + uint32_t cap; + + memset(&dev_conf, 0, sizeof(dev_conf)); + err = rte_event_eth_tx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID, + &cap); + TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err); + + internal_port = !!(cap & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT); + if (internal_port) + return TEST_SUCCESS; + + err = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_event_port_get(TEST_INST_ID, + &ev_port); + TEST_ASSERT_SUCCESS(err, "Failed to get event port %d", err); + + err = rte_event_dev_attr_get(TEST_DEV_ID, RTE_EVENT_DEV_ATTR_PORT_COUNT, + &pcnt); + TEST_ASSERT_SUCCESS(err, "Port count get failed"); + + err = rte_event_dev_attr_get(TEST_DEV_ID, + RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &qcnt); + TEST_ASSERT_SUCCESS(err, "Queue count get failed"); + + err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info); + TEST_ASSERT_SUCCESS(err, "Dev info failed"); + + dev_conf.nb_event_queue_flows = dev_info.max_event_queue_flows; + dev_conf.nb_event_port_dequeue_depth = + dev_info.max_event_port_dequeue_depth; + dev_conf.nb_event_port_enqueue_depth = + dev_info.max_event_port_enqueue_depth; + dev_conf.nb_events_limit = + dev_info.max_num_events; + dev_conf.nb_event_queues = qcnt + 1; + dev_conf.nb_event_ports = pcnt; + err = rte_event_dev_configure(TEST_DEV_ID, &dev_conf); + TEST_ASSERT(err == 0, "Event device initialization failed err %d\n", + err); + + ev_qid = qcnt; + qconf.nb_atomic_flows = dev_info.max_event_queue_flows; + qconf.nb_atomic_order_sequences = 32; + qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC; + qconf.priority = RTE_EVENT_DEV_PRIORITY_HIGHEST; + qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK; + err = rte_event_queue_setup(TEST_DEV_ID, ev_qid, &qconf); + TEST_ASSERT_SUCCESS(err, "Failed to setup queue %u", ev_qid); + + /* + * Setup ports again so that the newly added queue is visible + * to them + */ + for (i = 0; i < pcnt; i++) { + + int n_links; + uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV]; + uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV]; + + if (i == ev_port) + continue; + + n_links = rte_event_port_links_get(TEST_DEV_ID, i, queues, + priorities); + TEST_ASSERT(n_links > 0, "Failed to get port links %d\n", + n_links); + err = rte_event_port_setup(TEST_DEV_ID, i, NULL); + TEST_ASSERT(err == 0, "Failed to setup port err %d\n", err); + err = rte_event_port_link(TEST_DEV_ID, i, queues, priorities, + n_links); + TEST_ASSERT(n_links == err, "Failed to link all queues" + " err %s\n", rte_strerror(rte_errno)); + } + + err = rte_event_port_link(TEST_DEV_ID, ev_port, &ev_qid, NULL, 1); + TEST_ASSERT(err == 1, "Failed to link queue port %u", + ev_port); + + err = rte_event_eth_tx_adapter_start(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + if (!(dev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) { + err = rte_event_dev_service_id_get(0, (uint32_t *)&eid); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_service_runstate_set(eid, 1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_service_set_runstate_mapped_check(eid, 0); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + } + + err = rte_event_eth_tx_adapter_service_id_get(TEST_INST_ID, &tid); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_service_runstate_set(tid, 1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_service_set_runstate_mapped_check(tid, 0); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_dev_start(TEST_DEV_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + for (q = 0; q < MAX_NUM_QUEUE; q++) { + for (i = 0; i < RING_SIZE; i++) + pbufs[i] = &bufs[i]; + for (i = 0; i < RING_SIZE; i++) { + pbufs[i] = &bufs[i]; + err = tx_adapter_single(TEST_ETHDEV_ID, q, pbufs[i], + ev_qid, + RTE_SCHED_TYPE_ORDERED); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + } + for (i = 0; i < RING_SIZE; i++) { + TEST_ASSERT_EQUAL(pbufs[i], &bufs[i], + "Error: received data does not match" + " that transmitted"); + } + } + + err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, NULL); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT_EQUAL(stats.tx_packets, MAX_NUM_QUEUE * RING_SIZE, + "stats.tx_packets expected %u got %"PRIu64, + MAX_NUM_QUEUE * RING_SIZE, + stats.tx_packets); + + err = rte_event_eth_tx_adapter_stats_reset(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_stats_get(TEST_INST_ID, &stats); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + TEST_ASSERT_EQUAL(stats.tx_packets, 0, + "stats.tx_packets expected %u got %"PRIu64, + 0, + stats.tx_packets); + + err = rte_event_eth_tx_adapter_stats_get(1, &stats); + TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err); + + err = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID, + -1); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + err = rte_event_eth_tx_adapter_free(TEST_INST_ID); + TEST_ASSERT(err == 0, "Expected 0 got %d", err); + + rte_event_dev_stop(TEST_DEV_ID); + + return TEST_SUCCESS; +} + +static int +tx_adapter_dynamic_device(void) +{ + uint16_t port_id = rte_eth_dev_count_avail(); + const char *null_dev[2] = { "eth_null0", "eth_null1" }; + struct rte_eth_conf dev_conf; + int ret; + size_t i; + + memset(&dev_conf, 0, sizeof(dev_conf)); + for (i = 0; i < RTE_DIM(null_dev); i++) { + ret = rte_vdev_init(null_dev[i], NULL); + TEST_ASSERT_SUCCESS(ret, "%s Port creation failed %d", + null_dev[i], ret); + + if (i == 0) { + ret = tx_adapter_create(); + TEST_ASSERT_SUCCESS(ret, "Adapter create failed %d", + ret); + } + + ret = rte_eth_dev_configure(port_id + i, MAX_NUM_QUEUE, + MAX_NUM_QUEUE, &dev_conf); + TEST_ASSERT_SUCCESS(ret, "Failed to configure device %d", ret); + + ret = rte_event_eth_tx_adapter_queue_add(TEST_INST_ID, + port_id + i, 0); + TEST_ASSERT_SUCCESS(ret, "Failed to add queues %d", ret); + + } + + for (i = 0; i < RTE_DIM(null_dev); i++) { + ret = rte_event_eth_tx_adapter_queue_del(TEST_INST_ID, + port_id + i, -1); + TEST_ASSERT_SUCCESS(ret, "Failed to delete queues %d", ret); + } + + tx_adapter_free(); + + for (i = 0; i < RTE_DIM(null_dev); i++) + rte_vdev_uninit(null_dev[i]); + + return TEST_SUCCESS; +} + +static struct unit_test_suite event_eth_tx_tests = { + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .suite_name = "tx event eth adapter test suite", + .unit_test_cases = { + TEST_CASE_ST(NULL, NULL, tx_adapter_create_free), + TEST_CASE_ST(tx_adapter_create, tx_adapter_free, + tx_adapter_queue_add_del), + TEST_CASE_ST(tx_adapter_create, tx_adapter_free, + tx_adapter_start_stop), + TEST_CASE_ST(tx_adapter_create, tx_adapter_free, + tx_adapter_service), + TEST_CASE_ST(NULL, NULL, tx_adapter_dynamic_device), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static int +test_event_eth_tx_adapter_common(void) +{ + return unit_test_suite_runner(&event_eth_tx_tests); +} + +REGISTER_TEST_COMMAND(event_eth_tx_adapter_autotest, + test_event_eth_tx_adapter_common); diff --git a/test/test/test_event_timer_adapter.c b/test/test/test_event_timer_adapter.c index 93471db1..a45b7d19 100644 --- a/test/test/test_event_timer_adapter.c +++ b/test/test/test_event_timer_adapter.c @@ -792,7 +792,7 @@ _cancel_burst_thread(void *args) TEST_ASSERT_EQUAL(n, ret, "Failed to cancel complete burst of " "event timers"); rte_mempool_put_bulk(eventdev_test_mempool, (void **)ev_tim, - ret); + RTE_MIN(ret, MAX_BURST)); cancel_count += ret; } diff --git a/test/test/test_eventdev.c b/test/test/test_eventdev.c index 04bdc6b6..00d73275 100644 --- a/test/test/test_eventdev.c +++ b/test/test/test_eventdev.c @@ -190,15 +190,18 @@ test_eventdev_configure(void) "Config negative test failed"); TEST_ASSERT_EQUAL(-EINVAL, test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows), - "Config negative test failed"); - TEST_ASSERT_EQUAL(-EINVAL, - test_ethdev_config_run(&dev_conf, &info, - max_event_port_dequeue_depth), - "Config negative test failed"); - TEST_ASSERT_EQUAL(-EINVAL, - test_ethdev_config_run(&dev_conf, &info, - max_event_port_enqueue_depth), - "Config negative test failed"); + "Config negative test failed"); + + if (info.event_dev_cap & RTE_EVENT_DEV_CAP_BURST_MODE) { + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, + max_event_port_dequeue_depth), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, + max_event_port_enqueue_depth), + "Config negative test failed"); + } /* Positive case */ devconf_set_default_sane_values(&dev_conf, &info); diff --git a/test/test/test_external_mem.c b/test/test/test_external_mem.c new file mode 100644 index 00000000..998cafa6 --- /dev/null +++ b/test/test/test_external_mem.c @@ -0,0 +1,390 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Intel Corporation + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "test.h" + +#define EXTERNAL_MEM_SZ (RTE_PGSIZE_4K << 10) /* 4M of data */ + +static int +test_invalid_param(void *addr, size_t len, size_t pgsz, rte_iova_t *iova, + int n_pages) +{ + static const char * const names[] = { + NULL, /* NULL name */ + "", /* empty name */ + "this heap name is definitely way too long to be valid" + }; + const char *valid_name = "valid heap name"; + unsigned int i; + + /* check invalid name handling */ + for (i = 0; i < RTE_DIM(names); i++) { + const char *name = names[i]; + + /* these calls may fail for other reasons, so check errno */ + if (rte_malloc_heap_create(name) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Created heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_destroy(name) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Destroyed heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_get_socket(name) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Found socket for heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_add(name, addr, len, + NULL, 0, pgsz) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Added memory to heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_remove(name, addr, len) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Removed memory from heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_attach(name, addr, len) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Attached memory to heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_detach(name, addr, len) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Detached memory from heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + } + + /* do same as above, but with a valid heap name */ + + /* skip create call */ + if (rte_malloc_heap_destroy(valid_name) >= 0 || rte_errno != ENOENT) { + printf("%s():%i: Destroyed heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_get_socket(valid_name) >= 0 || + rte_errno != ENOENT) { + printf("%s():%i: Found socket for heap with invalid name\n", + __func__, __LINE__); + goto fail; + } + + /* these calls may fail for other reasons, so check errno */ + if (rte_malloc_heap_memory_add(valid_name, addr, len, + NULL, 0, pgsz) >= 0 || rte_errno != ENOENT) { + printf("%s():%i: Added memory to non-existent heap\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_remove(valid_name, addr, len) >= 0 || + rte_errno != ENOENT) { + printf("%s():%i: Removed memory from non-existent heap\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_attach(valid_name, addr, len) >= 0 || + rte_errno != ENOENT) { + printf("%s():%i: Attached memory to non-existent heap\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_detach(valid_name, addr, len) >= 0 || + rte_errno != ENOENT) { + printf("%s():%i: Detached memory from non-existent heap\n", + __func__, __LINE__); + goto fail; + } + + /* create a valid heap but test other invalid parameters */ + if (rte_malloc_heap_create(valid_name) != 0) { + printf("%s():%i: Failed to create valid heap\n", + __func__, __LINE__); + goto fail; + } + + /* zero length */ + if (rte_malloc_heap_memory_add(valid_name, addr, 0, + NULL, 0, pgsz) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Added memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_remove(valid_name, addr, 0) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Removed memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_attach(valid_name, addr, 0) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Attached memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_detach(valid_name, addr, 0) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Detached memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + /* zero address */ + if (rte_malloc_heap_memory_add(valid_name, NULL, len, + NULL, 0, pgsz) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Added memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_remove(valid_name, NULL, len) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Removed memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + if (rte_malloc_heap_memory_attach(valid_name, NULL, len) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Attached memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_detach(valid_name, NULL, len) >= 0 || + rte_errno != EINVAL) { + printf("%s():%i: Detached memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + /* wrong page count */ + if (rte_malloc_heap_memory_add(valid_name, addr, len, + iova, 0, pgsz) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Added memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_add(valid_name, addr, len, + iova, n_pages - 1, pgsz) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Added memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_memory_add(valid_name, addr, len, + iova, n_pages + 1, pgsz) >= 0 || rte_errno != EINVAL) { + printf("%s():%i: Added memory with invalid parameters\n", + __func__, __LINE__); + goto fail; + } + + /* tests passed, destroy heap */ + if (rte_malloc_heap_destroy(valid_name) != 0) { + printf("%s():%i: Failed to destroy valid heap\n", + __func__, __LINE__); + goto fail; + } + return 0; +fail: + rte_malloc_heap_destroy(valid_name); + return -1; +} + +static int +test_basic(void *addr, size_t len, size_t pgsz, rte_iova_t *iova, int n_pages) +{ + const char *heap_name = "heap"; + void *ptr = NULL; + int socket_id, i; + const struct rte_memzone *mz = NULL; + + /* create heap */ + if (rte_malloc_heap_create(heap_name) != 0) { + printf("%s():%i: Failed to create malloc heap\n", + __func__, __LINE__); + goto fail; + } + + /* get socket ID corresponding to this heap */ + socket_id = rte_malloc_heap_get_socket(heap_name); + if (socket_id < 0) { + printf("%s():%i: cannot find socket for external heap\n", + __func__, __LINE__); + goto fail; + } + + /* heap is empty, so any allocation should fail */ + ptr = rte_malloc_socket("EXTMEM", 64, 0, socket_id); + if (ptr != NULL) { + printf("%s():%i: Allocated from empty heap\n", __func__, + __LINE__); + goto fail; + } + + /* add memory to heap */ + if (rte_malloc_heap_memory_add(heap_name, addr, len, + iova, n_pages, pgsz) != 0) { + printf("%s():%i: Failed to add memory to heap\n", + __func__, __LINE__); + goto fail; + } + + /* check that we can get this memory from EAL now */ + for (i = 0; i < n_pages; i++) { + const struct rte_memseg *ms; + void *cur = RTE_PTR_ADD(addr, pgsz * i); + + ms = rte_mem_virt2memseg(cur, NULL); + if (ms == NULL) { + printf("%s():%i: Failed to retrieve memseg for external mem\n", + __func__, __LINE__); + goto fail; + } + if (ms->addr != cur) { + printf("%s():%i: VA mismatch\n", __func__, __LINE__); + goto fail; + } + if (ms->iova != iova[i]) { + printf("%s():%i: IOVA mismatch\n", __func__, __LINE__); + goto fail; + } + } + + /* allocate - this now should succeed */ + ptr = rte_malloc_socket("EXTMEM", 64, 0, socket_id); + if (ptr == NULL) { + printf("%s():%i: Failed to allocate from external heap\n", + __func__, __LINE__); + goto fail; + } + + /* check if address is in expected range */ + if (ptr < addr || ptr >= RTE_PTR_ADD(addr, len)) { + printf("%s():%i: Allocated from unexpected address space\n", + __func__, __LINE__); + goto fail; + } + + /* we've allocated something - removing memory should fail */ + if (rte_malloc_heap_memory_remove(heap_name, addr, len) >= 0 || + rte_errno != EBUSY) { + printf("%s():%i: Removing memory succeeded when memory is not free\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_destroy(heap_name) >= 0 || rte_errno != EBUSY) { + printf("%s():%i: Destroying heap succeeded when memory is not free\n", + __func__, __LINE__); + goto fail; + } + + /* try allocating an IOVA-contiguous memzone - this should succeed + * because we've set up a contiguous IOVA table. + */ + mz = rte_memzone_reserve("heap_test", pgsz * 2, socket_id, + RTE_MEMZONE_IOVA_CONTIG); + if (mz == NULL) { + printf("%s():%i: Failed to reserve memzone\n", + __func__, __LINE__); + goto fail; + } + + rte_malloc_dump_stats(stdout, NULL); + rte_malloc_dump_heaps(stdout); + + /* free memory - removing it should now succeed */ + rte_free(ptr); + ptr = NULL; + + rte_memzone_free(mz); + mz = NULL; + + if (rte_malloc_heap_memory_remove(heap_name, addr, len) != 0) { + printf("%s():%i: Removing memory from heap failed\n", + __func__, __LINE__); + goto fail; + } + if (rte_malloc_heap_destroy(heap_name) != 0) { + printf("%s():%i: Destroying heap failed\n", + __func__, __LINE__); + goto fail; + } + + return 0; +fail: + rte_memzone_free(mz); + rte_free(ptr); + /* even if something failed, attempt to clean up */ + rte_malloc_heap_memory_remove(heap_name, addr, len); + rte_malloc_heap_destroy(heap_name); + + return -1; +} + +/* we need to test attach/detach in secondary processes. */ +static int +test_external_mem(void) +{ + size_t len = EXTERNAL_MEM_SZ; + size_t pgsz = RTE_PGSIZE_4K; + rte_iova_t iova[len / pgsz]; + void *addr; + int ret, n_pages; + int i; + + /* create external memory area */ + n_pages = RTE_DIM(iova); + addr = mmap(NULL, len, PROT_WRITE | PROT_READ, + MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); + if (addr == MAP_FAILED) { + printf("%s():%i: Failed to create dummy memory area\n", + __func__, __LINE__); + return -1; + } + for (i = 0; i < n_pages; i++) { + /* arbitrary IOVA */ + rte_iova_t tmp = 0x100000000 + i * pgsz; + iova[i] = tmp; + } + + ret = test_invalid_param(addr, len, pgsz, iova, n_pages); + ret |= test_basic(addr, len, pgsz, iova, n_pages); + + munmap(addr, len); + + return ret; +} + +REGISTER_TEST_COMMAND(external_mem_autotest, test_external_mem); diff --git a/test/test/test_hash.c b/test/test/test_hash.c index b3db9fd1..6d06eb24 100644 --- a/test/test/test_hash.c +++ b/test/test/test_hash.c @@ -260,6 +260,13 @@ static void run_hash_func_tests(void) * - lookup (hit) * - delete * - lookup (miss) + * + * Repeat the test case when 'free on delete' is disabled. + * - add + * - lookup (hit) + * - delete + * - lookup (miss) + * - free */ static int test_add_delete(void) { @@ -295,10 +302,12 @@ static int test_add_delete(void) /* repeat test with precomputed hash functions */ hash_sig_t hash_value; - int pos1, expectedPos1; + int pos1, expectedPos1, delPos1; + 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; hash_value = rte_hash_hash(handle, &keys[0]); pos1 = rte_hash_add_key_with_hash(handle, &keys[0], hash_value); @@ -315,12 +324,18 @@ static int test_add_delete(void) print_key_info("Del", &keys[0], pos1); RETURN_IF_ERROR(pos1 != expectedPos1, "failed to delete key (pos1=%d)", pos1); + delPos1 = pos1; 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); + 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); + rte_hash_free(handle); return 0; @@ -390,6 +405,84 @@ static int test_add_update_delete(void) return 0; } +/* + * 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; +} + /* * Sequence of operations for retrieving a key with its position * @@ -399,11 +492,20 @@ static int test_add_update_delete(void) * - delete key * - try to get the deleted key: miss * + * 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 + * */ static int test_hash_get_key_with_position(void) { struct rte_hash *handle = NULL; - int pos, expectedPos, result; + int pos, expectedPos, delPos, result; void *key; ut_params.name = "hash_get_key_w_pos"; @@ -426,6 +528,38 @@ static int test_hash_get_key_with_position(void) result = rte_hash_get_key_with_position(handle, pos, &key); RETURN_IF_ERROR(result != -ENOENT, "non valid key retrieved"); + 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"); + rte_hash_free(handle); return 0; } @@ -660,6 +794,116 @@ static int test_full_bucket(void) return 0; } +/* + * 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, + .key_len = sizeof(struct flow_key), /* 13 */ + .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(¶ms_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; +} + /******************************************************************************/ static int fbk_hash_unit_test(void) @@ -1096,7 +1340,7 @@ test_hash_creation_with_good_parameters(void) * Test to see the average table utilization (entries added/max entries) * before hitting a random entry that cannot be added */ -static int test_average_table_utilization(void) +static int test_average_table_utilization(uint32_t ext_table) { struct rte_hash *handle; uint8_t simple_key[MAX_KEYSIZE]; @@ -1107,12 +1351,23 @@ static int test_average_table_utilization(void) printf("\n# Running test to determine average utilization" "\n before adding elements begins to fail\n"); + if (ext_table) + printf("ext table is enabled\n"); + else + printf("ext table is disabled\n"); + printf("Measuring performance, please wait"); fflush(stdout); ut_params.entries = 1 << 16; ut_params.name = "test_average_utilization"; ut_params.hash_func = rte_jhash; + if (ext_table) + ut_params.extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE; + else + ut_params.extra_flag &= ~RTE_HASH_EXTRA_FLAGS_EXT_TABLE; + handle = rte_hash_create(&ut_params); + RETURN_IF_ERROR(handle == NULL, "hash creation failed"); for (j = 0; j < ITERATIONS; j++) { @@ -1139,6 +1394,14 @@ static int test_average_table_utilization(void) rte_hash_free(handle); return -1; } + 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; + } + } average_keys_added += added_keys; @@ -1161,7 +1424,7 @@ static int test_average_table_utilization(void) } #define NUM_ENTRIES 256 -static int test_hash_iteration(void) +static int test_hash_iteration(uint32_t ext_table) { struct rte_hash *handle; unsigned i; @@ -1177,6 +1440,11 @@ static int test_hash_iteration(void) ut_params.name = "test_hash_iteration"; ut_params.hash_func = rte_jhash; ut_params.key_len = 16; + if (ext_table) + ut_params.extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE; + else + ut_params.extra_flag &= ~RTE_HASH_EXTRA_FLAGS_EXT_TABLE; + handle = rte_hash_create(&ut_params); RETURN_IF_ERROR(handle == NULL, "hash creation failed"); @@ -1186,8 +1454,13 @@ static int test_hash_iteration(void) 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]); - if (ret < 0) + if (ret < 0) { + if (ext_table) { + printf("Insertion failed for ext table\n"); + goto err; + } break; + } } /* Iterate through the hash table */ @@ -1470,10 +1743,14 @@ test_hash(void) return -1; if (test_add_update_delete() < 0) return -1; + if (test_add_update_delete_free() < 0) + return -1; if (test_five_keys() < 0) return -1; if (test_full_bucket() < 0) return -1; + if (test_extendable_bucket() < 0) + return -1; if (test_fbk_hash_find_existing() < 0) return -1; @@ -1483,9 +1760,17 @@ test_hash(void) return -1; if (test_hash_creation_with_good_parameters() < 0) return -1; - if (test_average_table_utilization() < 0) + + /* 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) return -1; - if (test_hash_iteration() < 0) + if (test_hash_iteration(1) < 0) return -1; run_hash_func_tests(); diff --git a/test/test/test_hash_multiwriter.c b/test/test/test_hash_multiwriter.c index 6a3eb10b..d447f6dc 100644 --- a/test/test/test_hash_multiwriter.c +++ b/test/test/test_hash_multiwriter.c @@ -12,6 +12,7 @@ #include #include #include +#include #include "test.h" @@ -108,7 +109,7 @@ test_hash_multiwriter(void) struct rte_hash_parameters hash_params = { .entries = nb_entries, .key_len = sizeof(uint32_t), - .hash_func = rte_hash_crc, + .hash_func = rte_jhash, .hash_func_init_val = 0, .socket_id = rte_socket_id(), }; diff --git a/test/test/test_hash_perf.c b/test/test/test_hash_perf.c index 33dcb9fc..52521118 100644 --- a/test/test/test_hash_perf.c +++ b/test/test/test_hash_perf.c @@ -18,9 +18,11 @@ #include "test.h" #define MAX_ENTRIES (1 << 19) -#define KEYS_TO_ADD (MAX_ENTRIES * 3 / 4) /* 75% table utilization */ +#define KEYS_TO_ADD (MAX_ENTRIES) +#define ADD_PERCENT 0.75 /* 75% table utilization */ #define NUM_LOOKUPS (KEYS_TO_ADD * 5) /* Loop among keys added, several times */ -#define BUCKET_SIZE 4 +/* BUCKET_SIZE should be same as RTE_HASH_BUCKET_ENTRIES in rte_hash library */ +#define BUCKET_SIZE 8 #define NUM_BUCKETS (MAX_ENTRIES / BUCKET_SIZE) #define MAX_KEYSIZE 64 #define NUM_KEYSIZES 10 @@ -77,7 +79,7 @@ static struct rte_hash_parameters ut_params = { static int create_table(unsigned int with_data, unsigned int table_index, - unsigned int with_locks) + unsigned int with_locks, unsigned int ext) { char name[RTE_HASH_NAMESIZE]; @@ -95,6 +97,9 @@ create_table(unsigned int with_data, unsigned int table_index, else ut_params.extra_flag = 0; + if (ext) + ut_params.extra_flag |= RTE_HASH_EXTRA_FLAGS_EXT_TABLE; + ut_params.name = name; ut_params.key_len = hashtest_key_lens[table_index]; ut_params.socket_id = rte_socket_id(); @@ -116,15 +121,21 @@ create_table(unsigned int with_data, unsigned int table_index, /* Shuffle the keys that have been added, so lookups will be totally random */ static void -shuffle_input_keys(unsigned table_index) +shuffle_input_keys(unsigned int table_index, unsigned int ext) { unsigned i; uint32_t swap_idx; uint8_t temp_key[MAX_KEYSIZE]; hash_sig_t temp_signature; int32_t temp_position; + unsigned int keys_to_add; + + if (!ext) + keys_to_add = KEYS_TO_ADD * ADD_PERCENT; + else + keys_to_add = KEYS_TO_ADD; - for (i = KEYS_TO_ADD - 1; i > 0; i--) { + for (i = keys_to_add - 1; i > 0; i--) { swap_idx = rte_rand() % i; memcpy(temp_key, keys[i], hashtest_key_lens[table_index]); @@ -146,14 +157,20 @@ shuffle_input_keys(unsigned table_index) * ALL can fit in hash table (no errors) */ static int -get_input_keys(unsigned with_pushes, unsigned table_index) +get_input_keys(unsigned int with_pushes, unsigned int table_index, + unsigned int ext) { unsigned i, j; unsigned bucket_idx, incr, success = 1; uint8_t k = 0; int32_t ret; const uint32_t bucket_bitmask = NUM_BUCKETS - 1; + unsigned int keys_to_add; + if (!ext) + keys_to_add = KEYS_TO_ADD * ADD_PERCENT; + else + keys_to_add = KEYS_TO_ADD; /* Reset all arrays */ for (i = 0; i < MAX_ENTRIES; i++) slot_taken[i] = 0; @@ -170,7 +187,7 @@ get_input_keys(unsigned with_pushes, unsigned table_index) * Regardless a key has been added correctly or not (success), * the next one to try will be increased by 1. */ - for (i = 0; i < KEYS_TO_ADD;) { + for (i = 0; i < keys_to_add;) { incr = 0; if (i != 0) { keys[i][0] = ++k; @@ -234,21 +251,27 @@ get_input_keys(unsigned with_pushes, unsigned table_index) } static int -timed_adds(unsigned with_hash, unsigned with_data, unsigned table_index) +timed_adds(unsigned int with_hash, unsigned int with_data, + unsigned int table_index, unsigned int ext) { unsigned i; const uint64_t start_tsc = rte_rdtsc(); void *data; int32_t ret; + unsigned int keys_to_add; + if (!ext) + keys_to_add = KEYS_TO_ADD * ADD_PERCENT; + else + keys_to_add = KEYS_TO_ADD; - for (i = 0; i < KEYS_TO_ADD; i++) { + for (i = 0; i < keys_to_add; i++) { data = (void *) ((uintptr_t) signatures[i]); if (with_hash && with_data) { ret = rte_hash_add_key_with_hash_data(h[table_index], (const void *) keys[i], signatures[i], data); if (ret < 0) { - printf("Failed to add key number %u\n", ret); + printf("H+D: Failed to add key number %u\n", i); return -1; } } else if (with_hash && !with_data) { @@ -258,7 +281,7 @@ timed_adds(unsigned with_hash, unsigned with_data, unsigned table_index) if (ret >= 0) positions[i] = ret; else { - printf("Failed to add key number %u\n", ret); + printf("H: Failed to add key number %u\n", i); return -1; } } else if (!with_hash && with_data) { @@ -266,7 +289,7 @@ timed_adds(unsigned with_hash, unsigned with_data, unsigned table_index) (const void *) keys[i], data); if (ret < 0) { - printf("Failed to add key number %u\n", ret); + printf("D: Failed to add key number %u\n", i); return -1; } } else { @@ -274,7 +297,7 @@ timed_adds(unsigned with_hash, unsigned with_data, unsigned table_index) if (ret >= 0) positions[i] = ret; else { - printf("Failed to add key number %u\n", ret); + printf("Failed to add key number %u\n", i); return -1; } } @@ -283,22 +306,31 @@ timed_adds(unsigned with_hash, unsigned with_data, unsigned table_index) const uint64_t end_tsc = rte_rdtsc(); const uint64_t time_taken = end_tsc - start_tsc; - cycles[table_index][ADD][with_hash][with_data] = time_taken/KEYS_TO_ADD; + cycles[table_index][ADD][with_hash][with_data] = time_taken/keys_to_add; return 0; } static int -timed_lookups(unsigned with_hash, unsigned with_data, unsigned table_index) +timed_lookups(unsigned int with_hash, unsigned int with_data, + unsigned int table_index, unsigned int ext) { unsigned i, j; const uint64_t start_tsc = rte_rdtsc(); void *ret_data; void *expected_data; int32_t ret; - - for (i = 0; i < NUM_LOOKUPS/KEYS_TO_ADD; i++) { - for (j = 0; j < KEYS_TO_ADD; j++) { + unsigned int keys_to_add, num_lookups; + + if (!ext) { + keys_to_add = KEYS_TO_ADD * ADD_PERCENT; + num_lookups = NUM_LOOKUPS * ADD_PERCENT; + } else { + keys_to_add = KEYS_TO_ADD; + num_lookups = NUM_LOOKUPS; + } + for (i = 0; i < num_lookups / keys_to_add; i++) { + for (j = 0; j < keys_to_add; j++) { if (with_hash && with_data) { ret = rte_hash_lookup_with_hash_data(h[table_index], (const void *) keys[j], @@ -351,13 +383,14 @@ timed_lookups(unsigned with_hash, unsigned with_data, unsigned table_index) const uint64_t end_tsc = rte_rdtsc(); const uint64_t time_taken = end_tsc - start_tsc; - cycles[table_index][LOOKUP][with_hash][with_data] = time_taken/NUM_LOOKUPS; + cycles[table_index][LOOKUP][with_hash][with_data] = time_taken/num_lookups; return 0; } static int -timed_lookups_multi(unsigned with_data, unsigned table_index) +timed_lookups_multi(unsigned int with_data, unsigned int table_index, + unsigned int ext) { unsigned i, j, k; int32_t positions_burst[BURST_SIZE]; @@ -366,11 +399,20 @@ timed_lookups_multi(unsigned with_data, unsigned table_index) void *ret_data[BURST_SIZE]; uint64_t hit_mask; int ret; + unsigned int keys_to_add, num_lookups; + + if (!ext) { + keys_to_add = KEYS_TO_ADD * ADD_PERCENT; + num_lookups = NUM_LOOKUPS * ADD_PERCENT; + } else { + keys_to_add = KEYS_TO_ADD; + num_lookups = NUM_LOOKUPS; + } const uint64_t start_tsc = rte_rdtsc(); - for (i = 0; i < NUM_LOOKUPS/KEYS_TO_ADD; i++) { - for (j = 0; j < KEYS_TO_ADD/BURST_SIZE; j++) { + for (i = 0; i < num_lookups/keys_to_add; i++) { + for (j = 0; j < keys_to_add/BURST_SIZE; j++) { for (k = 0; k < BURST_SIZE; k++) keys_burst[k] = keys[j * BURST_SIZE + k]; if (with_data) { @@ -418,19 +460,25 @@ timed_lookups_multi(unsigned with_data, unsigned table_index) const uint64_t end_tsc = rte_rdtsc(); const uint64_t time_taken = end_tsc - start_tsc; - cycles[table_index][LOOKUP_MULTI][0][with_data] = time_taken/NUM_LOOKUPS; + cycles[table_index][LOOKUP_MULTI][0][with_data] = time_taken/num_lookups; return 0; } static int -timed_deletes(unsigned with_hash, unsigned with_data, unsigned table_index) +timed_deletes(unsigned int with_hash, unsigned int with_data, + unsigned int table_index, unsigned int ext) { unsigned i; const uint64_t start_tsc = rte_rdtsc(); int32_t ret; + unsigned int keys_to_add; + if (!ext) + keys_to_add = KEYS_TO_ADD * ADD_PERCENT; + else + keys_to_add = KEYS_TO_ADD; - for (i = 0; i < KEYS_TO_ADD; i++) { + for (i = 0; i < keys_to_add; i++) { /* There are no delete functions with data, so just call two functions */ if (with_hash) ret = rte_hash_del_key_with_hash(h[table_index], @@ -442,7 +490,7 @@ timed_deletes(unsigned with_hash, unsigned with_data, unsigned table_index) if (ret >= 0) positions[i] = ret; else { - printf("Failed to add key number %u\n", ret); + printf("Failed to delete key number %u\n", i); return -1; } } @@ -450,7 +498,7 @@ timed_deletes(unsigned with_hash, unsigned with_data, unsigned table_index) const uint64_t end_tsc = rte_rdtsc(); const uint64_t time_taken = end_tsc - start_tsc; - cycles[table_index][DELETE][with_hash][with_data] = time_taken/KEYS_TO_ADD; + cycles[table_index][DELETE][with_hash][with_data] = time_taken/keys_to_add; return 0; } @@ -468,7 +516,8 @@ reset_table(unsigned table_index) } static int -run_all_tbl_perf_tests(unsigned int with_pushes, unsigned int with_locks) +run_all_tbl_perf_tests(unsigned int with_pushes, unsigned int with_locks, + unsigned int ext) { unsigned i, j, with_data, with_hash; @@ -477,25 +526,25 @@ run_all_tbl_perf_tests(unsigned int with_pushes, unsigned int with_locks) for (with_data = 0; with_data <= 1; with_data++) { for (i = 0; i < NUM_KEYSIZES; i++) { - if (create_table(with_data, i, with_locks) < 0) + if (create_table(with_data, i, with_locks, ext) < 0) return -1; - if (get_input_keys(with_pushes, i) < 0) + if (get_input_keys(with_pushes, i, ext) < 0) return -1; for (with_hash = 0; with_hash <= 1; with_hash++) { - if (timed_adds(with_hash, with_data, i) < 0) + if (timed_adds(with_hash, with_data, i, ext) < 0) return -1; for (j = 0; j < NUM_SHUFFLES; j++) - shuffle_input_keys(i); + shuffle_input_keys(i, ext); - if (timed_lookups(with_hash, with_data, i) < 0) + if (timed_lookups(with_hash, with_data, i, ext) < 0) return -1; - if (timed_lookups_multi(with_data, i) < 0) + if (timed_lookups_multi(with_data, i, ext) < 0) return -1; - if (timed_deletes(with_hash, with_data, i) < 0) + if (timed_deletes(with_hash, with_data, i, ext) < 0) return -1; /* Print a dot to show progress on operations */ @@ -631,10 +680,16 @@ test_hash_perf(void) printf("\nALL ELEMENTS IN PRIMARY LOCATION\n"); else printf("\nELEMENTS IN PRIMARY OR SECONDARY LOCATION\n"); - if (run_all_tbl_perf_tests(with_pushes, with_locks) < 0) + if (run_all_tbl_perf_tests(with_pushes, with_locks, 0) < 0) return -1; } } + + printf("\n EXTENDABLE BUCKETS PERFORMANCE\n"); + + if (run_all_tbl_perf_tests(1, 0, 1) < 0) + return -1; + if (fbk_hash_perf_test() < 0) return -1; diff --git a/test/test/test_hash_readwrite.c b/test/test/test_hash_readwrite.c index 55ae33d8..01f986cf 100644 --- a/test/test/test_hash_readwrite.c +++ b/test/test/test_hash_readwrite.c @@ -18,12 +18,14 @@ #define RTE_RWTEST_FAIL 0 -#define TOTAL_ENTRY (16*1024*1024) -#define TOTAL_INSERT (15*1024*1024) +#define TOTAL_ENTRY (5*1024*1024) +#define TOTAL_INSERT (4.5*1024*1024) +#define TOTAL_INSERT_EXT (5*1024*1024) #define NUM_TEST 3 unsigned int core_cnt[NUM_TEST] = {2, 4, 8}; +unsigned int slave_core_ids[RTE_MAX_LCORE]; struct perf { uint32_t single_read; uint32_t single_write; @@ -58,14 +60,19 @@ test_hash_readwrite_worker(__attribute__((unused)) void *arg) uint64_t i, offset; uint32_t lcore_id = rte_lcore_id(); uint64_t begin, cycles; - int ret; + int *ret; - offset = (lcore_id - rte_get_master_lcore()) - * tbl_rw_test_param.num_insert; + ret = rte_malloc(NULL, sizeof(int) * + tbl_rw_test_param.num_insert, 0); + for (i = 0; i < rte_lcore_count(); i++) { + if (slave_core_ids[i] == lcore_id) + break; + } + offset = tbl_rw_test_param.num_insert * i; printf("Core #%d inserting and reading %d: %'"PRId64" - %'"PRId64"\n", lcore_id, tbl_rw_test_param.num_insert, - offset, offset + tbl_rw_test_param.num_insert); + offset, offset + tbl_rw_test_param.num_insert - 1); begin = rte_rdtsc_precise(); @@ -75,13 +82,30 @@ test_hash_readwrite_worker(__attribute__((unused)) void *arg) tbl_rw_test_param.keys + i) > 0) break; - ret = rte_hash_add_key(tbl_rw_test_param.h, + ret[i - offset] = rte_hash_add_key(tbl_rw_test_param.h, tbl_rw_test_param.keys + i); - if (ret < 0) + if (ret[i - offset] < 0) + break; + + /* lookup a random key */ + uint32_t rand = rte_rand() % (i + 1 - offset); + + if (rte_hash_lookup(tbl_rw_test_param.h, + tbl_rw_test_param.keys + rand) != ret[rand]) + break; + + + if (rte_hash_del_key(tbl_rw_test_param.h, + tbl_rw_test_param.keys + rand) != ret[rand]) + break; + + ret[rand] = rte_hash_add_key(tbl_rw_test_param.h, + tbl_rw_test_param.keys + rand); + if (ret[rand] < 0) break; if (rte_hash_lookup(tbl_rw_test_param.h, - tbl_rw_test_param.keys + i) != ret) + tbl_rw_test_param.keys + rand) != ret[rand]) break; } @@ -92,11 +116,12 @@ test_hash_readwrite_worker(__attribute__((unused)) void *arg) for (; i < offset + tbl_rw_test_param.num_insert; i++) tbl_rw_test_param.keys[i] = RTE_RWTEST_FAIL; + rte_free(ret); return 0; } static int -init_params(int use_htm, int use_jhash) +init_params(int use_ext, int use_htm, int use_jhash) { unsigned int i; @@ -118,10 +143,19 @@ init_params(int use_htm, int use_jhash) if (use_htm) hash_params.extra_flag = RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT | - RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY; + RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY | + RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD; else hash_params.extra_flag = - RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY; + RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY | + RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD; + + if (use_ext) + hash_params.extra_flag |= + RTE_HASH_EXTRA_FLAGS_EXT_TABLE; + else + hash_params.extra_flag &= + ~RTE_HASH_EXTRA_FLAGS_EXT_TABLE; hash_params.name = "tests"; @@ -161,7 +195,7 @@ err: } static int -test_hash_readwrite_functional(int use_htm) +test_hash_readwrite_functional(int use_ext, int use_htm) { unsigned int i; const void *next_key; @@ -171,6 +205,8 @@ test_hash_readwrite_functional(int use_htm) uint32_t duplicated_keys = 0; uint32_t lost_keys = 0; int use_jhash = 1; + int slave_cnt = rte_lcore_count() - 1; + uint32_t tot_insert = 0; rte_atomic64_init(&gcycles); rte_atomic64_clear(&gcycles); @@ -178,21 +214,26 @@ test_hash_readwrite_functional(int use_htm) rte_atomic64_init(&ginsertions); rte_atomic64_clear(&ginsertions); - if (init_params(use_htm, use_jhash) != 0) + if (init_params(use_ext, use_htm, use_jhash) != 0) goto err; + if (use_ext) + tot_insert = TOTAL_INSERT_EXT; + else + tot_insert = TOTAL_INSERT; + tbl_rw_test_param.num_insert = - TOTAL_INSERT / rte_lcore_count(); + tot_insert / slave_cnt; tbl_rw_test_param.rounded_tot_insert = tbl_rw_test_param.num_insert - * rte_lcore_count(); + * slave_cnt; printf("++++++++Start function tests:+++++++++\n"); /* Fire all threads. */ rte_eal_mp_remote_launch(test_hash_readwrite_worker, - NULL, CALL_MASTER); + NULL, SKIP_MASTER); rte_eal_mp_wait_lcore(); while (rte_hash_iterate(tbl_rw_test_param.h, &next_key, @@ -249,7 +290,7 @@ err: } static int -test_rw_reader(__attribute__((unused)) void *arg) +test_rw_reader(void *arg) { uint64_t i; uint64_t begin, cycles; @@ -276,7 +317,7 @@ test_rw_reader(__attribute__((unused)) void *arg) } static int -test_rw_writer(__attribute__((unused)) void *arg) +test_rw_writer(void *arg) { uint64_t i; uint32_t lcore_id = rte_lcore_id(); @@ -285,8 +326,13 @@ test_rw_writer(__attribute__((unused)) void *arg) uint64_t start_coreid = (uint64_t)(uintptr_t)arg; uint64_t offset; - offset = TOTAL_INSERT / 2 + (lcore_id - start_coreid) - * tbl_rw_test_param.num_insert; + for (i = 0; i < rte_lcore_count(); i++) { + if (slave_core_ids[i] == lcore_id) + break; + } + + offset = TOTAL_INSERT / 2 + (i - (start_coreid)) * + tbl_rw_test_param.num_insert; begin = rte_rdtsc_precise(); for (i = offset; i < offset + tbl_rw_test_param.num_insert; i++) { ret = rte_hash_add_key_data(tbl_rw_test_param.h, @@ -333,7 +379,7 @@ test_hash_readwrite_perf(struct perf *perf_results, int use_htm, rte_atomic64_init(&gwrite_cycles); rte_atomic64_clear(&gwrite_cycles); - if (init_params(use_htm, use_jhash) != 0) + if (init_params(0, use_htm, use_jhash) != 0) goto err; /* @@ -384,8 +430,8 @@ test_hash_readwrite_perf(struct perf *perf_results, int use_htm, perf_results->single_read = end / i; for (n = 0; n < NUM_TEST; n++) { - unsigned int tot_lcore = rte_lcore_count(); - if (tot_lcore < core_cnt[n] * 2 + 1) + unsigned int tot_slave_lcore = rte_lcore_count() - 1; + if (tot_slave_lcore < core_cnt[n] * 2) goto finish; rte_atomic64_clear(&greads); @@ -415,17 +461,19 @@ test_hash_readwrite_perf(struct perf *perf_results, int use_htm, */ /* Test only reader cases */ - for (i = 1; i <= core_cnt[n]; i++) + for (i = 0; i < core_cnt[n]; i++) rte_eal_remote_launch(test_rw_reader, - (void *)(uintptr_t)read_cnt, i); + (void *)(uintptr_t)read_cnt, + slave_core_ids[i]); rte_eal_mp_wait_lcore(); start_coreid = i; /* Test only writer cases */ - for (; i <= core_cnt[n] * 2; i++) + for (; i < core_cnt[n] * 2; i++) rte_eal_remote_launch(test_rw_writer, - (void *)((uintptr_t)start_coreid), i); + (void *)((uintptr_t)start_coreid), + slave_core_ids[i]); rte_eal_mp_wait_lcore(); @@ -464,22 +512,26 @@ test_hash_readwrite_perf(struct perf *perf_results, int use_htm, } } - start_coreid = core_cnt[n] + 1; + start_coreid = core_cnt[n]; if (reader_faster) { - for (i = core_cnt[n] + 1; i <= core_cnt[n] * 2; i++) + for (i = core_cnt[n]; i < core_cnt[n] * 2; i++) rte_eal_remote_launch(test_rw_writer, - (void *)((uintptr_t)start_coreid), i); - for (i = 1; i <= core_cnt[n]; i++) + (void *)((uintptr_t)start_coreid), + slave_core_ids[i]); + for (i = 0; i < core_cnt[n]; i++) rte_eal_remote_launch(test_rw_reader, - (void *)(uintptr_t)read_cnt, i); + (void *)(uintptr_t)read_cnt, + slave_core_ids[i]); } else { - for (i = 1; i <= core_cnt[n]; i++) + for (i = 0; i < core_cnt[n]; i++) rte_eal_remote_launch(test_rw_reader, - (void *)(uintptr_t)read_cnt, i); - for (; i <= core_cnt[n] * 2; i++) + (void *)(uintptr_t)read_cnt, + slave_core_ids[i]); + for (; i < core_cnt[n] * 2; i++) rte_eal_remote_launch(test_rw_writer, - (void *)((uintptr_t)start_coreid), i); + (void *)((uintptr_t)start_coreid), + slave_core_ids[i]); } rte_eal_mp_wait_lcore(); @@ -561,14 +613,20 @@ test_hash_readwrite_main(void) * than writer threads. This is to timing either reader threads or * writer threads for performance numbers. */ - int use_htm, reader_faster; + int use_htm, use_ext, reader_faster; + unsigned int i = 0, core_id = 0; - if (rte_lcore_count() == 1) { - printf("More than one lcore is required " + if (rte_lcore_count() <= 2) { + printf("More than two lcores are required " "to do read write test\n"); return 0; } + RTE_LCORE_FOREACH_SLAVE(core_id) { + slave_core_ids[i] = core_id; + i++; + } + setlocale(LC_NUMERIC, ""); if (rte_tm_supported()) { @@ -578,7 +636,13 @@ test_hash_readwrite_main(void) printf("Test read-write with Hardware transactional memory\n"); use_htm = 1; - if (test_hash_readwrite_functional(use_htm) < 0) + use_ext = 0; + + if (test_hash_readwrite_functional(use_ext, use_htm) < 0) + return -1; + + use_ext = 1; + if (test_hash_readwrite_functional(use_ext, use_htm) < 0) return -1; reader_faster = 1; @@ -597,8 +661,14 @@ test_hash_readwrite_main(void) printf("Test read-write without Hardware transactional memory\n"); use_htm = 0; - if (test_hash_readwrite_functional(use_htm) < 0) + use_ext = 0; + if (test_hash_readwrite_functional(use_ext, use_htm) < 0) return -1; + + use_ext = 1; + if (test_hash_readwrite_functional(use_ext, use_htm) < 0) + return -1; + reader_faster = 1; if (test_hash_readwrite_perf(&non_htm_results, use_htm, reader_faster) < 0) @@ -610,8 +680,6 @@ test_hash_readwrite_main(void) printf("Results summary:\n"); - int i; - printf("single read: %u\n", htm_results.single_read); printf("single write: %u\n", htm_results.single_write); for (i = 0; i < NUM_TEST; i++) { diff --git a/test/test/test_hash_readwrite_lf.c b/test/test/test_hash_readwrite_lf.c new file mode 100644 index 00000000..cbfd9322 --- /dev/null +++ b/test/test/test_hash_readwrite_lf.c @@ -0,0 +1,1220 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Arm Limited + */ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "test.h" + +#ifndef RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF +#define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF 0 +#endif + +#define BULK_LOOKUP_SIZE 32 + +#define RUN_WITH_HTM_DISABLED 0 + +#if (RUN_WITH_HTM_DISABLED) + +#define TOTAL_ENTRY (5*1024) +#define TOTAL_INSERT (5*1024) + +#else + +#define TOTAL_ENTRY (4*1024*1024) +#define TOTAL_INSERT (4*1024*1024) + +#endif + +#define READ_FAIL 1 +#define READ_PASS_NO_KEY_SHIFTS 2 +#define READ_PASS_SHIFT_PATH 4 +#define READ_PASS_NON_SHIFT_PATH 8 +#define BULK_LOOKUP 16 +#define NUM_TEST 3 +unsigned int rwc_core_cnt[NUM_TEST] = {1, 2, 4}; + +struct rwc_perf { + uint32_t w_no_ks_r_hit[2][NUM_TEST]; + uint32_t w_no_ks_r_miss[2][NUM_TEST]; + uint32_t w_ks_r_hit_nsp[2][NUM_TEST]; + uint32_t w_ks_r_hit_sp[2][NUM_TEST]; + uint32_t w_ks_r_miss[2][NUM_TEST]; + uint32_t multi_rw[NUM_TEST - 1][2][NUM_TEST]; +}; + +static struct rwc_perf rwc_lf_results, rwc_non_lf_results; + +struct { + uint32_t *keys; + uint32_t *keys_no_ks; + uint32_t *keys_ks; + uint32_t *keys_absent; + uint32_t *keys_shift_path; + uint32_t *keys_non_shift_path; + uint32_t count_keys_no_ks; + uint32_t count_keys_ks; + uint32_t count_keys_absent; + uint32_t count_keys_shift_path; + uint32_t count_keys_non_shift_path; + uint32_t single_insert; + struct rte_hash *h; +} tbl_rwc_test_param; + +static rte_atomic64_t gread_cycles; +static rte_atomic64_t greads; + +static volatile uint8_t writer_done; +static volatile uint8_t multi_writer_done[4]; + +uint16_t enabled_core_ids[RTE_MAX_LCORE]; + +uint8_t *scanned_bkts; + +static inline int +get_enabled_cores_list(void) +{ + uint32_t i = 0; + uint16_t core_id; + uint32_t max_cores = rte_lcore_count(); + for (core_id = 0; core_id < RTE_MAX_LCORE && i < max_cores; core_id++) { + if (rte_lcore_is_enabled(core_id)) { + enabled_core_ids[i] = core_id; + i++; + } + } + + if (i != max_cores) { + printf("Number of enabled cores in list is different from " + "number given by rte_lcore_count()\n"); + return -1; + } + return 0; +} + +static inline int +check_bucket(uint32_t bkt_idx, uint32_t key) +{ + uint32_t iter; + uint32_t prev_iter; + uint32_t diff; + uint32_t count = 0; + const void *next_key; + void *next_data; + + /* Temporary bucket to hold the keys */ + uint32_t keys_in_bkt[8]; + + iter = bkt_idx * 8; + prev_iter = iter; + while (rte_hash_iterate(tbl_rwc_test_param.h, + &next_key, &next_data, &iter) >= 0) { + + /* Check for duplicate entries */ + if (*(const uint32_t *)next_key == key) + return 1; + + /* Identify if there is any free entry in the bucket */ + diff = iter - prev_iter; + if (diff > 1) + break; + + prev_iter = iter; + keys_in_bkt[count] = *(const uint32_t *)next_key; + count++; + + /* All entries in the bucket are occupied */ + if (count == 8) { + + /* + * Check if bucket was not scanned before, to avoid + * duplicate keys. + */ + if (scanned_bkts[bkt_idx] == 0) { + /* + * Since this bucket (pointed to by bkt_idx) is + * full, it is likely that key(s) in this + * bucket will be on the shift path, when + * collision occurs. Thus, add it to + * keys_shift_path. + */ + memcpy(tbl_rwc_test_param.keys_shift_path + + tbl_rwc_test_param.count_keys_shift_path + , keys_in_bkt, 32); + tbl_rwc_test_param.count_keys_shift_path += 8; + scanned_bkts[bkt_idx] = 1; + } + return -1; + } + } + return 0; +} + +static int +generate_keys(void) +{ + uint32_t *keys = NULL; + uint32_t *keys_no_ks = NULL; + uint32_t *keys_ks = NULL; + uint32_t *keys_absent = NULL; + uint32_t *keys_non_shift_path = NULL; + uint32_t *found = NULL; + uint32_t count_keys_no_ks = 0; + uint32_t count_keys_ks = 0; + uint32_t i; + + /* + * keys will consist of a) keys whose addition to the hash table + * will result in shifting of the existing keys to their alternate + * locations b) keys whose addition to the hash table will not result + * in shifting of the existing keys. + */ + keys = rte_malloc(NULL, sizeof(uint32_t) * TOTAL_INSERT, 0); + if (keys == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + /* + * keys_no_ks (no key-shifts): Subset of 'keys' - consists of keys that + * will NOT result in shifting of the existing keys to their alternate + * locations. Roughly around 900K keys. + */ + keys_no_ks = rte_malloc(NULL, sizeof(uint32_t) * TOTAL_INSERT, 0); + if (keys_no_ks == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + /* + * keys_ks (key-shifts): Subset of 'keys' - consists of keys that will + * result in shifting of the existing keys to their alternate locations. + * Roughly around 146K keys. There might be repeating keys. More code is + * required to filter out these keys which will complicate the test case + */ + keys_ks = rte_malloc(NULL, sizeof(uint32_t) * TOTAL_INSERT, 0); + if (keys_ks == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + /* Used to identify keys not inserted in the hash table */ + found = rte_zmalloc(NULL, sizeof(uint32_t) * TOTAL_INSERT, 0); + if (found == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + /* + * This consist of keys not inserted to the hash table. + * Used to test perf of lookup on keys that do not exist in the table. + */ + keys_absent = rte_malloc(NULL, sizeof(uint32_t) * TOTAL_INSERT, 0); + if (keys_absent == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + /* + * This consist of keys which are likely to be on the shift + * path (i.e. being moved to alternate location), when collision occurs + * on addition of a key to an already full primary bucket. + * Used to test perf of lookup on keys that are on the shift path. + */ + tbl_rwc_test_param.keys_shift_path = rte_malloc(NULL, sizeof(uint32_t) * + TOTAL_INSERT, 0); + if (tbl_rwc_test_param.keys_shift_path == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + /* + * This consist of keys which are never on the shift + * path (i.e. being moved to alternate location), when collision occurs + * on addition of a key to an already full primary bucket. + * Used to test perf of lookup on keys that are not on the shift path. + */ + keys_non_shift_path = rte_malloc(NULL, sizeof(uint32_t) * TOTAL_INSERT, + 0); + if (keys_non_shift_path == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + + hash_sig_t sig; + uint32_t prim_bucket_idx; + int ret; + uint32_t num_buckets; + uint32_t bucket_bitmask; + num_buckets = rte_align32pow2(TOTAL_ENTRY) / 8; + bucket_bitmask = num_buckets - 1; + + /* + * Used to mark bkts in which at least one key was shifted to its + * alternate location + */ + scanned_bkts = rte_malloc(NULL, sizeof(uint8_t) * num_buckets, 0); + if (scanned_bkts == NULL) { + printf("RTE_MALLOC failed\n"); + goto err; + } + + tbl_rwc_test_param.keys = keys; + tbl_rwc_test_param.keys_no_ks = keys_no_ks; + tbl_rwc_test_param.keys_ks = keys_ks; + tbl_rwc_test_param.keys_absent = keys_absent; + tbl_rwc_test_param.keys_non_shift_path = keys_non_shift_path; + /* Generate keys by adding previous two keys, neglect overflow */ + printf("Generating keys...\n"); + keys[0] = 0; + keys[1] = 1; + for (i = 2; i < TOTAL_INSERT; i++) + keys[i] = keys[i-1] + keys[i-2]; + + /* Segregate keys into keys_no_ks and keys_ks */ + for (i = 0; i < TOTAL_INSERT; i++) { + /* Check if primary bucket has space.*/ + sig = rte_hash_hash(tbl_rwc_test_param.h, + tbl_rwc_test_param.keys+i); + prim_bucket_idx = sig & bucket_bitmask; + ret = check_bucket(prim_bucket_idx, keys[i]); + if (ret < 0) { + /* + * Primary bucket is full, this key will result in + * shifting of the keys to their alternate locations. + */ + keys_ks[count_keys_ks] = keys[i]; + count_keys_ks++; + } else if (ret == 0) { + /* + * Primary bucket has space, this key will not result in + * shifting of the keys. Hence, add key to the table. + */ + ret = rte_hash_add_key_data(tbl_rwc_test_param.h, + keys+i, + (void *)((uintptr_t)i)); + if (ret < 0) { + printf("writer failed %"PRIu32"\n", i); + break; + } + keys_no_ks[count_keys_no_ks] = keys[i]; + count_keys_no_ks++; + } + } + + for (i = 0; i < count_keys_no_ks; i++) { + /* + * Identify keys in keys_no_ks with value less than + * 4M (HTM enabled) OR 5K (HTM disabled) + */ + if (keys_no_ks[i] < TOTAL_INSERT) + found[keys_no_ks[i]]++; + } + + for (i = 0; i < count_keys_ks; i++) { + /* + * Identify keys in keys_ks with value less than + * 4M (HTM enabled) OR 5K (HTM disabled) + */ + if (keys_ks[i] < TOTAL_INSERT) + found[keys_ks[i]]++; + } + + uint32_t count_keys_absent = 0; + for (i = 0; i < TOTAL_INSERT; i++) { + /* + * Identify missing keys between 0 and + * 4M (HTM enabled) OR 5K (HTM disabled) + */ + if (found[i] == 0) + keys_absent[count_keys_absent++] = i; + } + + /* Find keys that will not be on the shift path */ + uint32_t iter; + const void *next_key; + void *next_data; + uint32_t count = 0; + for (i = 0; i < num_buckets; i++) { + /* Check bucket for no keys shifted to alternate locations */ + if (scanned_bkts[i] == 0) { + iter = i * 8; + while (rte_hash_iterate(tbl_rwc_test_param.h, + &next_key, &next_data, &iter) >= 0) { + + /* Check if key belongs to the current bucket */ + if (i >= (iter-1)/8) + keys_non_shift_path[count++] + = *(const uint32_t *)next_key; + else + break; + } + } + } + + tbl_rwc_test_param.count_keys_no_ks = count_keys_no_ks; + tbl_rwc_test_param.count_keys_ks = count_keys_ks; + tbl_rwc_test_param.count_keys_absent = count_keys_absent; + tbl_rwc_test_param.count_keys_non_shift_path = count; + + printf("\nCount of keys NOT causing shifting of existing keys to " + "alternate location: %d\n", tbl_rwc_test_param.count_keys_no_ks); + printf("\nCount of keys causing shifting of existing keys to alternate " + "locations: %d\n\n", tbl_rwc_test_param.count_keys_ks); + printf("Count of absent keys that will never be added to the hash " + "table: %d\n\n", tbl_rwc_test_param.count_keys_absent); + printf("Count of keys likely to be on the shift path: %d\n\n", + tbl_rwc_test_param.count_keys_shift_path); + printf("Count of keys not likely to be on the shift path: %d\n\n", + tbl_rwc_test_param.count_keys_non_shift_path); + + rte_free(found); + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_free(keys); + rte_free(keys_no_ks); + rte_free(keys_ks); + rte_free(keys_absent); + rte_free(found); + rte_free(tbl_rwc_test_param.keys_shift_path); + rte_free(scanned_bkts); + return -1; +} + +static int +init_params(int rwc_lf, int use_jhash, int htm) +{ + struct rte_hash *handle; + + struct rte_hash_parameters hash_params = { + .entries = TOTAL_ENTRY, + .key_len = sizeof(uint32_t), + .hash_func_init_val = 0, + .socket_id = rte_socket_id(), + }; + + if (use_jhash) + hash_params.hash_func = rte_jhash; + else + hash_params.hash_func = rte_hash_crc; + + if (rwc_lf) + hash_params.extra_flag = + RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF | + RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD; + else if (htm) + hash_params.extra_flag = + RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT | + RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY | + RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD; + else + hash_params.extra_flag = + RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY | + RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD; + + hash_params.name = "tests"; + + handle = rte_hash_create(&hash_params); + if (handle == NULL) { + printf("hash creation failed"); + return -1; + } + + tbl_rwc_test_param.h = handle; + return 0; +} + +static int +test_rwc_reader(__attribute__((unused)) void *arg) +{ + uint32_t i, j; + int ret; + uint64_t begin, cycles; + uint32_t loop_cnt = 0; + uint8_t read_type = (uint8_t)((uintptr_t)arg); + uint32_t read_cnt; + uint32_t *keys; + uint32_t extra_keys; + int32_t *pos; + void *temp_a[BULK_LOOKUP_SIZE]; + + /* Used to identify keys not inserted in the hash table */ + pos = rte_zmalloc(NULL, sizeof(uint32_t) * BULK_LOOKUP_SIZE, 0); + if (pos == NULL) { + printf("RTE_MALLOC failed\n"); + return -1; + } + + if (read_type & READ_FAIL) { + keys = tbl_rwc_test_param.keys_absent; + read_cnt = tbl_rwc_test_param.count_keys_absent; + } else if (read_type & READ_PASS_NO_KEY_SHIFTS) { + keys = tbl_rwc_test_param.keys_no_ks; + read_cnt = tbl_rwc_test_param.count_keys_no_ks; + } else if (read_type & READ_PASS_SHIFT_PATH) { + keys = tbl_rwc_test_param.keys_shift_path; + read_cnt = tbl_rwc_test_param.count_keys_shift_path; + } else { + keys = tbl_rwc_test_param.keys_non_shift_path; + read_cnt = tbl_rwc_test_param.count_keys_non_shift_path; + } + + extra_keys = read_cnt & (BULK_LOOKUP_SIZE - 1); + + begin = rte_rdtsc_precise(); + do { + if (read_type & BULK_LOOKUP) { + for (i = 0; i < (read_cnt - extra_keys); + i += BULK_LOOKUP_SIZE) { + /* Array of pointer to the list of keys */ + for (j = 0; j < BULK_LOOKUP_SIZE; j++) + temp_a[j] = keys + i + j; + + rte_hash_lookup_bulk(tbl_rwc_test_param.h, + (const void **) + ((uintptr_t)temp_a), + BULK_LOOKUP_SIZE, pos); + /* Validate lookup result */ + for (j = 0; j < BULK_LOOKUP_SIZE; j++) + if ((read_type & READ_FAIL && + pos[j] != -ENOENT) || + (!(read_type & READ_FAIL) && + pos[j] == -ENOENT)) { + printf("lookup failed!" + "%"PRIu32"\n", + keys[i + j]); + return -1; + } + } + for (j = 0; j < extra_keys; j++) + temp_a[j] = keys + i + j; + + rte_hash_lookup_bulk(tbl_rwc_test_param.h, + (const void **) + ((uintptr_t)temp_a), + extra_keys, pos); + for (j = 0; j < extra_keys; j++) + if ((read_type & READ_FAIL && + pos[j] != -ENOENT) || + (!(read_type & READ_FAIL) && + pos[j] == -ENOENT)) { + printf("lookup failed! %"PRIu32"\n", + keys[i + j]); + return -1; + } + } else { + for (i = 0; i < read_cnt; i++) { + ret = rte_hash_lookup + (tbl_rwc_test_param.h, keys + i); + if (((read_type & READ_FAIL) && + (ret != -ENOENT)) || + (!(read_type & READ_FAIL) && + ret == -ENOENT)) { + printf("lookup failed! %"PRIu32"\n", + keys[i]); + return -1; + } + } + } + loop_cnt++; + } while (!writer_done); + + cycles = rte_rdtsc_precise() - begin; + rte_atomic64_add(&gread_cycles, cycles); + rte_atomic64_add(&greads, read_cnt*loop_cnt); + return 0; +} + +static int +write_keys(uint8_t key_shift) +{ + uint32_t i; + int ret; + uint32_t key_cnt; + uint32_t *keys; + if (key_shift) { + key_cnt = tbl_rwc_test_param.count_keys_ks; + keys = tbl_rwc_test_param.keys_ks; + } else { + key_cnt = tbl_rwc_test_param.count_keys_no_ks; + keys = tbl_rwc_test_param.keys_no_ks; + } + for (i = 0; i < key_cnt; i++) { + ret = rte_hash_add_key(tbl_rwc_test_param.h, keys + i); + if (!key_shift && ret < 0) { + printf("writer failed %"PRIu32"\n", i); + return -1; + } + } + return 0; +} + +static int +test_rwc_multi_writer(__attribute__((unused)) void *arg) +{ + uint32_t i, offset; + uint32_t pos_core = (uint32_t)((uintptr_t)arg); + offset = pos_core * tbl_rwc_test_param.single_insert; + for (i = offset; i < offset + tbl_rwc_test_param.single_insert; i++) + rte_hash_add_key(tbl_rwc_test_param.h, + tbl_rwc_test_param.keys_ks + i); + multi_writer_done[pos_core] = 1; + return 0; +} + +/* + * Test lookup perf: + * Reader(s) lookup keys present in the table. + */ +static int +test_hash_add_no_ks_lookup_hit(struct rwc_perf *rwc_perf_results, int rwc_lf, + int htm) +{ + unsigned int n, m; + uint64_t i; + int use_jhash = 0; + uint8_t key_shift = 0; + uint8_t read_type = READ_PASS_NO_KEY_SHIFTS; + + rte_atomic64_init(&greads); + rte_atomic64_init(&gread_cycles); + + if (init_params(rwc_lf, use_jhash, htm) != 0) + goto err; + printf("\nTest: Hash add - no key-shifts, read - hit\n"); + for (m = 0; m < 2; m++) { + if (m == 1) { + printf("\n** With bulk-lookup **\n"); + read_type |= BULK_LOOKUP; + } + for (n = 0; n < NUM_TEST; n++) { + unsigned int tot_lcore = rte_lcore_count(); + if (tot_lcore < rwc_core_cnt[n] + 1) + goto finish; + + printf("\nNumber of readers: %u\n", rwc_core_cnt[n]); + + rte_atomic64_clear(&greads); + rte_atomic64_clear(&gread_cycles); + + rte_hash_reset(tbl_rwc_test_param.h); + writer_done = 0; + if (write_keys(key_shift) < 0) + goto err; + writer_done = 1; + for (i = 1; i <= rwc_core_cnt[n]; i++) + rte_eal_remote_launch(test_rwc_reader, + (void *)(uintptr_t)read_type, + enabled_core_ids[i]); + rte_eal_mp_wait_lcore(); + + for (i = 1; i <= rwc_core_cnt[n]; i++) + if (lcore_config[i].ret < 0) + goto err; + + unsigned long long cycles_per_lookup = + rte_atomic64_read(&gread_cycles) / + rte_atomic64_read(&greads); + rwc_perf_results->w_no_ks_r_hit[m][n] + = cycles_per_lookup; + printf("Cycles per lookup: %llu\n", cycles_per_lookup); + } + } + +finish: + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_hash_free(tbl_rwc_test_param.h); + return -1; +} + +/* + * Test lookup perf: + * Reader(s) lookup keys absent in the table while + * 'Main' thread adds with no key-shifts. + */ +static int +test_hash_add_no_ks_lookup_miss(struct rwc_perf *rwc_perf_results, int rwc_lf, + int htm) +{ + unsigned int n, m; + uint64_t i; + int use_jhash = 0; + uint8_t key_shift = 0; + uint8_t read_type = READ_FAIL; + int ret; + + rte_atomic64_init(&greads); + rte_atomic64_init(&gread_cycles); + + if (init_params(rwc_lf, use_jhash, htm) != 0) + goto err; + printf("\nTest: Hash add - no key-shifts, Hash lookup - miss\n"); + for (m = 0; m < 2; m++) { + if (m == 1) { + printf("\n** With bulk-lookup **\n"); + read_type |= BULK_LOOKUP; + } + for (n = 0; n < NUM_TEST; n++) { + unsigned int tot_lcore = rte_lcore_count(); + if (tot_lcore < rwc_core_cnt[n] + 1) + goto finish; + + printf("\nNumber of readers: %u\n", rwc_core_cnt[n]); + + rte_atomic64_clear(&greads); + rte_atomic64_clear(&gread_cycles); + + rte_hash_reset(tbl_rwc_test_param.h); + writer_done = 0; + + for (i = 1; i <= rwc_core_cnt[n]; i++) + rte_eal_remote_launch(test_rwc_reader, + (void *)(uintptr_t)read_type, + enabled_core_ids[i]); + ret = write_keys(key_shift); + writer_done = 1; + rte_eal_mp_wait_lcore(); + + if (ret < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + if (lcore_config[i].ret < 0) + goto err; + + unsigned long long cycles_per_lookup = + rte_atomic64_read(&gread_cycles) / + rte_atomic64_read(&greads); + rwc_perf_results->w_no_ks_r_miss[m][n] + = cycles_per_lookup; + printf("Cycles per lookup: %llu\n", cycles_per_lookup); + } + } + +finish: + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_hash_free(tbl_rwc_test_param.h); + return -1; +} + +/* + * Test lookup perf: + * Reader(s) lookup keys present in the table and not likely to be on the + * shift path while 'Main' thread adds keys causing key-shifts. + */ +static int +test_hash_add_ks_lookup_hit_non_sp(struct rwc_perf *rwc_perf_results, + int rwc_lf, int htm) +{ + unsigned int n, m; + uint64_t i; + int use_jhash = 0; + int ret; + uint8_t key_shift; + uint8_t read_type = READ_PASS_NON_SHIFT_PATH; + + rte_atomic64_init(&greads); + rte_atomic64_init(&gread_cycles); + + if (init_params(rwc_lf, use_jhash, htm) != 0) + goto err; + printf("\nTest: Hash add - key shift, Hash lookup - hit" + " (non-shift-path)\n"); + for (m = 0; m < 2; m++) { + if (m == 1) { + printf("\n** With bulk-lookup **\n"); + read_type |= BULK_LOOKUP; + } + for (n = 0; n < NUM_TEST; n++) { + unsigned int tot_lcore = rte_lcore_count(); + if (tot_lcore < rwc_core_cnt[n] + 1) + goto finish; + + printf("\nNumber of readers: %u\n", rwc_core_cnt[n]); + + rte_atomic64_clear(&greads); + rte_atomic64_clear(&gread_cycles); + + rte_hash_reset(tbl_rwc_test_param.h); + writer_done = 0; + key_shift = 0; + if (write_keys(key_shift) < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + rte_eal_remote_launch(test_rwc_reader, + (void *)(uintptr_t)read_type, + enabled_core_ids[i]); + key_shift = 1; + ret = write_keys(key_shift); + writer_done = 1; + rte_eal_mp_wait_lcore(); + + if (ret < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + if (lcore_config[i].ret < 0) + goto err; + + unsigned long long cycles_per_lookup = + rte_atomic64_read(&gread_cycles) / + rte_atomic64_read(&greads); + rwc_perf_results->w_ks_r_hit_nsp[m][n] + = cycles_per_lookup; + printf("Cycles per lookup: %llu\n", cycles_per_lookup); + } + } + +finish: + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_hash_free(tbl_rwc_test_param.h); + return -1; +} + +/* + * Test lookup perf: + * Reader(s) lookup keys present in the table and likely on the shift-path while + * 'Main' thread adds keys causing key-shifts. + */ +static int +test_hash_add_ks_lookup_hit_sp(struct rwc_perf *rwc_perf_results, int rwc_lf, + int htm) +{ + unsigned int n, m; + uint64_t i; + int use_jhash = 0; + int ret; + uint8_t key_shift; + uint8_t read_type = READ_PASS_SHIFT_PATH; + + rte_atomic64_init(&greads); + rte_atomic64_init(&gread_cycles); + + if (init_params(rwc_lf, use_jhash, htm) != 0) + goto err; + printf("\nTest: Hash add - key shift, Hash lookup - hit (shift-path)" + "\n"); + + for (m = 0; m < 2; m++) { + if (m == 1) { + printf("\n** With bulk-lookup **\n"); + read_type |= BULK_LOOKUP; + } + for (n = 0; n < NUM_TEST; n++) { + unsigned int tot_lcore = rte_lcore_count(); + if (tot_lcore < rwc_core_cnt[n]) + goto finish; + + printf("\nNumber of readers: %u\n", rwc_core_cnt[n]); + rte_atomic64_clear(&greads); + rte_atomic64_clear(&gread_cycles); + + rte_hash_reset(tbl_rwc_test_param.h); + writer_done = 0; + key_shift = 0; + if (write_keys(key_shift) < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + rte_eal_remote_launch(test_rwc_reader, + (void *)(uintptr_t)read_type, + enabled_core_ids[i]); + key_shift = 1; + ret = write_keys(key_shift); + writer_done = 1; + rte_eal_mp_wait_lcore(); + + if (ret < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + if (lcore_config[i].ret < 0) + goto err; + + unsigned long long cycles_per_lookup = + rte_atomic64_read(&gread_cycles) / + rte_atomic64_read(&greads); + rwc_perf_results->w_ks_r_hit_sp[m][n] + = cycles_per_lookup; + printf("Cycles per lookup: %llu\n", cycles_per_lookup); + } + } + +finish: + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_hash_free(tbl_rwc_test_param.h); + return -1; +} + +/* + * Test lookup perf: + * Reader(s) lookup keys absent in the table while + * 'Main' thread adds keys causing key-shifts. + */ +static int +test_hash_add_ks_lookup_miss(struct rwc_perf *rwc_perf_results, int rwc_lf, int + htm) +{ + unsigned int n, m; + uint64_t i; + int use_jhash = 0; + int ret; + uint8_t key_shift; + uint8_t read_type = READ_FAIL; + + rte_atomic64_init(&greads); + rte_atomic64_init(&gread_cycles); + + if (init_params(rwc_lf, use_jhash, htm) != 0) + goto err; + printf("\nTest: Hash add - key shift, Hash lookup - miss\n"); + for (m = 0; m < 2; m++) { + if (m == 1) { + printf("\n** With bulk-lookup **\n"); + read_type |= BULK_LOOKUP; + } + for (n = 0; n < NUM_TEST; n++) { + unsigned int tot_lcore = rte_lcore_count(); + if (tot_lcore < rwc_core_cnt[n] + 1) + goto finish; + + printf("\nNumber of readers: %u\n", rwc_core_cnt[n]); + + rte_atomic64_clear(&greads); + rte_atomic64_clear(&gread_cycles); + + rte_hash_reset(tbl_rwc_test_param.h); + writer_done = 0; + key_shift = 0; + if (write_keys(key_shift) < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + rte_eal_remote_launch(test_rwc_reader, + (void *)(uintptr_t)read_type, + enabled_core_ids[i]); + key_shift = 1; + ret = write_keys(key_shift); + writer_done = 1; + rte_eal_mp_wait_lcore(); + + if (ret < 0) + goto err; + for (i = 1; i <= rwc_core_cnt[n]; i++) + if (lcore_config[i].ret < 0) + goto err; + + unsigned long long cycles_per_lookup = + rte_atomic64_read(&gread_cycles) / + rte_atomic64_read(&greads); + rwc_perf_results->w_ks_r_miss[m][n] = cycles_per_lookup; + printf("Cycles per lookup: %llu\n", cycles_per_lookup); + } + } + +finish: + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_hash_free(tbl_rwc_test_param.h); + return -1; +} + +/* + * Test lookup perf for multi-writer: + * Reader(s) lookup keys present in the table and likely on the shift-path while + * Writers add keys causing key-shiftsi. + * Writers are running in parallel, on different data plane cores. + */ +static int +test_hash_multi_add_lookup(struct rwc_perf *rwc_perf_results, int rwc_lf, + int htm) +{ + unsigned int n, m, k; + uint64_t i; + int use_jhash = 0; + uint8_t key_shift; + uint8_t read_type = READ_PASS_SHIFT_PATH; + + rte_atomic64_init(&greads); + rte_atomic64_init(&gread_cycles); + + if (init_params(rwc_lf, use_jhash, htm) != 0) + goto err; + printf("\nTest: Multi-add-lookup\n"); + uint8_t pos_core; + for (m = 1; m < NUM_TEST; m++) { + /* Calculate keys added by each writer */ + tbl_rwc_test_param.single_insert = + tbl_rwc_test_param.count_keys_ks / rwc_core_cnt[m]; + for (k = 0; k < 2; k++) { + if (k == 1) { + printf("\n** With bulk-lookup **\n"); + read_type |= BULK_LOOKUP; + } + for (n = 0; n < NUM_TEST; n++) { + unsigned int tot_lcore = rte_lcore_count(); + if (tot_lcore < (rwc_core_cnt[n] + + rwc_core_cnt[m] + 1)) + goto finish; + + printf("\nNumber of writers: %u", + rwc_core_cnt[m]); + printf("\nNumber of readers: %u\n", + rwc_core_cnt[n]); + + rte_atomic64_clear(&greads); + rte_atomic64_clear(&gread_cycles); + + rte_hash_reset(tbl_rwc_test_param.h); + writer_done = 0; + for (i = 0; i < 4; i++) + multi_writer_done[i] = 0; + key_shift = 0; + if (write_keys(key_shift) < 0) + goto err; + + /* Launch reader(s) */ + for (i = 1; i <= rwc_core_cnt[n]; i++) + rte_eal_remote_launch(test_rwc_reader, + (void *)(uintptr_t)read_type, + enabled_core_ids[i]); + key_shift = 1; + pos_core = 0; + + /* Launch writers */ + for (; i <= rwc_core_cnt[m] + + rwc_core_cnt[n]; i++) { + rte_eal_remote_launch + (test_rwc_multi_writer, + (void *)(uintptr_t)pos_core, + enabled_core_ids[i]); + pos_core++; + } + + /* Wait for writers to complete */ + for (i = 0; i < rwc_core_cnt[m]; i++) + while + (multi_writer_done[i] == 0); + writer_done = 1; + + rte_eal_mp_wait_lcore(); + + for (i = 1; i <= rwc_core_cnt[n]; i++) + if (lcore_config[i].ret < 0) + goto err; + + unsigned long long cycles_per_lookup = + rte_atomic64_read(&gread_cycles) + / rte_atomic64_read(&greads); + rwc_perf_results->multi_rw[m][k][n] + = cycles_per_lookup; + printf("Cycles per lookup: %llu\n", + cycles_per_lookup); + } + } + } + +finish: + rte_hash_free(tbl_rwc_test_param.h); + return 0; + +err: + rte_hash_free(tbl_rwc_test_param.h); + return -1; +} + +static int +test_hash_readwrite_lf_main(void) +{ + /* + * Variables used to choose different tests. + * rwc_lf indicates if read-write concurrency lock-free support is + * enabled. + * htm indicates if Hardware transactional memory support is enabled. + */ + int rwc_lf = 0; + int htm; + int use_jhash = 0; + if (rte_lcore_count() == 1) { + printf("More than one lcore is required " + "to do read write lock-free concurrency test\n"); + return -1; + } + + setlocale(LC_NUMERIC, ""); + + if (rte_tm_supported()) + htm = 1; + else + htm = 0; + + if (init_params(rwc_lf, use_jhash, htm) != 0) + return -1; + if (generate_keys() != 0) + return -1; + if (get_enabled_cores_list() != 0) + return -1; + + if (RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF) { + rwc_lf = 1; + printf("Test lookup with read-write concurrency lock free support" + " enabled\n"); + if (test_hash_add_no_ks_lookup_hit(&rwc_lf_results, rwc_lf, + htm) < 0) + return -1; + if (test_hash_add_no_ks_lookup_miss(&rwc_lf_results, rwc_lf, + htm) < 0) + return -1; + if (test_hash_add_ks_lookup_hit_non_sp(&rwc_lf_results, rwc_lf, + htm) < 0) + return -1; + if (test_hash_add_ks_lookup_hit_sp(&rwc_lf_results, rwc_lf, + htm) < 0) + return -1; + if (test_hash_add_ks_lookup_miss(&rwc_lf_results, rwc_lf, htm) + < 0) + return -1; + if (test_hash_multi_add_lookup(&rwc_lf_results, rwc_lf, htm) + < 0) + return -1; + } + printf("\nTest lookup with read-write concurrency lock free support" + " disabled\n"); + rwc_lf = 0; + if (!htm) { + printf("With HTM Disabled\n"); + if (!RUN_WITH_HTM_DISABLED) { + printf("Enable RUN_WITH_HTM_DISABLED to test with" + " lock-free disabled"); + goto results; + } + } else + printf("With HTM Enabled\n"); + if (test_hash_add_no_ks_lookup_hit(&rwc_non_lf_results, rwc_lf, htm) + < 0) + return -1; + if (test_hash_add_no_ks_lookup_miss(&rwc_non_lf_results, rwc_lf, htm) + < 0) + return -1; + if (test_hash_add_ks_lookup_hit_non_sp(&rwc_non_lf_results, rwc_lf, + htm) < 0) + return -1; + if (test_hash_add_ks_lookup_hit_sp(&rwc_non_lf_results, rwc_lf, htm) + < 0) + return -1; + if (test_hash_add_ks_lookup_miss(&rwc_non_lf_results, rwc_lf, htm) < 0) + return -1; + if (test_hash_multi_add_lookup(&rwc_non_lf_results, rwc_lf, htm) < 0) + return -1; +results: + printf("\n\t\t\t\t\t\t********** Results summary **********\n\n"); + int i, j, k; + for (j = 0; j < 2; j++) { + if (j == 1) + printf("\n\t\t\t\t\t#######********** Bulk Lookup " + "**********#######\n\n"); + printf("_______\t\t_______\t\t_________\t___\t\t_________\t\t" + "\t\t\t\t_________________\n"); + printf("Writers\t\tReaders\t\tLock-free\tHTM\t\tTest-case\t\t\t" + "\t\t\tCycles per lookup\n"); + printf("_______\t\t_______\t\t_________\t___\t\t_________\t\t\t" + "\t\t\t_________________\n"); + for (i = 0; i < NUM_TEST; i++) { + printf("%u\t\t%u\t\t", 1, rwc_core_cnt[i]); + printf("Enabled\t\t"); + printf("N/A\t\t"); + printf("Hash add - no key-shifts, lookup - hit\t\t\t\t" + "%u\n\t\t\t\t\t\t\t\t", + rwc_lf_results.w_no_ks_r_hit[j][i]); + printf("Hash add - no key-shifts, lookup - miss\t\t\t\t" + "%u\n\t\t\t\t\t\t\t\t", + rwc_lf_results.w_no_ks_r_miss[j][i]); + printf("Hash add - key-shifts, lookup - hit" + "(non-shift-path)\t\t%u\n\t\t\t\t\t\t\t\t", + rwc_lf_results.w_ks_r_hit_nsp[j][i]); + printf("Hash add - key-shifts, lookup - hit " + "(shift-path)\t\t%u\n\t\t\t\t\t\t\t\t", + rwc_lf_results.w_ks_r_hit_sp[j][i]); + printf("Hash add - key-shifts, Hash lookup miss\t\t\t\t" + "%u\n\n\t\t\t\t", + rwc_lf_results.w_ks_r_miss[j][i]); + + printf("Disabled\t"); + if (htm) + printf("Enabled\t\t"); + else + printf("Disabled\t"); + printf("Hash add - no key-shifts, lookup - hit\t\t\t\t" + "%u\n\t\t\t\t\t\t\t\t", + rwc_non_lf_results.w_no_ks_r_hit[j][i]); + printf("Hash add - no key-shifts, lookup - miss\t\t\t\t" + "%u\n\t\t\t\t\t\t\t\t", + rwc_non_lf_results.w_no_ks_r_miss[j][i]); + printf("Hash add - key-shifts, lookup - hit " + "(non-shift-path)\t\t%u\n\t\t\t\t\t\t\t\t", + rwc_non_lf_results.w_ks_r_hit_nsp[j][i]); + printf("Hash add - key-shifts, lookup - hit " + "(shift-path)\t\t%u\n\t\t\t\t\t\t\t\t", + rwc_non_lf_results.w_ks_r_hit_sp[j][i]); + printf("Hash add - key-shifts, Hash lookup miss\t\t\t\t" + "%u\n", rwc_non_lf_results.w_ks_r_miss[j][i]); + + printf("_______\t\t_______\t\t_________\t___\t\t" + "_________\t\t\t\t\t\t_________________\n"); + } + + for (i = 1; i < NUM_TEST; i++) { + for (k = 0; k < NUM_TEST; k++) { + printf("%u", rwc_core_cnt[i]); + printf("\t\t%u\t\t", rwc_core_cnt[k]); + printf("Enabled\t\t"); + printf("N/A\t\t"); + printf("Multi-add-lookup\t\t\t\t\t\t%u\n\n\t\t" + "\t\t", + rwc_lf_results.multi_rw[i][j][k]); + printf("Disabled\t"); + if (htm) + printf("Enabled\t\t"); + else + printf("Disabled\t"); + printf("Multi-add-lookup\t\t\t\t\t\t%u\n", + rwc_non_lf_results.multi_rw[i][j][k]); + + printf("_______\t\t_______\t\t_________\t___" + "\t\t_________\t\t\t\t\t\t" + "_________________\n"); + } + } + } + rte_free(tbl_rwc_test_param.keys); + rte_free(tbl_rwc_test_param.keys_no_ks); + rte_free(tbl_rwc_test_param.keys_ks); + rte_free(tbl_rwc_test_param.keys_absent); + rte_free(tbl_rwc_test_param.keys_shift_path); + rte_free(scanned_bkts); + return 0; +} + +REGISTER_TEST_COMMAND(hash_readwrite_lf_autotest, test_hash_readwrite_lf_main); diff --git a/test/test/test_hash_scaling.c b/test/test/test_hash_scaling.c deleted file mode 100644 index 07765a7e..00000000 --- a/test/test/test_hash_scaling.c +++ /dev/null @@ -1,191 +0,0 @@ -/* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2015 Intel Corporation - */ - -#include - -#include -#include -#include -#include -#include - -#include "test.h" - -/* - * 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) - -enum locking_mode_t { - NORMAL_LOCK, - LOCK_ELISION, - NULL_LOCK -}; - -struct { - uint32_t num_iterations; - struct rte_hash *h; - rte_spinlock_t *lock; - int locking_mode; -} tbl_scaling_test_params; - -static rte_atomic64_t gcycles; - -static int test_hash_scaling_worker(__attribute__((unused)) void *arg) -{ - uint64_t i, key; - uint32_t thr_id = rte_sys_gettid(); - uint64_t begin, cycles = 0; - - switch (tbl_scaling_test_params.locking_mode) { - - case NORMAL_LOCK: - - for (i = 0; i < tbl_scaling_test_params.num_iterations; i++) { - /* different threads get different keys because - we use the thread-id in the key computation - */ - key = rte_hash_crc(&i, sizeof(i), thr_id); - begin = rte_rdtsc_precise(); - rte_spinlock_lock(tbl_scaling_test_params.lock); - rte_hash_add_key(tbl_scaling_test_params.h, &key); - rte_spinlock_unlock(tbl_scaling_test_params.lock); - cycles += rte_rdtsc_precise() - begin; - } - break; - - case LOCK_ELISION: - - for (i = 0; i < tbl_scaling_test_params.num_iterations; i++) { - key = rte_hash_crc(&i, sizeof(i), thr_id); - begin = rte_rdtsc_precise(); - rte_spinlock_lock_tm(tbl_scaling_test_params.lock); - rte_hash_add_key(tbl_scaling_test_params.h, &key); - rte_spinlock_unlock_tm(tbl_scaling_test_params.lock); - cycles += rte_rdtsc_precise() - begin; - } - break; - - default: - - for (i = 0; i < tbl_scaling_test_params.num_iterations; i++) { - key = rte_hash_crc(&i, sizeof(i), thr_id); - begin = rte_rdtsc_precise(); - rte_hash_add_key(tbl_scaling_test_params.h, &key); - cycles += rte_rdtsc_precise() - begin; - } - } - - rte_atomic64_add(&gcycles, cycles); - - return 0; -} - -/* - * Do scalability perf tests. - */ -static int -test_hash_scaling(int locking_mode) -{ - static unsigned calledCount = 1; - uint32_t num_iterations = 1024*1024; - uint64_t i, key; - struct rte_hash_parameters hash_params = { - .entries = num_iterations*2, - .key_len = sizeof(key), - .hash_func = rte_hash_crc, - .hash_func_init_val = 0, - .socket_id = rte_socket_id(), - .extra_flag = RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT - }; - struct rte_hash *handle; - char name[RTE_HASH_NAMESIZE]; - rte_spinlock_t lock; - - rte_spinlock_init(&lock); - - snprintf(name, 32, "test%u", calledCount++); - hash_params.name = name; - - handle = rte_hash_create(&hash_params); - RETURN_IF_ERROR(handle == NULL, "hash creation failed"); - - tbl_scaling_test_params.num_iterations = - num_iterations/rte_lcore_count(); - tbl_scaling_test_params.h = handle; - tbl_scaling_test_params.lock = &lock; - tbl_scaling_test_params.locking_mode = locking_mode; - - rte_atomic64_init(&gcycles); - rte_atomic64_clear(&gcycles); - - /* fill up to initial size */ - for (i = 0; i < num_iterations; i++) { - key = rte_hash_crc(&i, sizeof(i), 0xabcdabcd); - rte_hash_add_key(tbl_scaling_test_params.h, &key); - } - - rte_eal_mp_remote_launch(test_hash_scaling_worker, NULL, CALL_MASTER); - rte_eal_mp_wait_lcore(); - - unsigned long long int cycles_per_operation = - rte_atomic64_read(&gcycles)/ - (tbl_scaling_test_params.num_iterations*rte_lcore_count()); - const char *lock_name; - - switch (locking_mode) { - case NORMAL_LOCK: - lock_name = "normal spinlock"; - break; - case LOCK_ELISION: - lock_name = "lock elision"; - break; - default: - lock_name = "null lock"; - } - printf("--------------------------------------------------------\n"); - printf("Cores: %d; %s mode -> cycles per operation: %llu\n", - rte_lcore_count(), lock_name, cycles_per_operation); - printf("--------------------------------------------------------\n"); - /* CSV output */ - printf(">>>%d,%s,%llu\n", rte_lcore_count(), lock_name, - cycles_per_operation); - - rte_hash_free(handle); - return 0; -} - -static int -test_hash_scaling_main(void) -{ - int r = 0; - - if (rte_lcore_count() == 1) - r = test_hash_scaling(NULL_LOCK); - - if (r == 0) - r = test_hash_scaling(NORMAL_LOCK); - - if (!rte_tm_supported()) { - printf("Hardware transactional memory (lock elision) is NOT supported\n"); - return r; - } - printf("Hardware transactional memory (lock elision) is supported\n"); - - if (r == 0) - r = test_hash_scaling(LOCK_ELISION); - - return r; -} - -REGISTER_TEST_COMMAND(hash_scaling_autotest, test_hash_scaling_main); diff --git a/test/test/test_kni.c b/test/test/test_kni.c index 1b876719..f3c19b5a 100644 --- a/test/test/test_kni.c +++ b/test/test/test_kni.c @@ -7,10 +7,11 @@ #include #include #include +#include #include "test.h" -#ifndef RTE_LIBRTE_KNI +#if !defined(RTE_EXEC_ENV_LINUXAPP) || !defined(RTE_LIBRTE_KNI) static int test_kni(void) @@ -40,6 +41,8 @@ test_kni(void) #define IFCONFIG "/sbin/ifconfig " #define TEST_KNI_PORT "test_kni_port" +#define KNI_MODULE_PATH "/sys/module/rte_kni" +#define KNI_MODULE_PARAM_LO KNI_MODULE_PATH"/parameters/lo_mode" #define KNI_TEST_MAX_PORTS 4 /* The threshold number of mbufs to be transmitted or received. */ #define KNI_NUM_MBUF_THRESHOLD 100 @@ -70,9 +73,6 @@ static const struct rte_eth_txconf tx_conf = { }; static const struct rte_eth_conf port_conf = { - .rxmode = { - .offloads = DEV_RX_OFFLOAD_CRC_STRIP, - }, .txmode = { .mq_mode = ETH_DCB_NONE, }, @@ -121,6 +121,79 @@ kni_change_mtu(uint16_t port_id, unsigned int new_mtu) port_id, kni_pkt_mtu); return 0; } + +static int +test_kni_link_change(void) +{ + int ret; + int pid; + + pid = fork(); + if (pid < 0) { + printf("Error: Failed to fork a process\n"); + return -1; + } + + if (pid == 0) { + printf("Starting KNI Link status change tests.\n"); + if (system(IFCONFIG TEST_KNI_PORT" up") == -1) { + ret = -1; + goto error; + } + + ret = rte_kni_update_link(test_kni_ctx, 1); + if (ret < 0) { + printf("Failed to change link state to Up ret=%d.\n", + ret); + goto error; + } + rte_delay_ms(1000); + printf("KNI: Set LINKUP, previous state=%d\n", ret); + + ret = rte_kni_update_link(test_kni_ctx, 0); + if (ret != 1) { + printf( + "Failed! Previous link state should be 1, returned %d.\n", + ret); + goto error; + } + rte_delay_ms(1000); + printf("KNI: Set LINKDOWN, previous state=%d\n", ret); + + ret = rte_kni_update_link(test_kni_ctx, 1); + if (ret != 0) { + printf( + "Failed! Previous link state should be 0, returned %d.\n", + ret); + goto error; + } + printf("KNI: Set LINKUP, previous state=%d\n", ret); + + ret = 0; + rte_delay_ms(1000); + +error: + if (system(IFCONFIG TEST_KNI_PORT" down") == -1) + ret = -1; + + printf("KNI: Link status change tests: %s.\n", + (ret == 0) ? "Passed" : "Failed"); + exit(ret); + } else { + int p_ret, status; + + while (1) { + p_ret = waitpid(pid, &status, WNOHANG); + if (p_ret != 0) { + if (WIFEXITED(status)) + return WEXITSTATUS(status); + return -1; + } + rte_delay_ms(10); + rte_kni_handle_request(test_kni_ctx); + } + } +} /** * This loop fully tests the basic functions of KNI. e.g. transmitting, * receiving to, from kernel space, and kernel requests. @@ -404,6 +477,10 @@ test_kni_processing(uint16_t port_id, struct rte_mempool *mp) goto fail_kni; } + ret = test_kni_link_change(); + if (ret != 0) + goto fail_kni; + rte_eal_mp_remote_launch(test_kni_loop, NULL, CALL_MASTER); RTE_LCORE_FOREACH_SLAVE(i) { if (rte_eal_wait_lcore(i) < 0) { @@ -429,12 +506,6 @@ test_kni_processing(uint16_t port_id, struct rte_mempool *mp) } test_kni_ctx = NULL; - /* test of releasing a released kni device */ - if (rte_kni_release(kni) == 0) { - printf("should not release a released kni device\n"); - return -1; - } - /* test of reusing memzone */ kni = rte_kni_alloc(mp, &conf, &ops); if (!kni) { @@ -462,7 +533,7 @@ static int test_kni(void) { int ret = -1; - uint16_t nb_ports, port_id; + uint16_t port_id; struct rte_kni *kni; struct rte_mempool *mp; struct rte_kni_conf conf; @@ -470,6 +541,20 @@ test_kni(void) struct rte_kni_ops ops; const struct rte_pci_device *pci_dev; const struct rte_bus *bus; + FILE *fd; + DIR *dir; + char buf[16]; + + dir = opendir(KNI_MODULE_PATH); + if (!dir) { + if (errno == ENOENT) { + printf("Cannot run UT due to missing rte_kni module\n"); + return -1; + } + printf("opendir: %s", strerror(errno)); + return -1; + } + closedir(dir); /* Initialize KNI subsytem */ rte_kni_init(KNI_TEST_MAX_PORTS); @@ -485,12 +570,6 @@ test_kni(void) return -1; } - nb_ports = rte_eth_dev_count_avail(); - if (nb_ports == 0) { - printf("no supported nic port found\n"); - return -1; - } - /* configuring port 0 for the test is enough */ port_id = 0; ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf); @@ -519,9 +598,25 @@ test_kni(void) rte_eth_promiscuous_enable(port_id); /* basic test of kni processing */ - ret = test_kni_processing(port_id, mp); - if (ret < 0) - goto fail; + fd = fopen(KNI_MODULE_PARAM_LO, "r"); + if (fd == NULL) { + printf("fopen: %s", strerror(errno)); + return -1; + } + memset(&buf, 0, sizeof(buf)); + if (fgets(buf, sizeof(buf), fd)) { + if (!strncmp(buf, "lo_mode_fifo", strlen("lo_mode_fifo")) || + !strncmp(buf, "lo_mode_fifo_skb", + strlen("lo_mode_fifo_skb"))) { + ret = test_kni_processing(port_id, mp); + if (ret < 0) { + fclose(fd); + goto fail; + } + } else + printf("test_kni_processing skipped because of missing rte_kni module lo_mode argument\n"); + } + fclose(fd); /* test of allocating KNI with NULL mempool pointer */ memset(&info, 0, sizeof(info)); diff --git a/test/test/test_kvargs.c b/test/test/test_kvargs.c index e6738624..a42056f3 100644 --- a/test/test/test_kvargs.c +++ b/test/test/test_kvargs.c @@ -137,6 +137,26 @@ static int test_valid_kvargs(void) } rte_kvargs_free(kvlist); + /* third test using list as value */ + args = "foo=[0,1],check=value2"; + valid_keys = valid_keys_list; + kvlist = rte_kvargs_parse(args, valid_keys); + if (kvlist == NULL) { + printf("rte_kvargs_parse() error"); + goto fail; + } + if (strcmp(kvlist->pairs[0].value, "[0,1]") != 0) { + printf("wrong value %s", kvlist->pairs[0].value); + goto fail; + } + count = kvlist->count; + if (count != 2) { + printf("invalid count value %d\n", count); + rte_kvargs_free(kvlist); + goto fail; + } + rte_kvargs_free(kvlist); + return 0; fail: @@ -162,6 +182,7 @@ static int test_invalid_kvargs(void) "foo=1,,foo=2", /* empty key/value */ "foo=1,foo", /* no value */ "foo=1,=2", /* no key */ + "foo=[1,2", /* no closing bracket in value */ ",=", /* also test with a smiley */ NULL }; const char **args; diff --git a/test/test/test_link_bonding_mode4.c b/test/test/test_link_bonding_mode4.c index 9163f631..e539f078 100644 --- a/test/test/test_link_bonding_mode4.c +++ b/test/test/test_link_bonding_mode4.c @@ -110,7 +110,6 @@ static struct rte_eth_conf default_pmd_conf = { .mq_mode = ETH_MQ_RX_NONE, .max_rx_pkt_len = ETHER_MAX_LEN, .split_hdr_size = 0, - .offloads = DEV_RX_OFFLOAD_CRC_STRIP, }, .txmode = { .mq_mode = ETH_MQ_TX_NONE, diff --git a/test/test/test_malloc.c b/test/test/test_malloc.c index 4b5abb4e..5e527241 100644 --- a/test/test/test_malloc.c +++ b/test/test/test_malloc.c @@ -711,6 +711,9 @@ check_socket_mem(const struct rte_memseg_list *msl, void *arg) { int32_t *socket = arg; + if (msl->external) + return 0; + return *socket == msl->socket_id; } diff --git a/test/test/test_memzone.c b/test/test/test_memzone.c index 452d7cc5..9fe465e6 100644 --- a/test/test/test_memzone.c +++ b/test/test/test_memzone.c @@ -115,6 +115,9 @@ find_available_pagesz(const struct rte_memseg_list *msl, void *arg) { struct walk_arg *wa = arg; + if (msl->external) + return 0; + if (msl->page_sz == RTE_PGSIZE_2M) wa->hugepage_2MB_avail = 1; if (msl->page_sz == RTE_PGSIZE_1G) diff --git a/test/test/test_metrics.c b/test/test/test_metrics.c new file mode 100644 index 00000000..94d54d71 --- /dev/null +++ b/test/test/test_metrics.c @@ -0,0 +1,313 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2018 Intel Corporation + */ + +#include +#include +#include +#include + +#include +#include + +#include "test.h" + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) +#define REG_METRIC_COUNT 6 +#define METRIC_LESSER_COUNT 3 +#define KEY 1 +#define VALUE 1 + +/* Initializes metric module. This function must be called + * from a primary process before metrics are used + */ +static int +test_metrics_init(void) +{ + rte_metrics_init(rte_socket_id()); + return TEST_SUCCESS; +} + + /* Test Case to check failures when memzone init is not done */ +static int +test_metrics_without_init(void) +{ + int err = 0; + const uint64_t value[REG_METRIC_COUNT] = {0}; + const char * const mnames[] = { + "mean_bits_in", "mean_bits_out", + "peak_bits_in", "peak_bits_out", + }; + + /* Failure Test: Checking for memzone initialization */ + err = rte_metrics_reg_name("peak_bits_in"); + TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__); + + err = rte_metrics_reg_names(&mnames[0], 1); + TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__); + + err = rte_metrics_update_value(RTE_METRICS_GLOBAL, KEY, VALUE); + TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__); + + err = rte_metrics_update_values(RTE_METRICS_GLOBAL, KEY, &value[0], 4); + TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__); + + err = rte_metrics_get_names(NULL, 0); + TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__); + + err = rte_metrics_get_values(RTE_METRICS_GLOBAL, NULL, 0); + TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +/* Test Case to validate registering a single metric */ +static int +test_metrics_reg_name_with_validname(void) +{ + int err = 0; + + /* Test to register the new metric name */ + err = rte_metrics_reg_name("peak_bits_out"); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Test to register the same metric name */ + err = rte_metrics_reg_name("peak_bits_out"); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Test case to validate registering a invalid metric */ + err = rte_metrics_reg_name(NULL); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +/* Test case to validate registering a list of valid metric names */ +static int +test_metrics_reg_names(void) +{ + int err = 0; + const char * const mnames[] = { + "mean_bits_in", "mean_bits_out", + "peak_bits_in", "peak_bits_out", + }; + + /* Success Test: valid array and count size */ + err = rte_metrics_reg_names(&mnames[0], ARRAY_SIZE(mnames)); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +/* Test case to validate update a metric */ +static int +test_metrics_update_value(void) +{ + int err = 0; + + /* Successful Test: Valid port_id, key and value */ + err = rte_metrics_update_value(RTE_METRICS_GLOBAL, KEY, VALUE); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test: Valid port_id otherthan RTE_METRICS_GLOBAL, key + * and value + */ + err = rte_metrics_update_value(9, KEY, VALUE); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Failed Test: Invalid port_id with lower value */ + err = rte_metrics_update_value(-2, KEY, VALUE); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + /* Failed Test: Invalid port_id with higher value */ + err = rte_metrics_update_value(39, KEY, VALUE); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + /* Failed Test: valid port id, value with invalid key */ + err = rte_metrics_update_value(RTE_METRICS_GLOBAL, KEY+12, VALUE); + TEST_ASSERT(err < 0, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +/* Test case to validate update a list of metrics */ +static int +test_metrics_update_values(void) +{ + int err = 0; + const uint64_t value[REG_METRIC_COUNT] = {1, 2, 3, 4, 5, 6}; + + /* Successful Test: update metrics with first set */ + err = rte_metrics_update_values(RTE_METRICS_GLOBAL, 0, + &value[0], 1); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test: update metrics with second set */ + err = rte_metrics_update_values(RTE_METRICS_GLOBAL, 1, + &value[1], 1); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test: update metrics with third set */ + err = rte_metrics_update_values(RTE_METRICS_GLOBAL, 2, + &value[2], 4); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Failed Test: Invalid count size */ + err = rte_metrics_update_values(RTE_METRICS_GLOBAL, + KEY, &value[0], 0); + TEST_ASSERT(err < 0, "%s, %d", __func__, __LINE__); + + /* Failed Test: Invalid port_id(lower value) and valid data */ + err = rte_metrics_update_values(-2, KEY, &value[0], ARRAY_SIZE(value)); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + /* Failed Test: Invalid port_id(higher value) and valid data */ + err = rte_metrics_update_values(39, 1, &value[0], ARRAY_SIZE(value)); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + /* Failed Test: Invalid array */ + err = rte_metrics_update_values(RTE_METRICS_GLOBAL, + KEY, NULL, ARRAY_SIZE(value)); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +/* Test to validate get metric name-key lookup table */ +static int +test_metrics_get_names(void) +{ + int err = 0; + struct rte_metric_name metrics[METRIC_LESSER_COUNT]; + struct rte_metric_name success_metrics[REG_METRIC_COUNT]; + + /* Successful Test: Invalid array list */ + err = rte_metrics_get_names(NULL, 0); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test: Valid array list, Correct Count Stats same + * as memzone stats + */ + err = rte_metrics_get_names(success_metrics, REG_METRIC_COUNT); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test: Valid array list, Increase Count Stats than + * memzone stats + */ + err = rte_metrics_get_names(success_metrics, REG_METRIC_COUNT+5); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test, Not update results: + * Invalid array list, Lesser Count Stats than allocated stats + */ + err = rte_metrics_get_names(metrics, METRIC_LESSER_COUNT); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +/* Test to validate get list of metric values */ +static int +test_metrics_get_values(void) +{ + int i = 0; + int err = 0; + struct rte_metric_value getvalues[REG_METRIC_COUNT]; + + size_t m_size = sizeof(struct rte_metric_value); + for (i = 0; i < REG_METRIC_COUNT; i++) + memset(&getvalues[i], 0, m_size); + + /* Successful Test, Not update results: valid arguments + * count lessthan the memzone stats + */ + err = rte_metrics_get_values(RTE_METRICS_GLOBAL, getvalues, + METRIC_LESSER_COUNT); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test, update results: valid arguments */ + err = rte_metrics_get_values(RTE_METRICS_GLOBAL, getvalues, + REG_METRIC_COUNT); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Successful Test : valid arguments count greaterthan the + * memzone stats + */ + err = rte_metrics_get_values(RTE_METRICS_GLOBAL, getvalues, + REG_METRIC_COUNT+2); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + /* Failure Test: Invalid port_id(lower value) with correct values + * and Capacity + */ + err = rte_metrics_get_values(-2, getvalues, REG_METRIC_COUNT); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + /* Failure Test: Invalid port_id(higher value) with correct values + * and Capacity + */ + err = rte_metrics_get_values(33, getvalues, REG_METRIC_COUNT); + TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__); + + /* Successful Test: valid port_id with incorrect values and valid + * capacity + */ + err = rte_metrics_get_values(RTE_METRICS_GLOBAL, NULL, + REG_METRIC_COUNT); + TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__); + + return TEST_SUCCESS; +} + +static struct unit_test_suite metrics_testsuite = { + .suite_name = "Metrics Unit Test Suite", + .setup = NULL, + .teardown = NULL, + .unit_test_cases = { + /* Test Case 1: Test to check all metric APIs without + * metrics init + */ + TEST_CASE(test_metrics_without_init), + + /* TEST CASE 2: Test to register valid metrics*/ + TEST_CASE_ST(test_metrics_init, NULL, + test_metrics_reg_name_with_validname), + + /* TEST CASE 3: Test to register list of metrics with valid + * names and valid count size, invalid names and invalid + * count size + */ + TEST_CASE(test_metrics_reg_names), + + /* TEST CASE 4: Test to register a update value with valid port + * id and invalid port id + */ + TEST_CASE(test_metrics_update_value), + + /* TEST CASE 5: Test to register update list of values with + * valid port id, key, value, count size and invalid port id, + * key, value, count size + */ + TEST_CASE(test_metrics_update_values), + + /* TEST CASE 6: Test to get metric names-key with valid + * array list, count size and invalid array list, count size + */ + TEST_CASE(test_metrics_get_names), + + /* TEST CASE 7: Test to get list of metric values with valid + * port id, array list, count size and invalid port id, + * arraylist, count size + */ + TEST_CASE(test_metrics_get_values), + TEST_CASES_END() + } +}; + +static int +test_metrics(void) +{ + return unit_test_suite_runner(&metrics_testsuite); +} + +REGISTER_TEST_COMMAND(metrics_autotest, test_metrics); diff --git a/test/test/test_pmd_perf.c b/test/test/test_pmd_perf.c index 4549965f..f5095c87 100644 --- a/test/test/test_pmd_perf.c +++ b/test/test/test_pmd_perf.c @@ -65,7 +65,6 @@ static struct rte_eth_conf port_conf = { .mq_mode = ETH_MQ_RX_NONE, .max_rx_pkt_len = ETHER_MAX_LEN, .split_hdr_size = 0, - .offloads = DEV_RX_OFFLOAD_CRC_STRIP, }, .txmode = { .mq_mode = ETH_MQ_TX_NONE, diff --git a/test/test/test_pmd_ring.c b/test/test/test_pmd_ring.c index 19d7d20a..6414bbd1 100644 --- a/test/test/test_pmd_ring.c +++ b/test/test/test_pmd_ring.c @@ -2,20 +2,22 @@ * Copyright(c) 2010-2015 Intel Corporation */ #include "test.h" +#include #include #include #include - -static struct rte_mempool *mp; -static int tx_porta, rx_portb, rxtx_portc, rxtx_portd, rxtx_porte; +#include #define SOCKET0 0 #define RING_SIZE 256 #define NUM_RINGS 2 #define NB_MBUF 512 +static struct rte_mempool *mp; +struct rte_ring *rxtx[NUM_RINGS]; +static int tx_porta, rx_portb, rxtx_portc, rxtx_portd, rxtx_porte; static int test_ethdev_configure_port(int port) @@ -42,7 +44,7 @@ test_ethdev_configure_port(int port) } if (rte_eth_rx_queue_setup(port, 0, RING_SIZE, SOCKET0, - NULL, mp) < 0) { + NULL, mp) < 0) { printf("RX queue setup failed port %d\n", port); return -1; } @@ -71,21 +73,21 @@ test_send_basic_packets(void) if (rte_eth_tx_burst(tx_porta, 0, pbufs, RING_SIZE/2) < RING_SIZE/2) { printf("Failed to transmit packet burst port %d\n", tx_porta); - return -1; + return TEST_FAILED; } if (rte_eth_rx_burst(rx_portb, 0, pbufs, RING_SIZE) != RING_SIZE/2) { printf("Failed to receive packet burst on port %d\n", rx_portb); - return -1; + return TEST_FAILED; } for (i = 0; i < RING_SIZE/2; i++) if (pbufs[i] != &bufs[i]) { printf("Error: received data does not match that transmitted\n"); - return -1; + return TEST_FAILED; } - return 0; + return TEST_SUCCESS; } static int @@ -212,7 +214,7 @@ test_stats_reset(int port) } static int -test_pmd_ring_pair_create_attach(int portd, int porte) +test_pmd_ring_pair_create_attach(void) { struct rte_eth_stats stats, stats2; struct rte_mbuf buf, *pbuf = &buf; @@ -220,185 +222,218 @@ test_pmd_ring_pair_create_attach(int portd, int porte) memset(&null_conf, 0, sizeof(struct rte_eth_conf)); - if ((rte_eth_dev_configure(portd, 1, 1, &null_conf) < 0) - || (rte_eth_dev_configure(porte, 1, 1, &null_conf) < 0)) { + if ((rte_eth_dev_configure(rxtx_portd, 1, 1, &null_conf) < 0) + || (rte_eth_dev_configure(rxtx_porte, 1, 1, + &null_conf) < 0)) { printf("Configure failed for port\n"); - return -1; + return TEST_FAILED; } - if ((rte_eth_tx_queue_setup(portd, 0, RING_SIZE, SOCKET0, NULL) < 0) - || (rte_eth_tx_queue_setup(porte, 0, RING_SIZE, SOCKET0, NULL) < 0)) { + if ((rte_eth_tx_queue_setup(rxtx_portd, 0, RING_SIZE, + SOCKET0, NULL) < 0) + || (rte_eth_tx_queue_setup(rxtx_porte, 0, RING_SIZE, + SOCKET0, NULL) < 0)) { printf("TX queue setup failed\n"); - return -1; + return TEST_FAILED; } - if ((rte_eth_rx_queue_setup(portd, 0, RING_SIZE, SOCKET0, NULL, mp) < 0) - || (rte_eth_rx_queue_setup(porte, 0, RING_SIZE, SOCKET0, NULL, mp) < 0)) { + if ((rte_eth_rx_queue_setup(rxtx_portd, 0, RING_SIZE, + SOCKET0, NULL, mp) < 0) + || (rte_eth_rx_queue_setup(rxtx_porte, 0, RING_SIZE, + SOCKET0, NULL, mp) < 0)) { printf("RX queue setup failed\n"); - return -1; + return TEST_FAILED; } - if ((rte_eth_dev_start(portd) < 0) - || (rte_eth_dev_start(porte) < 0)) { + if ((rte_eth_dev_start(rxtx_portd) < 0) + || (rte_eth_dev_start(rxtx_porte) < 0)) { printf("Error starting port\n"); - return -1; + return TEST_FAILED; } - rte_eth_stats_reset(portd); + rte_eth_stats_reset(rxtx_portd); /* check stats of port, should all be zero */ - rte_eth_stats_get(portd, &stats); + rte_eth_stats_get(rxtx_portd, &stats); if (stats.ipackets != 0 || stats.opackets != 0 || stats.ibytes != 0 || stats.obytes != 0 || stats.ierrors != 0 || stats.oerrors != 0) { - printf("Error: port %d stats are not zero\n", portd); - return -1; + printf("Error: port %d stats are not zero\n", rxtx_portd); + return TEST_FAILED; } - rte_eth_stats_reset(porte); + rte_eth_stats_reset(rxtx_porte); /* check stats of port, should all be zero */ - rte_eth_stats_get(porte, &stats2); + rte_eth_stats_get(rxtx_porte, &stats2); if (stats2.ipackets != 0 || stats2.opackets != 0 || stats2.ibytes != 0 || stats2.obytes != 0 || stats2.ierrors != 0 || stats2.oerrors != 0) { - printf("Error: port %d stats are not zero\n", porte); - return -1; + printf("Error: port %d stats are not zero\n", rxtx_porte); + return TEST_FAILED; } /* - * send and receive 1 packet (portd -> porte) + * send and receive 1 packet (rxtx_portd -> rxtx_porte) * and check for stats update */ - printf("Testing send and receive 1 packet (portd -> porte)\n"); - if (rte_eth_tx_burst(portd, 0, &pbuf, 1) != 1) { - printf("Error sending packet to port %d\n", portd); - return -1; + printf("Testing send and receive 1 packet (rxtx_portd -> rxtx_porte)\n"); + if (rte_eth_tx_burst(rxtx_portd, 0, &pbuf, 1) != 1) { + printf("Error sending packet to port %d\n", rxtx_portd); + return TEST_FAILED; } - if (rte_eth_rx_burst(porte, 0, &pbuf, 1) != 1) { - printf("Error receiving packet from port %d\n", porte); - return -1; + if (rte_eth_rx_burst(rxtx_porte, 0, &pbuf, 1) != 1) { + printf("Error receiving packet from port %d\n", rxtx_porte); + return TEST_FAILED; } - rte_eth_stats_get(portd, &stats); - rte_eth_stats_get(porte, &stats2); + rte_eth_stats_get(rxtx_portd, &stats); + rte_eth_stats_get(rxtx_porte, &stats2); if (stats.ipackets != 0 || stats.opackets != 1 || stats.ibytes != 0 || stats.obytes != 0 || stats.ierrors != 0 || stats.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", portd); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_portd); + return TEST_FAILED; } if (stats2.ipackets != 1 || stats2.opackets != 0 || stats2.ibytes != 0 || stats2.obytes != 0 || stats2.ierrors != 0 || stats2.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", porte); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_porte); + return TEST_FAILED; } /* - * send and receive 1 packet (porte -> portd) + * send and receive 1 packet (rxtx_porte -> rxtx_portd) * and check for stats update */ - printf("Testing send and receive 1 packet (porte -> portd)\n"); - if (rte_eth_tx_burst(porte, 0, &pbuf, 1) != 1) { - printf("Error sending packet to port %d\n", porte); - return -1; + printf("Testing send and receive 1 packet " + "(rxtx_porte -> rxtx_portd)\n"); + if (rte_eth_tx_burst(rxtx_porte, 0, &pbuf, 1) != 1) { + printf("Error sending packet to port %d\n", rxtx_porte); + return TEST_FAILED; } - if (rte_eth_rx_burst(portd, 0, &pbuf, 1) != 1) { - printf("Error receiving packet from port %d\n", portd); - return -1; + if (rte_eth_rx_burst(rxtx_portd, 0, &pbuf, 1) != 1) { + printf("Error receiving packet from port %d\n", rxtx_portd); + return TEST_FAILED; } - rte_eth_stats_get(portd, &stats); - rte_eth_stats_get(porte, &stats2); + rte_eth_stats_get(rxtx_portd, &stats); + rte_eth_stats_get(rxtx_porte, &stats2); if (stats.ipackets != 1 || stats.opackets != 1 || stats.ibytes != 0 || stats.obytes != 0 || stats.ierrors != 0 || stats.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", portd); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_portd); + return TEST_FAILED; } if (stats2.ipackets != 1 || stats2.opackets != 1 || stats2.ibytes != 0 || stats2.obytes != 0 || stats2.ierrors != 0 || stats2.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", porte); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_porte); + return TEST_FAILED; } /* - * send and receive 1 packet (portd -> portd) + * send and receive 1 packet (rxtx_portd -> rxtx_portd) * and check for stats update */ - printf("Testing send and receive 1 packet (portd -> portd)\n"); - if (rte_eth_tx_burst(portd, 0, &pbuf, 1) != 1) { - printf("Error sending packet to port %d\n", portd); - return -1; + printf("Testing send and receive 1 packet " + "(rxtx_portd -> rxtx_portd)\n"); + if (rte_eth_tx_burst(rxtx_portd, 0, &pbuf, 1) != 1) { + printf("Error sending packet to port %d\n", rxtx_portd); + return TEST_FAILED; } - if (rte_eth_rx_burst(portd, 0, &pbuf, 1) != 1) { - printf("Error receiving packet from port %d\n", porte); - return -1; + if (rte_eth_rx_burst(rxtx_portd, 0, &pbuf, 1) != 1) { + printf("Error receiving packet from port %d\n", rxtx_porte); + return TEST_FAILED; } - rte_eth_stats_get(portd, &stats); - rte_eth_stats_get(porte, &stats2); + rte_eth_stats_get(rxtx_portd, &stats); + rte_eth_stats_get(rxtx_porte, &stats2); if (stats.ipackets != 2 || stats.opackets != 2 || stats.ibytes != 0 || stats.obytes != 0 || stats.ierrors != 0 || stats.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", portd); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_portd); + return TEST_FAILED; } if (stats2.ipackets != 1 || stats2.opackets != 1 || stats2.ibytes != 0 || stats2.obytes != 0 || stats2.ierrors != 0 || stats2.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", porte); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_porte); + return TEST_FAILED; } /* - * send and receive 1 packet (porte -> porte) + * send and receive 1 packet (rxtx_porte -> rxtx_porte) * and check for stats update */ - printf("Testing send and receive 1 packet (porte -> porte)\n"); - if (rte_eth_tx_burst(porte, 0, &pbuf, 1) != 1) { - printf("Error sending packet to port %d\n", porte); - return -1; + printf("Testing send and receive 1 packet " + "(rxtx_porte -> rxtx_porte)\n"); + if (rte_eth_tx_burst(rxtx_porte, 0, &pbuf, 1) != 1) { + printf("Error sending packet to port %d\n", rxtx_porte); + return TEST_FAILED; } - if (rte_eth_rx_burst(porte, 0, &pbuf, 1) != 1) { - printf("Error receiving packet from port %d\n", porte); - return -1; + if (rte_eth_rx_burst(rxtx_porte, 0, &pbuf, 1) != 1) { + printf("Error receiving packet from port %d\n", rxtx_porte); + return TEST_FAILED; } - rte_eth_stats_get(portd, &stats); - rte_eth_stats_get(porte, &stats2); + rte_eth_stats_get(rxtx_portd, &stats); + rte_eth_stats_get(rxtx_porte, &stats2); if (stats.ipackets != 2 || stats.opackets != 2 || stats.ibytes != 0 || stats.obytes != 0 || stats.ierrors != 0 || stats.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", portd); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_portd); + return TEST_FAILED; } if (stats2.ipackets != 2 || stats2.opackets != 2 || stats2.ibytes != 0 || stats2.obytes != 0 || stats2.ierrors != 0 || stats2.oerrors != 0) { - printf("Error: port %d stats are not as expected\n", porte); - return -1; + printf("Error: port %d stats are not as expected\n", + rxtx_porte); + return TEST_FAILED; } - rte_eth_dev_stop(portd); - rte_eth_dev_stop(porte); + rte_eth_dev_stop(rxtx_portd); + rte_eth_dev_stop(rxtx_porte); - return 0; + return TEST_SUCCESS; +} + +static void +test_cleanup_resources(void) +{ + int itr; + for (itr = 0; itr < NUM_RINGS; itr++) + rte_ring_free(rxtx[itr]); + + rte_eth_dev_stop(tx_porta); + rte_eth_dev_stop(rx_portb); + rte_eth_dev_stop(rxtx_portc); + + rte_mempool_free(mp); + rte_vdev_uninit("net_ring_net_ringa"); + rte_vdev_uninit("net_ring_net_ringb"); + rte_vdev_uninit("net_ring_net_ringc"); + rte_vdev_uninit("net_ring_net_ringd"); + rte_vdev_uninit("net_ring_net_ringe"); } static int -test_pmd_ring(void) +test_pmd_ringcreate_setup(void) { - struct rte_ring *rxtx[NUM_RINGS]; - int port, cmdl_port0 = -1; uint8_t nb_ports; nb_ports = rte_eth_dev_count_avail(); @@ -431,53 +466,33 @@ test_pmd_ring(void) tx_porta, rx_portb, rxtx_portc, rxtx_portd, rxtx_porte); if ((tx_porta == -1) || (rx_portb == -1) || (rxtx_portc == -1) - || (rxtx_portd == -1) || (rxtx_porte == -1)) { + || (rxtx_portd == -1) || (rxtx_porte == -1)) { printf("rte_eth_from rings failed\n"); return -1; } mp = rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 32, - 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); + 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); if (mp == NULL) return -1; if ((tx_porta >= RTE_MAX_ETHPORTS) || (rx_portb >= RTE_MAX_ETHPORTS) - || (rxtx_portc >= RTE_MAX_ETHPORTS) - || (rxtx_portd >= RTE_MAX_ETHPORTS) - || (rxtx_porte >= RTE_MAX_ETHPORTS)) { + || (rxtx_portc >= RTE_MAX_ETHPORTS) + || (rxtx_portd >= RTE_MAX_ETHPORTS) + || (rxtx_porte >= RTE_MAX_ETHPORTS)) { printf(" port exceed max eth ports\n"); return -1; } + return 0; +} - if (test_ethdev_configure_port(tx_porta) < 0) - return -1; - - if (test_ethdev_configure_port(rx_portb) < 0) - return -1; - - if (test_ethdev_configure_port(rxtx_portc) < 0) - return -1; - - if (test_send_basic_packets() < 0) - return -1; - - if (test_get_stats(rxtx_portc) < 0) - return -1; - - if (test_stats_reset(rxtx_portc) < 0) - return -1; - - rte_eth_dev_stop(tx_porta); - rte_eth_dev_stop(rx_portb); - rte_eth_dev_stop(rxtx_portc); - - if (test_pmd_ring_pair_create_attach(rxtx_portd, rxtx_porte) < 0) - return -1; - +static int +test_command_line_ring_port(void) +{ + int port, cmdl_port0 = -1; /* find a port created with the --vdev=net_ring0 command line option */ RTE_ETH_FOREACH_DEV(port) { struct rte_eth_dev_info dev_info; - rte_eth_dev_info_get(port, &dev_info); if (!strcmp(dev_info.driver_name, "Rings PMD")) { printf("found a command line ring port=%d\n", port); @@ -486,17 +501,66 @@ test_pmd_ring(void) } } if (cmdl_port0 != -1) { - if (test_ethdev_configure_port(cmdl_port0) < 0) - return -1; - if (test_send_basic_packets_port(cmdl_port0) < 0) - return -1; - if (test_stats_reset(cmdl_port0) < 0) - return -1; - if (test_get_stats(cmdl_port0) < 0) - return -1; + TEST_ASSERT((test_ethdev_configure_port(cmdl_port0) < 0), + "test ethdev configure port cmdl_port0 is failed"); + TEST_ASSERT((test_send_basic_packets_port(cmdl_port0) < 0), + "test send basic packets port cmdl_port0 is failed"); + TEST_ASSERT((test_stats_reset(cmdl_port0) < 0), + "test stats reset cmdl_port0 is failed"); + TEST_ASSERT((test_get_stats(cmdl_port0) < 0), + "test get stats cmdl_port0 is failed"); rte_eth_dev_stop(cmdl_port0); } - return 0; + return TEST_SUCCESS; +} + +static int +test_ethdev_configure_ports(void) +{ + TEST_ASSERT((test_ethdev_configure_port(tx_porta) == 0), + "test ethdev configure ports tx_porta is failed"); + TEST_ASSERT((test_ethdev_configure_port(rx_portb) == 0), + "test ethdev configure ports rx_portb is failed"); + TEST_ASSERT((test_ethdev_configure_port(rxtx_portc) == 0), + "test ethdev configure ports rxtx_portc is failed"); + + return TEST_SUCCESS; +} + +static int +test_get_stats_for_port(void) +{ + TEST_ASSERT(test_get_stats(rxtx_portc) == 0, "test get stats failed"); + return TEST_SUCCESS; +} + +static int +test_stats_reset_for_port(void) +{ + TEST_ASSERT(test_stats_reset(rxtx_portc) == 0, "test stats reset failed"); + return TEST_SUCCESS; +} + +static struct +unit_test_suite test_pmd_ring_suite = { + .setup = test_pmd_ringcreate_setup, + .teardown = test_cleanup_resources, + .suite_name = "Test Pmd Ring Unit Test Suite", + .unit_test_cases = { + TEST_CASE(test_ethdev_configure_ports), + TEST_CASE(test_send_basic_packets), + TEST_CASE(test_get_stats_for_port), + TEST_CASE(test_stats_reset_for_port), + TEST_CASE(test_pmd_ring_pair_create_attach), + TEST_CASE(test_command_line_ring_port), + TEST_CASES_END() + } +}; + +static int +test_pmd_ring(void) +{ + return unit_test_suite_runner(&test_pmd_ring_suite); } REGISTER_TEST_COMMAND(ring_pmd_autotest, test_pmd_ring); diff --git a/test/test/test_timer_racecond.c b/test/test/test_timer_racecond.c index 5e08f06b..d29048ea 100644 --- a/test/test/test_timer_racecond.c +++ b/test/test/test_timer_racecond.c @@ -54,7 +54,7 @@ #define BILLION (1UL << 30) -#define TEST_DURATION_S 20 /* in seconds */ +#define TEST_DURATION_S 4 /* in seconds */ #define N_TIMERS 50 static struct rte_timer timer[N_TIMERS]; diff --git a/test/test/virtual_pmd.c b/test/test/virtual_pmd.c index 591b3098..f8ddc2db 100644 --- a/test/test/virtual_pmd.c +++ b/test/test/virtual_pmd.c @@ -91,7 +91,6 @@ virtual_ethdev_info_get(struct rte_eth_dev *dev __rte_unused, dev_info->max_tx_queues = (uint16_t)512; dev_info->min_rx_bufsize = 0; - dev_info->rx_offload_capa = DEV_RX_OFFLOAD_CRC_STRIP; } static int -- cgit 1.2.3-korg