From patchwork Tue Sep 24 14:10:32 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Dybkowski, AdamX" X-Patchwork-Id: 59681 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 82E0C343C; Tue, 24 Sep 2019 16:12:47 +0200 (CEST) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id F33A12C28 for ; Tue, 24 Sep 2019 16:12:38 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 24 Sep 2019 07:12:38 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,544,1559545200"; d="scan'208";a="272642320" Received: from adamdybx-mobl.ger.corp.intel.com (HELO addy-VirtualBox.isw.intel.com) ([10.103.104.111]) by orsmga001.jf.intel.com with ESMTP; 24 Sep 2019 07:12:36 -0700 From: Adam Dybkowski To: dev@dpdk.org, fiona.trahe@intel.com, arturx.trybula@intel.com, akhil.goyal@nxp.com Cc: Adam Dybkowski Date: Tue, 24 Sep 2019 16:10:32 +0200 Message-Id: <20190924141033.3894-2-adamx.dybkowski@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190924141033.3894-1-adamx.dybkowski@intel.com> References: <20190903094312.8780-1-adamx.dybkowski@intel.com> <20190924141033.3894-1-adamx.dybkowski@intel.com> Subject: [dpdk-dev] [PATCH v2 1/2] test/compress: add external buffer in mbuf API test X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Adds a new test to verify external buffer in mbuf APIs. Initialize fields in test_data_params structures by name for better readability. Signed-off-by: Adam Dybkowski --- app/test/test_compressdev.c | 314 +++++++++++++++++++++++++----------- 1 file changed, 221 insertions(+), 93 deletions(-) diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c index 9a7989683..d470c34b9 100644 --- a/app/test/test_compressdev.c +++ b/app/test/test_compressdev.c @@ -104,6 +104,12 @@ struct test_data_params { /* stateful decompression specific parameters */ unsigned int decompress_output_block_size; unsigned int decompress_steps_max; + /* external mbufs specific parameters */ + unsigned int use_external_mbufs; + unsigned int inbuf_data_size; + const struct rte_memzone *inbuf_memzone; + const struct rte_memzone *compbuf_memzone; + const struct rte_memzone *uncompbuf_memzone; }; static struct comp_testsuite_params testsuite_params = { 0 }; @@ -714,6 +720,11 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, return 0; } +static void +extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused) +{ +} + /* * Compresses and decompresses buffer with compressdev API and Zlib API */ @@ -735,6 +746,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, unsigned int big_data = test_data->big_data; enum zlib_direction zlib_dir = test_data->zlib_dir; int ret_status = TEST_FAILED; + struct rte_mbuf_ext_shared_info inbuf_info; + struct rte_mbuf_ext_shared_info compbuf_info; + struct rte_mbuf_ext_shared_info decompbuf_info; int ret; struct rte_mbuf *uncomp_bufs[num_bufs]; struct rte_mbuf *comp_bufs[num_bufs]; @@ -803,7 +817,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, goto exit; } - if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) { + if (test_data->use_external_mbufs) { + inbuf_info.free_cb = extbuf_free_callback; + inbuf_info.fcb_opaque = NULL; + rte_mbuf_ext_refcnt_set(&inbuf_info, 1); + for (i = 0; i < num_bufs; i++) { + rte_pktmbuf_attach_extbuf(uncomp_bufs[i], + test_data->inbuf_memzone->addr, + test_data->inbuf_memzone->iova, + test_data->inbuf_data_size, + &inbuf_info); + rte_pktmbuf_append(uncomp_bufs[i], + test_data->inbuf_data_size); + } + } else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) { for (i = 0; i < num_bufs; i++) { data_size = strlen(test_bufs[i]) + 1; if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i], @@ -831,7 +858,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, goto exit; } - if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { + if (test_data->use_external_mbufs) { + compbuf_info.free_cb = extbuf_free_callback; + compbuf_info.fcb_opaque = NULL; + rte_mbuf_ext_refcnt_set(&compbuf_info, 1); + for (i = 0; i < num_bufs; i++) { + rte_pktmbuf_attach_extbuf(comp_bufs[i], + test_data->compbuf_memzone->addr, + test_data->compbuf_memzone->iova, + test_data->compbuf_memzone->len, + &compbuf_info); + rte_pktmbuf_append(comp_bufs[i], + test_data->compbuf_memzone->len); + } + } else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { for (i = 0; i < num_bufs; i++) { if (out_of_space == 1 && oos_zlib_decompress) data_size = OUT_OF_SPACE_BUF; @@ -1058,7 +1098,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, goto exit; } - if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { + if (test_data->use_external_mbufs) { + decompbuf_info.free_cb = extbuf_free_callback; + decompbuf_info.fcb_opaque = NULL; + rte_mbuf_ext_refcnt_set(&decompbuf_info, 1); + for (i = 0; i < num_bufs; i++) { + rte_pktmbuf_attach_extbuf(uncomp_bufs[i], + test_data->uncompbuf_memzone->addr, + test_data->uncompbuf_memzone->iova, + test_data->uncompbuf_memzone->len, + &decompbuf_info); + rte_pktmbuf_append(uncomp_bufs[i], + test_data->uncompbuf_memzone->len); + } + } else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { for (i = 0; i < num_bufs; i++) { priv_data = (struct priv_op_data *) (ops_processed[i] + 1); @@ -1386,8 +1439,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, */ for (i = 0; i < num_bufs; i++) { priv_data = (struct priv_op_data *)(ops_processed[i] + 1); - const char *buf1 = test_bufs[priv_data->orig_idx]; + const char *buf1 = test_data->use_external_mbufs ? + test_data->inbuf_memzone->addr : + test_bufs[priv_data->orig_idx]; const char *buf2; + data_size = test_data->use_external_mbufs ? + test_data->inbuf_data_size : + strlen(buf1) + 1; contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0); if (contig_buf == NULL) { RTE_LOG(ERR, USER1, "Contiguous buffer could not " @@ -1397,7 +1455,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0, ops_processed[i]->produced, contig_buf); - if (compare_buffers(buf1, strlen(buf1) + 1, + if (compare_buffers(buf1, data_size, buf2, ops_processed[i]->produced) < 0) goto exit; @@ -1478,14 +1536,12 @@ test_compressdev_deflate_stateless_fixed(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1550,14 +1606,12 @@ test_compressdev_deflate_stateless_dynamic(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1606,14 +1660,12 @@ test_compressdev_deflate_stateless_multi_op(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; /* Compress with compressdev, decompress with Zlib */ @@ -1661,14 +1713,12 @@ test_compressdev_deflate_stateless_multi_level(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1752,14 +1802,12 @@ test_compressdev_deflate_stateless_multi_xform(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; /* Compress with compressdev, decompress with Zlib */ @@ -1802,14 +1850,12 @@ test_compressdev_deflate_stateless_sgl(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - SGL_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = SGL_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1914,14 +1960,12 @@ test_compressdev_deflate_stateless_checksum(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 0, - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0 }; /* Check if driver supports crc32 checksum and test */ @@ -2033,14 +2077,12 @@ test_compressdev_out_of_space_buffer(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - LB_BOTH, - ZLIB_DECOMPRESS, - 1, /* run out-of-space test */ - 0, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 1, /* run out-of-space test */ + .big_data = 0 }; /* Compress with compressdev, decompress with Zlib */ test_data.zlib_dir = ZLIB_DECOMPRESS; @@ -2112,14 +2154,12 @@ test_compressdev_deflate_stateless_dynamic_big(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATELESS, - SGL_BOTH, - ZLIB_DECOMPRESS, - 0, - 1, - 0, - 0 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = SGL_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 1 }; ts_params->def_comp_xform->compress.deflate.huffman = @@ -2176,14 +2216,14 @@ test_compressdev_deflate_stateful_decomp(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATEFUL, - LB_BOTH, - ZLIB_COMPRESS, - 0, - 0, - 2000, - 4 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATEFUL, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_COMPRESS, + .out_of_space = 0, + .big_data = 0, + .decompress_output_block_size = 2000, + .decompress_steps_max = 4 }; /* Compress with Zlib, decompress with compressdev */ @@ -2258,14 +2298,14 @@ test_compressdev_deflate_stateful_decomp_checksum(void) }; struct test_data_params test_data = { - RTE_COMP_OP_STATELESS, - RTE_COMP_OP_STATEFUL, - LB_BOTH, - ZLIB_COMPRESS, - 0, - 0, - 2000, - 4 + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATEFUL, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_COMPRESS, + .out_of_space = 0, + .big_data = 0, + .decompress_output_block_size = 2000, + .decompress_steps_max = 4 }; /* Check if driver supports crc32 checksum and test */ @@ -2346,6 +2386,92 @@ test_compressdev_deflate_stateful_decomp_checksum(void) return ret; } +static const struct rte_memzone * +make_memzone(const char *name, size_t size) +{ + unsigned int socket_id = rte_socket_id(); + char mz_name[RTE_MEMZONE_NAMESIZE]; + const struct rte_memzone *memzone; + + snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id); + memzone = rte_memzone_lookup(mz_name); + if (memzone != NULL && memzone->len != size) { + rte_memzone_free(memzone); + memzone = NULL; + } + if (memzone == NULL) { + memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id, + RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE); + if (memzone == NULL) + RTE_LOG(ERR, USER1, "Can't allocate memory zone %s", + mz_name); + } + return memzone; +} + +static int +test_compressdev_external_mbufs(void) +{ + struct comp_testsuite_params *ts_params = &testsuite_params; + size_t data_len = 0; + uint16_t i; + int ret = TEST_FAILED; + + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) + data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1); + + struct interim_data_params int_data = { + NULL, + 1, + NULL, + &ts_params->def_comp_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + .compress_state = RTE_COMP_OP_STATELESS, + .decompress_state = RTE_COMP_OP_STATELESS, + .buff_type = LB_BOTH, + .zlib_dir = ZLIB_DECOMPRESS, + .out_of_space = 0, + .big_data = 0, + .use_external_mbufs = 1, + .inbuf_data_size = data_len, + .inbuf_memzone = make_memzone("inbuf", data_len), + .compbuf_memzone = make_memzone("compbuf", data_len * + COMPRESS_BUF_SIZE_RATIO), + .uncompbuf_memzone = make_memzone("decompbuf", data_len) + }; + + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { + /* prepare input data */ + data_len = strlen(compress_test_bufs[i]) + 1; + rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i], + data_len); + test_data.inbuf_data_size = data_len; + int_data.buf_idx = &i; + + /* Compress with compressdev, decompress with Zlib */ + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) + goto exit; + + /* Compress with Zlib, decompress with compressdev */ + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) + goto exit; + } + + ret = TEST_SUCCESS; + +exit: + rte_memzone_free(test_data.inbuf_memzone); + rte_memzone_free(test_data.compbuf_memzone); + rte_memzone_free(test_data.uncompbuf_memzone); + return ret; +} + static struct unit_test_suite compressdev_testsuite = { .suite_name = "compressdev unit test suite", .setup = testsuite_setup, @@ -2375,6 +2501,8 @@ static struct unit_test_suite compressdev_testsuite = { test_compressdev_deflate_stateful_decomp), TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, test_compressdev_deflate_stateful_decomp_checksum), + TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, + test_compressdev_external_mbufs), TEST_CASES_END() /**< NULL terminate unit test array */ } }; From patchwork Tue Sep 24 14:10:33 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Dybkowski, AdamX" X-Patchwork-Id: 59682 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id A90251BE84; Tue, 24 Sep 2019 16:12:49 +0200 (CEST) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id DCD802C57 for ; Tue, 24 Sep 2019 16:12:40 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 24 Sep 2019 07:12:40 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,544,1559545200"; d="scan'208";a="272642327" Received: from adamdybx-mobl.ger.corp.intel.com (HELO addy-VirtualBox.isw.intel.com) ([10.103.104.111]) by orsmga001.jf.intel.com with ESMTP; 24 Sep 2019 07:12:38 -0700 From: Adam Dybkowski To: dev@dpdk.org, fiona.trahe@intel.com, arturx.trybula@intel.com, akhil.goyal@nxp.com Cc: Adam Dybkowski Date: Tue, 24 Sep 2019 16:10:33 +0200 Message-Id: <20190924141033.3894-3-adamx.dybkowski@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190924141033.3894-1-adamx.dybkowski@intel.com> References: <20190903094312.8780-1-adamx.dybkowski@intel.com> <20190924141033.3894-1-adamx.dybkowski@intel.com> Subject: [dpdk-dev] [PATCH v2 2/2] app/compress-perf: add external mbufs option X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" This patch adds new performance measurement option --external-mbufs that allocates and uses memzones as external buffers instead of putting the data directly inside mbufs. Signed-off-by: Adam Dybkowski --- app/test-compress-perf/comp_perf_options.h | 2 + .../comp_perf_options_parse.c | 15 ++ .../comp_perf_test_benchmark.c | 3 +- .../comp_perf_test_common.c | 201 +++++++++++++++++- .../comp_perf_test_common.h | 9 +- .../comp_perf_test_verify.c | 4 +- 6 files changed, 222 insertions(+), 12 deletions(-) diff --git a/app/test-compress-perf/comp_perf_options.h b/app/test-compress-perf/comp_perf_options.h index 651cbea4e..606268373 100644 --- a/app/test-compress-perf/comp_perf_options.h +++ b/app/test-compress-perf/comp_perf_options.h @@ -56,12 +56,14 @@ struct comp_test_data { uint32_t pool_sz; uint32_t num_iter; uint16_t max_sgl_segs; + uint32_t total_segs; enum rte_comp_huffman huffman_enc; enum comp_operation test_op; int window_sz; struct range_list level_lst; uint8_t level; + int use_external_mbufs; double ratio; enum cleanup_st cleanup; diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c index 01e19eafb..e623fea7f 100644 --- a/app/test-compress-perf/comp_perf_options_parse.c +++ b/app/test-compress-perf/comp_perf_options_parse.c @@ -28,6 +28,7 @@ #define CPERF_HUFFMAN_ENC ("huffman-enc") #define CPERF_LEVEL ("compress-level") #define CPERF_WINDOW_SIZE ("window-sz") +#define CPERF_EXTERNAL_MBUFS ("external-mbufs") struct name_id_map { const char *name; @@ -58,6 +59,8 @@ usage(char *progname) " (default: range between 1 and 9)\n" " --window-sz N: base two log value of compression window size\n" " (e.g.: 15 => 32k, default: max supported by PMD)\n" + " --external-mbufs: use memzones as external buffers instead of\n" + " keeping the data directly in mbuf area\n" " -h: prints this help\n", progname); } @@ -520,6 +523,14 @@ parse_level(struct comp_test_data *test_data, const char *arg) return 0; } +static int +parse_external_mbufs(struct comp_test_data *test_data, + const char *arg __rte_unused) +{ + test_data->use_external_mbufs = 1; + return 0; +} + typedef int (*option_parser_t)(struct comp_test_data *test_data, const char *arg); @@ -544,8 +555,10 @@ static struct option lgopts[] = { { CPERF_HUFFMAN_ENC, required_argument, 0, 0 }, { CPERF_LEVEL, required_argument, 0, 0 }, { CPERF_WINDOW_SIZE, required_argument, 0, 0 }, + { CPERF_EXTERNAL_MBUFS, 0, 0, 0 }, { NULL, 0, 0, 0 } }; + static int comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data) { @@ -563,6 +576,7 @@ comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data) { CPERF_HUFFMAN_ENC, parse_huffman_enc }, { CPERF_LEVEL, parse_level }, { CPERF_WINDOW_SIZE, parse_window_sz }, + { CPERF_EXTERNAL_MBUFS, parse_external_mbufs }, }; unsigned int i; @@ -618,6 +632,7 @@ comp_perf_options_default(struct comp_test_data *test_data) test_data->level_lst.max = RTE_COMP_LEVEL_MAX; test_data->level_lst.inc = 1; test_data->test = CPERF_TEST_TYPE_BENCHMARK; + test_data->use_external_mbufs = 0; } int diff --git a/app/test-compress-perf/comp_perf_test_benchmark.c b/app/test-compress-perf/comp_perf_test_benchmark.c index 887459449..0c6bb9b45 100644 --- a/app/test-compress-perf/comp_perf_test_benchmark.c +++ b/app/test-compress-perf/comp_perf_test_benchmark.c @@ -15,7 +15,8 @@ cperf_benchmark_test_destructor(void *arg) { if (arg) { comp_perf_free_memory( - &((struct cperf_benchmark_ctx *)arg)->ver.mem); + ((struct cperf_benchmark_ctx *)arg)->ver.options, + &((struct cperf_benchmark_ctx *)arg)->ver.mem); rte_free(arg); } } diff --git a/app/test-compress-perf/comp_perf_test_common.c b/app/test-compress-perf/comp_perf_test_common.c index 7b26734c9..1b8985b43 100644 --- a/app/test-compress-perf/comp_perf_test_common.c +++ b/app/test-compress-perf/comp_perf_test_common.c @@ -77,7 +77,8 @@ find_buf_size(uint32_t input_size) } void -comp_perf_free_memory(struct cperf_mem_resources *mem) +comp_perf_free_memory(struct comp_test_data *test_data, + struct cperf_mem_resources *mem) { uint32_t i; @@ -96,26 +97,162 @@ comp_perf_free_memory(struct cperf_mem_resources *mem) rte_mempool_free(mem->op_pool); rte_mempool_free(mem->decomp_buf_pool); rte_mempool_free(mem->comp_buf_pool); + + /* external mbuf support */ + if (mem->decomp_memzones != NULL) { + for (i = 0; i < test_data->total_segs; i++) + rte_memzone_free(mem->decomp_memzones[i]); + rte_free(mem->decomp_memzones); + } + if (mem->comp_memzones != NULL) { + for (i = 0; i < test_data->total_segs; i++) + rte_memzone_free(mem->comp_memzones[i]); + rte_free(mem->comp_memzones); + } + rte_free(mem->decomp_buf_infos); + rte_free(mem->comp_buf_infos); +} + +static void +comp_perf_extbuf_free_cb(void *addr __rte_unused, void *opaque __rte_unused) +{ +} + +static const struct rte_memzone * +comp_perf_make_memzone(const char *name, struct cperf_mem_resources *mem, + unsigned int number, size_t size) +{ + unsigned int socket_id = rte_socket_id(); + char mz_name[RTE_MEMZONE_NAMESIZE]; + const struct rte_memzone *memzone; + + snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_s%u_d%u_q%u_%d", name, + socket_id, mem->dev_id, mem->qp_id, number); + memzone = rte_memzone_lookup(mz_name); + if (memzone != NULL && memzone->len != size) { + rte_memzone_free(memzone); + memzone = NULL; + } + if (memzone == NULL) { + memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id, + RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE); + if (memzone == NULL) + RTE_LOG(ERR, USER1, "Can't allocate memory zone %s\n", + mz_name); + } + return memzone; +} + +static int +comp_perf_allocate_external_mbufs(struct comp_test_data *test_data, + struct cperf_mem_resources *mem) +{ + uint32_t i; + + mem->comp_memzones = rte_zmalloc_socket(NULL, + test_data->total_segs * sizeof(struct rte_memzone *), + 0, rte_socket_id()); + + if (mem->comp_memzones == NULL) { + RTE_LOG(ERR, USER1, + "Memory to hold the compression memzones could not be allocated\n"); + return -1; + } + + mem->decomp_memzones = rte_zmalloc_socket(NULL, + test_data->total_segs * sizeof(struct rte_memzone *), + 0, rte_socket_id()); + + if (mem->decomp_memzones == NULL) { + RTE_LOG(ERR, USER1, + "Memory to hold the decompression memzones could not be allocated\n"); + return -1; + } + + mem->comp_buf_infos = rte_zmalloc_socket(NULL, + test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info), + 0, rte_socket_id()); + + if (mem->comp_buf_infos == NULL) { + RTE_LOG(ERR, USER1, + "Memory to hold the compression buf infos could not be allocated\n"); + return -1; + } + + mem->decomp_buf_infos = rte_zmalloc_socket(NULL, + test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info), + 0, rte_socket_id()); + + if (mem->decomp_buf_infos == NULL) { + RTE_LOG(ERR, USER1, + "Memory to hold the decompression buf infos could not be allocated\n"); + return -1; + } + + for (i = 0; i < test_data->total_segs; i++) { + mem->comp_memzones[i] = comp_perf_make_memzone("comp", mem, + i, test_data->out_seg_sz); + if (mem->comp_memzones[i] == NULL) { + RTE_LOG(ERR, USER1, + "Memory to hold the compression memzone could not be allocated\n"); + return -1; + } + + mem->decomp_memzones[i] = comp_perf_make_memzone("decomp", mem, + i, test_data->seg_sz); + if (mem->decomp_memzones[i] == NULL) { + RTE_LOG(ERR, USER1, + "Memory to hold the decompression memzone could not be allocated\n"); + return -1; + } + + mem->comp_buf_infos[i].free_cb = + comp_perf_extbuf_free_cb; + mem->comp_buf_infos[i].fcb_opaque = NULL; + rte_mbuf_ext_refcnt_set(&mem->comp_buf_infos[i], 1); + + mem->decomp_buf_infos[i].free_cb = + comp_perf_extbuf_free_cb; + mem->decomp_buf_infos[i].fcb_opaque = NULL; + rte_mbuf_ext_refcnt_set(&mem->decomp_buf_infos[i], 1); + } + + return 0; } int comp_perf_allocate_memory(struct comp_test_data *test_data, struct cperf_mem_resources *mem) { + uint16_t comp_mbuf_size; + uint16_t decomp_mbuf_size; + test_data->out_seg_sz = find_buf_size(test_data->seg_sz); + /* Number of segments for input and output * (compression and decompression) */ - uint32_t total_segs = DIV_CEIL(test_data->input_data_sz, + test_data->total_segs = DIV_CEIL(test_data->input_data_sz, test_data->seg_sz); + + if (test_data->use_external_mbufs != 0) { + if (comp_perf_allocate_external_mbufs(test_data, mem) < 0) + return -1; + comp_mbuf_size = 0; + decomp_mbuf_size = 0; + } else { + comp_mbuf_size = test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM; + decomp_mbuf_size = test_data->seg_sz + RTE_PKTMBUF_HEADROOM; + } + char pool_name[32] = ""; snprintf(pool_name, sizeof(pool_name), "comp_buf_pool_%u_qp_%u", mem->dev_id, mem->qp_id); mem->comp_buf_pool = rte_pktmbuf_pool_create(pool_name, - total_segs, + test_data->total_segs, 0, 0, - test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM, + comp_mbuf_size, rte_socket_id()); if (mem->comp_buf_pool == NULL) { RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n"); @@ -125,15 +262,17 @@ comp_perf_allocate_memory(struct comp_test_data *test_data, snprintf(pool_name, sizeof(pool_name), "decomp_buf_pool_%u_qp_%u", mem->dev_id, mem->qp_id); mem->decomp_buf_pool = rte_pktmbuf_pool_create(pool_name, - total_segs, - 0, 0, test_data->seg_sz + RTE_PKTMBUF_HEADROOM, + test_data->total_segs, + 0, 0, + decomp_mbuf_size, rte_socket_id()); if (mem->decomp_buf_pool == NULL) { RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n"); return -1; } - mem->total_bufs = DIV_CEIL(total_segs, test_data->max_sgl_segs); + mem->total_bufs = DIV_CEIL(test_data->total_segs, + test_data->max_sgl_segs); snprintf(pool_name, sizeof(pool_name), "op_pool_%u_qp_%u", mem->dev_id, mem->qp_id); @@ -151,7 +290,8 @@ comp_perf_allocate_memory(struct comp_test_data *test_data, */ mem->compressed_data = rte_zmalloc_socket(NULL, RTE_MAX( - (size_t) test_data->out_seg_sz * total_segs, + (size_t) test_data->out_seg_sz * + test_data->total_segs, (size_t) MIN_COMPRESSED_BUF_SIZE), 0, rte_socket_id()); @@ -188,7 +328,7 @@ comp_perf_allocate_memory(struct comp_test_data *test_data, return -1; } - buffer_info.total_segments = total_segs; + buffer_info.total_segments = test_data->total_segs; buffer_info.segment_sz = test_data->seg_sz; buffer_info.total_buffs = mem->total_bufs; buffer_info.segments_per_buff = test_data->max_sgl_segs; @@ -206,6 +346,8 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem) uint8_t *data_addr; uint32_t i, j; uint16_t segs_per_mbuf = 0; + uint32_t cmz = 0; + uint32_t dmz = 0; for (i = 0; i < mem->total_bufs; i++) { /* Allocate data in input mbuf and copy data from input file */ @@ -217,6 +359,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem) } data_sz = RTE_MIN(remaining_data, test_data->seg_sz); + + if (test_data->use_external_mbufs != 0) { + rte_pktmbuf_attach_extbuf(mem->decomp_bufs[i], + mem->decomp_memzones[dmz]->addr, + mem->decomp_memzones[dmz]->iova, + test_data->seg_sz, + &mem->decomp_buf_infos[dmz]); + dmz++; + } + data_addr = (uint8_t *) rte_pktmbuf_append( mem->decomp_bufs[i], data_sz); if (data_addr == NULL) { @@ -244,6 +396,17 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem) } data_sz = RTE_MIN(remaining_data, test_data->seg_sz); + + if (test_data->use_external_mbufs != 0) { + rte_pktmbuf_attach_extbuf( + next_seg, + mem->decomp_memzones[dmz]->addr, + mem->decomp_memzones[dmz]->iova, + test_data->seg_sz, + &mem->decomp_buf_infos[dmz]); + dmz++; + } + data_addr = (uint8_t *)rte_pktmbuf_append(next_seg, data_sz); @@ -271,6 +434,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem) RTE_LOG(ERR, USER1, "Could not allocate mbuf\n"); return -1; } + + if (test_data->use_external_mbufs != 0) { + rte_pktmbuf_attach_extbuf(mem->comp_bufs[i], + mem->comp_memzones[cmz]->addr, + mem->comp_memzones[cmz]->iova, + test_data->out_seg_sz, + &mem->comp_buf_infos[cmz]); + cmz++; + } + data_addr = (uint8_t *) rte_pktmbuf_append( mem->comp_bufs[i], test_data->out_seg_sz); @@ -290,6 +463,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem) return -1; } + if (test_data->use_external_mbufs != 0) { + rte_pktmbuf_attach_extbuf( + next_seg, + mem->comp_memzones[cmz]->addr, + mem->comp_memzones[cmz]->iova, + test_data->out_seg_sz, + &mem->comp_buf_infos[cmz]); + cmz++; + } + data_addr = (uint8_t *)rte_pktmbuf_append(next_seg, test_data->out_seg_sz); if (data_addr == NULL) { diff --git a/app/test-compress-perf/comp_perf_test_common.h b/app/test-compress-perf/comp_perf_test_common.h index c9e0c9081..920642888 100644 --- a/app/test-compress-perf/comp_perf_test_common.h +++ b/app/test-compress-perf/comp_perf_test_common.h @@ -26,13 +26,20 @@ struct cperf_mem_resources { struct rte_mempool *comp_buf_pool; struct rte_mempool *decomp_buf_pool; struct rte_mempool *op_pool; + + /* external mbuf support */ + const struct rte_memzone **comp_memzones; + const struct rte_memzone **decomp_memzones; + struct rte_mbuf_ext_shared_info *comp_buf_infos; + struct rte_mbuf_ext_shared_info *decomp_buf_infos; }; int param_range_check(uint16_t size, const struct rte_param_log2_range *range); void -comp_perf_free_memory(struct cperf_mem_resources *mem); +comp_perf_free_memory(struct comp_test_data *test_data, + struct cperf_mem_resources *mem); int comp_perf_allocate_memory(struct comp_test_data *test_data, diff --git a/app/test-compress-perf/comp_perf_test_verify.c b/app/test-compress-perf/comp_perf_test_verify.c index f66f95ff7..758a22ff5 100644 --- a/app/test-compress-perf/comp_perf_test_verify.c +++ b/app/test-compress-perf/comp_perf_test_verify.c @@ -14,7 +14,9 @@ void cperf_verify_test_destructor(void *arg) { if (arg) { - comp_perf_free_memory(&((struct cperf_verify_ctx *)arg)->mem); + comp_perf_free_memory( + ((struct cperf_verify_ctx *)arg)->options, + &((struct cperf_verify_ctx *)arg)->mem); rte_free(arg); } }