From patchwork Tue Feb 14 17:40:29 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Baum X-Patchwork-Id: 123907 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8CA4A41C97; Tue, 14 Feb 2023 18:41:23 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 0DBF042FD4; Tue, 14 Feb 2023 18:41:08 +0100 (CET) Received: from NAM12-DM6-obe.outbound.protection.outlook.com (mail-dm6nam12on2072.outbound.protection.outlook.com [40.107.243.72]) by mails.dpdk.org (Postfix) with ESMTP id 5F6E242FC2 for ; Tue, 14 Feb 2023 18:41:04 +0100 (CET) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=FVZ+Mc1OQrNTj0IFEKSJi7JPhuJmTu/n/AWIF498SuLV3xfZ02M2FqpXQ9cfnEleacL0n3qIQ7wn4Os0NGexoDb9SpAtYq5JnOl8erXlKGXdN8FX8zCSops+i/dR6CK7dd71jr0WqgWDKwaDeBt1aEdqRArXbmQ87YVPDckHXHBakGC2trNHCAJP9XrgdUV7zfOLeUngKRRyKsZs08tuaCn1iwxRgidjLDvtv66/oD2y88R+kTxQG0AQUDlSTdpKeBw+pAyWeeVngF3m9PjQ0081ZURX9vswoNBWcbYwGu8bXsvNSXngyNZhWUY5poCfY6UDExxBPjY9oqsa6zYc0Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=iBf7229B5qzZO8m7qH2Xez65QlTr73N+EUzLsxENPlU=; b=jSki0OqQnLGFZoBlrsZsDbeZXwZs3pqivxz/iwPKhl1IBr+/20NyCpUVk3GZX7mrC0Y6RXl0pf15RRGn5koEe/XShn3yXKjXNCbtVPjfniH+2NIF5mVVI3y+WwV/NR6kxpeixMVqueQosDroOrOhmDy+f5ukp7CpXR+qX4+D4yIzBkkxZ1rzJbjU+ggqGTxW0Ry1b4E7XRvpJ76FXPYXOJbz49h2Lqzd1lDUuQG0ZBCb4G8Ug+MZKieKoBc5H7QXBKAqm/A0tAWrpepOJw0Vr352GzWtmXtu+LxKwZTXX8XW7XvOPZ8oR4fZsqBmvCHHXiXRz7dAd1rEbhVhCdztYQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 216.228.117.160) smtp.rcpttodomain=dpdk.org smtp.mailfrom=nvidia.com; dmarc=pass (p=reject sp=reject pct=100) action=none header.from=nvidia.com; dkim=none (message not signed); arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Nvidia.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=iBf7229B5qzZO8m7qH2Xez65QlTr73N+EUzLsxENPlU=; b=evOgVULiw9d8n69ns2DED3NNeBmyJXkJgxVyNTf7GiNlm7QZ4BEkS+JOjfQDGJxWxkODK55zTGDnrq4elhYCHseZblAknEWLvgDPxemwL5dk2T3Yaq9t1GGWbDLuqyEu9P2aSUBU55dAMdZgWiBUUehV0L3lRTOmItSPJCXl3A33ksd3zjh2gDITbua5bzQ2Wxn4p6tdOtX3/tuA2ukRNW/BR3QAkaB+d0piVRCXpqNigiANhvIbNORxu8/f45/fhMotAxQABwEPeUqvBEtiAJELHnFZVbPUqrBRcFdOwz6Wq8O6wcHEyh4HmMGgni7U1S+QKspgAdauEk3MlXjOog== Received: from BN9P222CA0022.NAMP222.PROD.OUTLOOK.COM (2603:10b6:408:10c::27) by CH0PR12MB5076.namprd12.prod.outlook.com (2603:10b6:610:e3::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6086.17; Tue, 14 Feb 2023 17:41:02 +0000 Received: from BN8NAM11FT099.eop-nam11.prod.protection.outlook.com (2603:10b6:408:10c:cafe::b8) by BN9P222CA0022.outlook.office365.com (2603:10b6:408:10c::27) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6086.24 via Frontend Transport; Tue, 14 Feb 2023 17:41:02 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 216.228.117.160) smtp.mailfrom=nvidia.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=nvidia.com; Received-SPF: Pass (protection.outlook.com: domain of nvidia.com designates 216.228.117.160 as permitted sender) receiver=protection.outlook.com; client-ip=216.228.117.160; helo=mail.nvidia.com; pr=C Received: from mail.nvidia.com (216.228.117.160) by BN8NAM11FT099.mail.protection.outlook.com (10.13.177.197) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6111.10 via Frontend Transport; Tue, 14 Feb 2023 17:41:02 +0000 Received: from rnnvmail202.nvidia.com (10.129.68.7) by mail.nvidia.com (10.129.200.66) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.36; Tue, 14 Feb 2023 09:40:46 -0800 Received: from rnnvmail202.nvidia.com (10.129.68.7) by rnnvmail202.nvidia.com (10.129.68.7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.36; Tue, 14 Feb 2023 09:40:45 -0800 Received: from nvidia.com (10.127.8.13) by mail.nvidia.com (10.129.68.7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.986.36 via Frontend Transport; Tue, 14 Feb 2023 09:40:43 -0800 From: Michael Baum To: CC: Matan Azrad , Akhil Goyal , "Ashish Gupta" , Fiona Trahe , "Thomas Monjalon" Subject: [PATCH v4 4/4] app/test-compress-perf: add algo option Date: Tue, 14 Feb 2023 19:40:29 +0200 Message-ID: <20230214174029.2397125-5-michaelba@nvidia.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20230214174029.2397125-1-michaelba@nvidia.com> References: <20230213061140.2157499-1-michaelba@nvidia.com> <20230214174029.2397125-1-michaelba@nvidia.com> MIME-Version: 1.0 X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN8NAM11FT099:EE_|CH0PR12MB5076:EE_ X-MS-Office365-Filtering-Correlation-Id: 4b5e5689-4d5d-407a-261a-08db0eb2a435 X-LD-Processed: 43083d15-7273-40c1-b7db-39efd9ccc17a,ExtAddr X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: KOU0Gp99FXJ2Ahf+bCs0wTC4G9quEiQG+GSG6oVgP5YsFIkynW3+LpJ2qDYiaz9dqDckgARLoG1iVenRBv3A9Bmqr4oNpLjWZpKhm9N3+zfgUsUkyfbUmf0GyBQ7RqYISCg0Eq85WCvxpp/qgLpg/ywXzZcqOMn3wkHCUJJSoPyP1PVr/SZmwN7d/glAsf21oY1K4NUXK0/GCiLzNQ+8XgiS700iuQYpdh5JHRXsuvGAuaJEn37O2L44qm3NXxdXDqG9ESAOZjvKOKJTUU28L+yJ2ajZc7QH7mqBj/ueAJg9bPnm4m6U080OBz/0PJJxZ8+dFqteCC967v3LjqxOEdbo0S495l92CEokhEMBZS0Dz45euLLapRvMPZBqjE1h/eCdf2IvtUB/Wn2lX4xDqP9DVu3dftzw04i5PtBh/ljDPuEkZJss3nEukMlbzsbhN8VR7wn/tfJbvAyEoQDaFi4SaIJsLTGy0zpVKiuQNG9WO70QRjGMlG6zuiZ5xhlgLkDILr7FL5T4fowMNn52CU7c3RJDC56NAz6IrfOo1drlwK+yOkqzmfHJs4TVkmCe9Zo46JG40B6xuCwk3+1qzFodsqZllMWsBvmo8VlKA6fseB+zu/Me7pg9zwk7BrQj5QVgVii7MZ+OjEKbs8ci8beeyMwKt46VVAx8Nb4SfV9CSSFcLoDCBI7x3/7iheHwKEmTPtbrLnh3PWoz7lJhd/JYhQXvJXVvDPw4F9hoiB5Cf3WfeW+6U6FHE3Eh9wHR X-Forefront-Antispam-Report: CIP:216.228.117.160; CTRY:US; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:mail.nvidia.com; PTR:dc6edge1.nvidia.com; CAT:NONE; SFS:(13230025)(4636009)(39860400002)(346002)(136003)(396003)(376002)(451199018)(46966006)(40470700004)(36840700001)(47076005)(2906002)(4326008)(30864003)(26005)(6916009)(41300700001)(426003)(36756003)(83380400001)(40460700003)(70586007)(2616005)(336012)(5660300002)(36860700001)(70206006)(82310400005)(6286002)(86362001)(54906003)(8936002)(186003)(1076003)(478600001)(8676002)(55016003)(82740400003)(40480700001)(316002)(7696005)(7636003)(356005)(6666004); DIR:OUT; SFP:1101; X-OriginatorOrg: Nvidia.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 14 Feb 2023 17:41:02.2783 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 4b5e5689-4d5d-407a-261a-08db0eb2a435 X-MS-Exchange-CrossTenant-Id: 43083d15-7273-40c1-b7db-39efd9ccc17a X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=43083d15-7273-40c1-b7db-39efd9ccc17a; Ip=[216.228.117.160]; Helo=[mail.nvidia.com] X-MS-Exchange-CrossTenant-AuthSource: BN8NAM11FT099.eop-nam11.prod.protection.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: CH0PR12MB5076 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Add a command line option `algo` to select the compress algorithm supported by the compress API: null (DMA), deflate, lz4 and lzs. Default for deflate. Signed-off-by: Matan Azrad Signed-off-by: Michael Baum --- app/test-compress-perf/comp_perf_options.h | 3 + .../comp_perf_options_parse.c | 75 +++++++++++++++++++ .../comp_perf_test_cyclecount.c | 11 ++- .../comp_perf_test_throughput.c | 11 ++- .../comp_perf_test_verify.c | 11 ++- app/test-compress-perf/main.c | 55 ++++++++++---- doc/guides/tools/comp_perf.rst | 5 ++ 7 files changed, 148 insertions(+), 23 deletions(-) diff --git a/app/test-compress-perf/comp_perf_options.h b/app/test-compress-perf/comp_perf_options.h index d00b299247..828a7309d8 100644 --- a/app/test-compress-perf/comp_perf_options.h +++ b/app/test-compress-perf/comp_perf_options.h @@ -61,8 +61,11 @@ struct comp_test_data { uint16_t max_sgl_segs; uint32_t total_segs; + uint8_t lz4_flags; enum rte_comp_huffman huffman_enc; enum comp_operation test_op; + enum rte_comp_algorithm test_algo; + int window_sz; struct range_list level_lst; uint8_t level; diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c index 303e714cda..6d8c370fc2 100644 --- a/app/test-compress-perf/comp_perf_options_parse.c +++ b/app/test-compress-perf/comp_perf_options_parse.c @@ -25,7 +25,9 @@ #define CPERF_MAX_SGL_SEGS ("max-num-sgl-segs") #define CPERF_NUM_ITER ("num-iter") #define CPERF_OPTYPE ("operation") +#define CPERF_ALGO ("algo") #define CPERF_HUFFMAN_ENC ("huffman-enc") +#define CPERF_LZ4_FLAGS ("lz4-flags") #define CPERF_LEVEL ("compress-level") #define CPERF_WINDOW_SIZE ("window-sz") #define CPERF_EXTERNAL_MBUFS ("external-mbufs") @@ -56,8 +58,11 @@ usage(char *progname) " compressed/decompressed (default: 10000)\n" " --operation [comp/decomp/comp_and_decomp]: perform test on\n" " compression, decompression or both operations\n" + " --algo [null/deflate/lzs/lz4]: perform test on algorithm\n" + " null(DMA), deflate, lzs or lz4 (default: deflate)\n" " --huffman-enc [fixed/dynamic/default]: Huffman encoding\n" " (default: dynamic)\n" + " --lz4-flags N: flags to configure LZ4 algorithm (default: 0)\n" " --compress-level N: compression level, which could be a single value, list or range\n" " (default: range between 1 and 9)\n" " --window-sz N: base two log value of compression window size\n" @@ -150,6 +155,23 @@ parse_uint16_t(uint16_t *value, const char *arg) return 0; } +static int +parse_uint8_t(uint8_t *value, const char *arg) +{ + uint32_t val = 0; + int ret = parse_uint32_t(&val, arg); + + if (ret < 0) + return ret; + + if (val > UINT8_MAX) + return -ERANGE; + + *value = (uint8_t) val; + + return 0; +} + static int parse_range(const char *arg, uint8_t *min, uint8_t *max, uint8_t *inc) { @@ -470,6 +492,40 @@ parse_op_type(struct comp_test_data *test_data, const char *arg) return 0; } +static int +parse_algo(struct comp_test_data *test_data, const char *arg) +{ + struct name_id_map algo_namemap[] = { + { + "null", + RTE_COMP_ALGO_NULL + }, + { + "deflate", + RTE_COMP_ALGO_DEFLATE + }, + { + "lzs", + RTE_COMP_ALGO_LZS + }, + { + "lz4", + RTE_COMP_ALGO_LZ4 + } + }; + + int id = get_str_key_id_mapping(algo_namemap, + RTE_DIM(algo_namemap), arg); + if (id < 0) { + RTE_LOG(ERR, USER1, "Invalid algorithm specified\n"); + return -1; + } + + test_data->test_algo = (enum rte_comp_algorithm)id; + + return 0; +} + static int parse_huffman_enc(struct comp_test_data *test_data, const char *arg) { @@ -500,6 +556,19 @@ parse_huffman_enc(struct comp_test_data *test_data, const char *arg) return 0; } +static int +parse_lz4_flags(struct comp_test_data *test_data, const char *arg) +{ + int ret = parse_uint8_t(&test_data->lz4_flags, arg); + + if (ret) { + RTE_LOG(ERR, USER1, "Failed to parse LZ4 flags\n"); + return -1; + } + + return 0; +} + static int parse_level(struct comp_test_data *test_data, const char *arg) { @@ -572,7 +641,9 @@ static struct option lgopts[] = { { CPERF_MAX_SGL_SEGS, required_argument, 0, 0}, { CPERF_NUM_ITER, required_argument, 0, 0 }, { CPERF_OPTYPE, required_argument, 0, 0 }, + { CPERF_ALGO, required_argument, 0, 0 }, { CPERF_HUFFMAN_ENC, required_argument, 0, 0 }, + { CPERF_LZ4_FLAGS, required_argument, 0, 0 }, { CPERF_LEVEL, required_argument, 0, 0 }, { CPERF_WINDOW_SIZE, required_argument, 0, 0 }, { CPERF_EXTERNAL_MBUFS, 0, 0, 0 }, @@ -594,7 +665,9 @@ comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data) { CPERF_MAX_SGL_SEGS, parse_max_num_sgl_segs }, { CPERF_NUM_ITER, parse_num_iter }, { CPERF_OPTYPE, parse_op_type }, + { CPERF_ALGO, parse_algo }, { CPERF_HUFFMAN_ENC, parse_huffman_enc }, + { CPERF_LZ4_FLAGS, parse_lz4_flags }, { CPERF_LEVEL, parse_level }, { CPERF_WINDOW_SIZE, parse_window_sz }, { CPERF_EXTERNAL_MBUFS, parse_external_mbufs }, @@ -647,8 +720,10 @@ comp_perf_options_default(struct comp_test_data *test_data) test_data->pool_sz = 8192; test_data->max_sgl_segs = 16; test_data->num_iter = 10000; + test_data->lz4_flags = 0; test_data->huffman_enc = RTE_COMP_HUFFMAN_DYNAMIC; test_data->test_op = COMPRESS_DECOMPRESS; + test_data->test_algo = RTE_COMP_ALGO_DEFLATE; test_data->window_sz = -1; test_data->level_lst.min = RTE_COMP_LEVEL_MIN; test_data->level_lst.max = RTE_COMP_LEVEL_MAX; diff --git a/app/test-compress-perf/comp_perf_test_cyclecount.c b/app/test-compress-perf/comp_perf_test_cyclecount.c index ce6c4d7605..4d336ec8d6 100644 --- a/app/test-compress-perf/comp_perf_test_cyclecount.c +++ b/app/test-compress-perf/comp_perf_test_cyclecount.c @@ -193,14 +193,17 @@ main_loop(struct cperf_cyclecount_ctx *ctx, enum rte_comp_xform_type type) xform = (struct rte_comp_xform) { .type = RTE_COMP_COMPRESS, .compress = { - .algo = RTE_COMP_ALGO_DEFLATE, - .deflate.huffman = test_data->huffman_enc, + .algo = test_data->test_algo, .level = test_data->level, .window_size = test_data->window_sz, .chksum = RTE_COMP_CHECKSUM_NONE, .hash_algo = RTE_COMP_HASH_ALGO_NONE } }; + if (test_data->test_algo == RTE_COMP_ALGO_DEFLATE) + xform.compress.deflate.huffman = test_data->huffman_enc; + else if (test_data->test_algo == RTE_COMP_ALGO_LZ4) + xform.compress.lz4.flags = test_data->lz4_flags; input_bufs = mem->decomp_bufs; output_bufs = mem->comp_bufs; out_seg_sz = test_data->out_seg_sz; @@ -208,12 +211,14 @@ main_loop(struct cperf_cyclecount_ctx *ctx, enum rte_comp_xform_type type) xform = (struct rte_comp_xform) { .type = RTE_COMP_DECOMPRESS, .decompress = { - .algo = RTE_COMP_ALGO_DEFLATE, + .algo = test_data->test_algo, .chksum = RTE_COMP_CHECKSUM_NONE, .window_size = test_data->window_sz, .hash_algo = RTE_COMP_HASH_ALGO_NONE } }; + if (test_data->test_algo == RTE_COMP_ALGO_LZ4) + xform.decompress.lz4.flags = test_data->lz4_flags; input_bufs = mem->comp_bufs; output_bufs = mem->decomp_bufs; out_seg_sz = test_data->seg_sz; diff --git a/app/test-compress-perf/comp_perf_test_throughput.c b/app/test-compress-perf/comp_perf_test_throughput.c index c9f8237626..1f7072d223 100644 --- a/app/test-compress-perf/comp_perf_test_throughput.c +++ b/app/test-compress-perf/comp_perf_test_throughput.c @@ -84,14 +84,17 @@ main_loop(struct cperf_benchmark_ctx *ctx, enum rte_comp_xform_type type) xform = (struct rte_comp_xform) { .type = RTE_COMP_COMPRESS, .compress = { - .algo = RTE_COMP_ALGO_DEFLATE, - .deflate.huffman = test_data->huffman_enc, + .algo = test_data->test_algo, .level = test_data->level, .window_size = test_data->window_sz, .chksum = RTE_COMP_CHECKSUM_NONE, .hash_algo = RTE_COMP_HASH_ALGO_NONE } }; + if (test_data->test_algo == RTE_COMP_ALGO_DEFLATE) + xform.compress.deflate.huffman = test_data->huffman_enc; + else if (test_data->test_algo == RTE_COMP_ALGO_LZ4) + xform.compress.lz4.flags = test_data->lz4_flags; input_bufs = mem->decomp_bufs; output_bufs = mem->comp_bufs; out_seg_sz = test_data->out_seg_sz; @@ -99,12 +102,14 @@ main_loop(struct cperf_benchmark_ctx *ctx, enum rte_comp_xform_type type) xform = (struct rte_comp_xform) { .type = RTE_COMP_DECOMPRESS, .decompress = { - .algo = RTE_COMP_ALGO_DEFLATE, + .algo = test_data->test_algo, .chksum = RTE_COMP_CHECKSUM_NONE, .window_size = test_data->window_sz, .hash_algo = RTE_COMP_HASH_ALGO_NONE } }; + if (test_data->test_algo == RTE_COMP_ALGO_LZ4) + xform.decompress.lz4.flags = test_data->lz4_flags; input_bufs = mem->comp_bufs; output_bufs = mem->decomp_bufs; out_seg_sz = test_data->seg_sz; diff --git a/app/test-compress-perf/comp_perf_test_verify.c b/app/test-compress-perf/comp_perf_test_verify.c index 7d6b6abecd..7bd18073cf 100644 --- a/app/test-compress-perf/comp_perf_test_verify.c +++ b/app/test-compress-perf/comp_perf_test_verify.c @@ -87,14 +87,17 @@ main_loop(struct cperf_verify_ctx *ctx, enum rte_comp_xform_type type) xform = (struct rte_comp_xform) { .type = RTE_COMP_COMPRESS, .compress = { - .algo = RTE_COMP_ALGO_DEFLATE, - .deflate.huffman = test_data->huffman_enc, + .algo = test_data->test_algo, .level = test_data->level, .window_size = test_data->window_sz, .chksum = RTE_COMP_CHECKSUM_NONE, .hash_algo = RTE_COMP_HASH_ALGO_NONE } }; + if (test_data->test_algo == RTE_COMP_ALGO_DEFLATE) + xform.compress.deflate.huffman = test_data->huffman_enc; + else if (test_data->test_algo == RTE_COMP_ALGO_LZ4) + xform.compress.lz4.flags = test_data->lz4_flags; output_data_ptr = ctx->mem.compressed_data; output_data_sz = &ctx->comp_data_sz; input_bufs = mem->decomp_bufs; @@ -104,12 +107,14 @@ main_loop(struct cperf_verify_ctx *ctx, enum rte_comp_xform_type type) xform = (struct rte_comp_xform) { .type = RTE_COMP_DECOMPRESS, .decompress = { - .algo = RTE_COMP_ALGO_DEFLATE, + .algo = test_data->test_algo, .chksum = RTE_COMP_CHECKSUM_NONE, .window_size = test_data->window_sz, .hash_algo = RTE_COMP_HASH_ALGO_NONE } }; + if (test_data->test_algo == RTE_COMP_ALGO_LZ4) + xform.decompress.lz4.flags = test_data->lz4_flags; output_data_ptr = ctx->mem.decompressed_data; output_data_sz = &ctx->decomp_data_sz; input_bufs = mem->comp_bufs; diff --git a/app/test-compress-perf/main.c b/app/test-compress-perf/main.c index bbb4c7917b..fa366123ed 100644 --- a/app/test-compress-perf/main.c +++ b/app/test-compress-perf/main.c @@ -57,29 +57,56 @@ comp_perf_check_capabilities(struct comp_test_data *test_data, uint8_t cdev_id) { const struct rte_compressdev_capabilities *cap; - cap = rte_compressdev_capability_get(cdev_id, - RTE_COMP_ALGO_DEFLATE); + cap = rte_compressdev_capability_get(cdev_id, test_data->test_algo); if (cap == NULL) { RTE_LOG(ERR, USER1, - "Compress device does not support DEFLATE\n"); + "Compress device does not support %u algorithm\n", + test_data->test_algo); return -1; } uint64_t comp_flags = cap->comp_feature_flags; - /* Huffman encoding */ - if (test_data->huffman_enc == RTE_COMP_HUFFMAN_FIXED && - (comp_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) { - RTE_LOG(ERR, USER1, - "Compress device does not supported Fixed Huffman\n"); - return -1; - } + /* Algorithm type */ + switch (test_data->test_algo) { + case RTE_COMP_ALGO_DEFLATE: + /* Huffman encoding */ + if (test_data->huffman_enc == RTE_COMP_HUFFMAN_FIXED && + (comp_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) { + RTE_LOG(ERR, USER1, + "Compress device does not supported Fixed Huffman\n"); + return -1; + } - if (test_data->huffman_enc == RTE_COMP_HUFFMAN_DYNAMIC && - (comp_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) { - RTE_LOG(ERR, USER1, - "Compress device does not supported Dynamic Huffman\n"); + if (test_data->huffman_enc == RTE_COMP_HUFFMAN_DYNAMIC && + (comp_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) { + RTE_LOG(ERR, USER1, + "Compress device does not supported Dynamic Huffman\n"); + return -1; + } + break; + case RTE_COMP_ALGO_LZ4: + /* LZ4 flags */ + if ((test_data->lz4_flags & RTE_COMP_LZ4_FLAG_BLOCK_CHECKSUM) && + (comp_flags & RTE_COMP_FF_LZ4_BLOCK_WITH_CHECKSUM) == 0) { + RTE_LOG(ERR, USER1, + "Compress device does not support LZ4 block with checksum\n"); + return -1; + } + + if ((test_data->lz4_flags & + RTE_COMP_LZ4_FLAG_BLOCK_INDEPENDENCE) && + (comp_flags & RTE_COMP_FF_LZ4_BLOCK_INDEPENDENCE) == 0) { + RTE_LOG(ERR, USER1, + "Compress device does not support LZ4 independent blocks\n"); + return -1; + } + break; + case RTE_COMP_ALGO_LZS: + case RTE_COMP_ALGO_NULL: + break; + default: return -1; } diff --git a/doc/guides/tools/comp_perf.rst b/doc/guides/tools/comp_perf.rst index 9d2f4dbe4a..5eb05a095c 100644 --- a/doc/guides/tools/comp_perf.rst +++ b/doc/guides/tools/comp_perf.rst @@ -84,8 +84,13 @@ Application Options ``--operation [comp/decomp/comp_and_decomp]``: perform test on compression, decompression or both operations + ``--algo [null/deflate/lzs/lz4]`` : perform test on algorithm null(DMA), Deflate, lzs or lz4 (default: Deflate) + ``--huffman-enc [fixed/dynamic/default]``: Huffman encoding (default: dynamic) + ``--lz4-flags N``: flags to for LZ4 parameters, + see `LZ4 Frame Descriptor `_ (default: no flags) + ``--compress-level N``: compression level, which could be a single value, list or range (default: range between 1 and 9) ``--window-sz N``: base two log value of compression window size (default: max supported by PMD)