app/compress-perf: add parser
authorTomasz Jozwiak <tomaszx.jozwiak@intel.com>
Wed, 12 Dec 2018 12:08:01 +0000 (13:08 +0100)
committerAkhil Goyal <akhil.goyal@nxp.com>
Wed, 19 Dec 2018 10:19:10 +0000 (11:19 +0100)
Added parser part into compression perf. test.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Signed-off-by: Tomasz Jozwiak <tomaszx.jozwiak@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>
Acked-by: Lee Daly <lee.daly@intel.com>
Acked-by: Shally Verma <shally.verma@caviumnetworks.com>
app/Makefile
app/meson.build
app/test-compress-perf/Makefile [new file with mode: 0644]
app/test-compress-perf/comp_perf_options.h [new file with mode: 0644]
app/test-compress-perf/comp_perf_options_parse.c [new file with mode: 0644]
app/test-compress-perf/main.c [new file with mode: 0644]
app/test-compress-perf/meson.build [new file with mode: 0644]
config/common_base

index 069fa98..d6641ef 100644 (file)
@@ -11,6 +11,10 @@ ifeq ($(CONFIG_RTE_LIBRTE_BBDEV),y)
 DIRS-$(CONFIG_RTE_TEST_BBDEV) += test-bbdev
 endif
 
+ifeq ($(CONFIG_RTE_LIBRTE_COMPRESSDEV),y)
+DIRS-$(CONFIG_RTE_APP_COMPRESS_PERF) += test-compress-perf
+endif
+
 ifeq ($(CONFIG_RTE_LIBRTE_CRYPTODEV),y)
 DIRS-$(CONFIG_RTE_APP_CRYPTO_PERF) += test-crypto-perf
 endif
index a9a026b..47a2a86 100644 (file)
@@ -4,6 +4,7 @@
 apps = ['pdump',
        'proc-info',
        'test-bbdev',
+       'test-compress-perf',
        'test-crypto-perf',
        'test-eventdev',
        'test-pmd']
diff --git a/app/test-compress-perf/Makefile b/app/test-compress-perf/Makefile
new file mode 100644 (file)
index 0000000..8aa7a22
--- /dev/null
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2018 Intel Corporation
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+APP = dpdk-test-compress-perf
+
+CFLAGS += $(WERROR_FLAGS)
+CFLAGS += -DALLOW_EXPERIMENTAL_API
+CFLAGS += -O3
+
+# all source are stored in SRCS-y
+SRCS-y := main.c
+SRCS-y += comp_perf_options_parse.c
+
+include $(RTE_SDK)/mk/rte.app.mk
diff --git a/app/test-compress-perf/comp_perf_options.h b/app/test-compress-perf/comp_perf_options.h
new file mode 100644 (file)
index 0000000..7516ea0
--- /dev/null
@@ -0,0 +1,59 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2018 Intel Corporation
+ */
+
+#define MAX_DRIVER_NAME                64
+#define MAX_INPUT_FILE_NAME    64
+#define MAX_LIST               32
+
+enum comp_operation {
+       COMPRESS_ONLY,
+       DECOMPRESS_ONLY,
+       COMPRESS_DECOMPRESS
+};
+
+struct range_list {
+       uint8_t min;
+       uint8_t max;
+       uint8_t inc;
+       uint8_t count;
+       uint8_t list[MAX_LIST];
+};
+
+struct comp_test_data {
+       char driver_name[64];
+       char input_file[64];
+       struct rte_mbuf **comp_bufs;
+       struct rte_mbuf **decomp_bufs;
+       uint32_t total_bufs;
+       uint8_t *input_data;
+       size_t input_data_sz;
+       uint8_t *compressed_data;
+       uint8_t *decompressed_data;
+       struct rte_mempool *comp_buf_pool;
+       struct rte_mempool *decomp_buf_pool;
+       struct rte_mempool *op_pool;
+       int8_t cdev_id;
+       uint16_t seg_sz;
+       uint16_t burst_sz;
+       uint32_t pool_sz;
+       uint32_t num_iter;
+       uint16_t max_sgl_segs;
+       enum rte_comp_huffman huffman_enc;
+       enum comp_operation test_op;
+       int window_sz;
+       struct range_list level;
+       /* Store TSC duration for all levels (including level 0) */
+       uint64_t comp_tsc_duration[RTE_COMP_LEVEL_MAX + 1];
+       uint64_t decomp_tsc_duration[RTE_COMP_LEVEL_MAX + 1];
+};
+
+int
+comp_perf_options_parse(struct comp_test_data *test_data, int argc,
+                       char **argv);
+
+void
+comp_perf_options_default(struct comp_test_data *test_data);
+
+int
+comp_perf_options_check(struct comp_test_data *test_data);
diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c
new file mode 100644 (file)
index 0000000..7f1a7ff
--- /dev/null
@@ -0,0 +1,592 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2018 Intel Corporation
+ */
+
+#include <getopt.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <rte_string_fns.h>
+#include <rte_comp.h>
+
+#include "comp_perf_options.h"
+
+#define CPERF_DRIVER_NAME      ("driver-name")
+#define CPERF_TEST_FILE                ("input-file")
+#define CPERF_SEG_SIZE         ("seg-sz")
+#define CPERF_BURST_SIZE       ("burst-sz")
+#define CPERF_EXTENDED_SIZE    ("extended-input-sz")
+#define CPERF_POOL_SIZE                ("pool-sz")
+#define CPERF_MAX_SGL_SEGS     ("max-num-sgl-segs")
+#define CPERF_NUM_ITER         ("num-iter")
+#define CPERF_OPTYPE           ("operation")
+#define CPERF_HUFFMAN_ENC      ("huffman-enc")
+#define CPERF_LEVEL            ("compress-level")
+#define CPERF_WINDOW_SIZE      ("window-sz")
+
+struct name_id_map {
+       const char *name;
+       uint32_t id;
+};
+
+static void
+usage(char *progname)
+{
+       printf("%s [EAL options] --\n"
+               " --driver-name NAME: compress driver to use\n"
+               " --input-file NAME: file to compress and decompress\n"
+               " --extended-input-sz N: extend file data up to this size (default: no extension)\n"
+               " --seg-sz N: size of segment to store the data (default: 2048)\n"
+               " --burst-sz N: compress operation burst size\n"
+               " --pool-sz N: mempool size for compress operations/mbufs\n"
+               "               (default: 8192)\n"
+               " --max-num-sgl-segs N: maximum number of segments for each mbuf\n"
+               "               (default: 16)\n"
+               " --num-iter N: number of times the file will be\n"
+               "               compressed/decompressed (default: 10000)\n"
+               " --operation [comp/decomp/comp_and_decomp]: perform test on\n"
+               "               compression, decompression or both operations\n"
+               " --huffman-enc [fixed/default]: Huffman encoding\n"
+               "               (default: fixed)\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"
+               "               (e.g.: 15 => 32k, default: max supported by PMD)\n"
+               " -h: prints this help\n",
+               progname);
+}
+
+static int
+get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
+               const char *str_key)
+{
+       unsigned int i;
+
+       for (i = 0; i < map_len; i++) {
+
+               if (strcmp(str_key, map[i].name) == 0)
+                       return map[i].id;
+       }
+
+       return -1;
+}
+
+static int
+parse_uint32_t(uint32_t *value, const char *arg)
+{
+       char *end = NULL;
+       unsigned long n = strtoul(arg, &end, 10);
+
+       if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0'))
+               return -1;
+
+       if (n > UINT32_MAX)
+               return -ERANGE;
+
+       *value = (uint32_t) n;
+
+       return 0;
+}
+
+static int
+parse_uint16_t(uint16_t *value, const char *arg)
+{
+       uint32_t val = 0;
+       int ret = parse_uint32_t(&val, arg);
+
+       if (ret < 0)
+               return ret;
+
+       if (val > UINT16_MAX)
+               return -ERANGE;
+
+       *value = (uint16_t) val;
+
+       return 0;
+}
+
+static int
+parse_range(const char *arg, uint8_t *min, uint8_t *max, uint8_t *inc)
+{
+       char *token;
+       uint8_t number;
+
+       char *copy_arg = strdup(arg);
+
+       if (copy_arg == NULL)
+               return -1;
+
+       errno = 0;
+       token = strtok(copy_arg, ":");
+
+       /* Parse minimum value */
+       if (token != NULL) {
+               number = strtoul(token, NULL, 10);
+
+               if (errno == EINVAL || errno == ERANGE)
+                       goto err_range;
+
+               *min = number;
+       } else
+               goto err_range;
+
+       token = strtok(NULL, ":");
+
+       /* Parse increment value */
+       if (token != NULL) {
+               number = strtoul(token, NULL, 10);
+
+               if (errno == EINVAL || errno == ERANGE ||
+                               number == 0)
+                       goto err_range;
+
+               *inc = number;
+       } else
+               goto err_range;
+
+       token = strtok(NULL, ":");
+
+       /* Parse maximum value */
+       if (token != NULL) {
+               number = strtoul(token, NULL, 10);
+
+               if (errno == EINVAL || errno == ERANGE ||
+                               number < *min)
+                       goto err_range;
+
+               *max = number;
+       } else
+               goto err_range;
+
+       if (strtok(NULL, ":") != NULL)
+               goto err_range;
+
+       free(copy_arg);
+       return 0;
+
+err_range:
+       free(copy_arg);
+       return -1;
+}
+
+static int
+parse_list(const char *arg, uint8_t *list, uint8_t *min, uint8_t *max)
+{
+       char *token;
+       uint32_t number;
+       uint8_t count = 0;
+       uint32_t temp_min;
+       uint32_t temp_max;
+
+       char *copy_arg = strdup(arg);
+
+       if (copy_arg == NULL)
+               return -1;
+
+       errno = 0;
+       token = strtok(copy_arg, ",");
+
+       /* Parse first value */
+       if (token != NULL) {
+               number = strtoul(token, NULL, 10);
+
+               if (errno == EINVAL || errno == ERANGE)
+                       goto err_list;
+
+               list[count++] = number;
+               temp_min = number;
+               temp_max = number;
+       } else
+               goto err_list;
+
+       token = strtok(NULL, ",");
+
+       while (token != NULL) {
+               if (count == MAX_LIST) {
+                       RTE_LOG(WARNING, USER1,
+                               "Using only the first %u sizes\n",
+                                       MAX_LIST);
+                       break;
+               }
+
+               number = strtoul(token, NULL, 10);
+
+               if (errno == EINVAL || errno == ERANGE)
+                       goto err_list;
+
+               list[count++] = number;
+
+               if (number < temp_min)
+                       temp_min = number;
+               if (number > temp_max)
+                       temp_max = number;
+
+               token = strtok(NULL, ",");
+       }
+
+       if (min)
+               *min = temp_min;
+       if (max)
+               *max = temp_max;
+
+       free(copy_arg);
+       return count;
+
+err_list:
+       free(copy_arg);
+       return -1;
+}
+
+static int
+parse_num_iter(struct comp_test_data *test_data, const char *arg)
+{
+       int ret = parse_uint32_t(&test_data->num_iter, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1, "Failed to parse total iteration count\n");
+               return -1;
+       }
+
+       if (test_data->num_iter == 0) {
+               RTE_LOG(ERR, USER1,
+                               "Total number of iterations must be higher than 0\n");
+               return -1;
+       }
+
+       return ret;
+}
+
+static int
+parse_pool_sz(struct comp_test_data *test_data, const char *arg)
+{
+       int ret = parse_uint32_t(&test_data->pool_sz, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1, "Failed to parse pool size");
+               return -1;
+       }
+
+       if (test_data->pool_sz == 0) {
+               RTE_LOG(ERR, USER1, "Pool size must be higher than 0\n");
+               return -1;
+       }
+
+       return ret;
+}
+
+static int
+parse_burst_sz(struct comp_test_data *test_data, const char *arg)
+{
+       int ret = parse_uint16_t(&test_data->burst_sz, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1, "Failed to parse burst size/s\n");
+               return -1;
+       }
+
+       if (test_data->burst_sz == 0) {
+               RTE_LOG(ERR, USER1, "Burst size must be higher than 0\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+parse_extended_input_sz(struct comp_test_data *test_data, const char *arg)
+{
+       uint32_t tmp;
+       int ret = parse_uint32_t(&tmp, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1, "Failed to parse extended input size\n");
+               return -1;
+       }
+       test_data->input_data_sz = tmp;
+
+       if (tmp == 0) {
+               RTE_LOG(ERR, USER1,
+                       "Extended file size must be higher than 0\n");
+               return -1;
+       }
+       return 0;
+}
+
+static int
+parse_seg_sz(struct comp_test_data *test_data, const char *arg)
+{
+       int ret = parse_uint16_t(&test_data->seg_sz, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1, "Failed to parse segment size\n");
+               return -1;
+       }
+
+       if (test_data->seg_sz == 0) {
+               RTE_LOG(ERR, USER1, "Segment size must be higher than 0\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+parse_max_num_sgl_segs(struct comp_test_data *test_data, const char *arg)
+{
+       int ret = parse_uint16_t(&test_data->max_sgl_segs, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1,
+                       "Failed to parse max number of segments per mbuf chain\n");
+               return -1;
+       }
+
+       if (test_data->max_sgl_segs == 0) {
+               RTE_LOG(ERR, USER1, "Max number of segments per mbuf chain "
+                       "must be higher than 0\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+parse_window_sz(struct comp_test_data *test_data, const char *arg)
+{
+       int ret = parse_uint16_t((uint16_t *)&test_data->window_sz, arg);
+
+       if (ret) {
+               RTE_LOG(ERR, USER1, "Failed to parse window size\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+static int
+parse_driver_name(struct comp_test_data *test_data, const char *arg)
+{
+       if (strlen(arg) > (sizeof(test_data->driver_name) - 1))
+               return -1;
+
+       rte_strlcpy(test_data->driver_name, arg,
+                       sizeof(test_data->driver_name));
+
+       return 0;
+}
+
+static int
+parse_test_file(struct comp_test_data *test_data, const char *arg)
+{
+       if (strlen(arg) > (sizeof(test_data->input_file) - 1))
+               return -1;
+
+       rte_strlcpy(test_data->input_file, arg, sizeof(test_data->input_file));
+
+       return 0;
+}
+
+static int
+parse_op_type(struct comp_test_data *test_data, const char *arg)
+{
+       struct name_id_map optype_namemap[] = {
+               {
+                       "comp",
+                       COMPRESS_ONLY
+               },
+               {
+                       "decomp",
+                       DECOMPRESS_ONLY
+               },
+               {
+                       "comp_and_decomp",
+                       COMPRESS_DECOMPRESS
+               }
+       };
+
+       int id = get_str_key_id_mapping(optype_namemap,
+                       RTE_DIM(optype_namemap), arg);
+       if (id < 0) {
+               RTE_LOG(ERR, USER1, "Invalid operation type specified\n");
+               return -1;
+       }
+
+       test_data->test_op = (enum comp_operation)id;
+
+       return 0;
+}
+
+static int
+parse_huffman_enc(struct comp_test_data *test_data, const char *arg)
+{
+       struct name_id_map huffman_namemap[] = {
+               {
+                       "default",
+                       RTE_COMP_HUFFMAN_DEFAULT
+               },
+               {
+                       "fixed",
+                       RTE_COMP_HUFFMAN_FIXED
+               }
+       };
+
+       int id = get_str_key_id_mapping(huffman_namemap,
+                       RTE_DIM(huffman_namemap), arg);
+       if (id < 0) {
+               RTE_LOG(ERR, USER1, "Invalid Huffmane encoding specified\n");
+               return -1;
+       }
+
+       test_data->huffman_enc = (enum rte_comp_huffman)id;
+
+       return 0;
+}
+
+static int
+parse_level(struct comp_test_data *test_data, const char *arg)
+{
+       int ret;
+
+       /*
+        * Try parsing the argument as a range, if it fails,
+        * arse it as a list
+        */
+       if (parse_range(arg, &test_data->level.min, &test_data->level.max,
+                       &test_data->level.inc) < 0) {
+               ret = parse_list(arg, test_data->level.list,
+                                       &test_data->level.min,
+                                       &test_data->level.max);
+               if (ret < 0) {
+                       RTE_LOG(ERR, USER1,
+                               "Failed to parse compression level/s\n");
+                       return -1;
+               }
+               test_data->level.count = ret;
+
+               if (test_data->level.max > RTE_COMP_LEVEL_MAX) {
+                       RTE_LOG(ERR, USER1, "Level cannot be higher than %u\n",
+                                       RTE_COMP_LEVEL_MAX);
+                       return -1;
+               }
+       }
+
+       return 0;
+}
+
+typedef int (*option_parser_t)(struct comp_test_data *test_data,
+               const char *arg);
+
+struct long_opt_parser {
+       const char *lgopt_name;
+       option_parser_t parser_fn;
+
+};
+
+static struct option lgopts[] = {
+
+       { CPERF_DRIVER_NAME, required_argument, 0, 0 },
+       { CPERF_TEST_FILE, required_argument, 0, 0 },
+       { CPERF_SEG_SIZE, required_argument, 0, 0 },
+       { CPERF_BURST_SIZE, required_argument, 0, 0 },
+       { CPERF_EXTENDED_SIZE, required_argument, 0, 0 },
+       { CPERF_POOL_SIZE, required_argument, 0, 0 },
+       { CPERF_MAX_SGL_SEGS, required_argument, 0, 0},
+       { CPERF_NUM_ITER, required_argument, 0, 0 },
+       { CPERF_OPTYPE, required_argument, 0, 0 },
+       { CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
+       { CPERF_LEVEL, required_argument, 0, 0 },
+       { CPERF_WINDOW_SIZE, required_argument, 0, 0 },
+       { NULL, 0, 0, 0 }
+};
+static int
+comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
+{
+       struct long_opt_parser parsermap[] = {
+               { CPERF_DRIVER_NAME,    parse_driver_name },
+               { CPERF_TEST_FILE,      parse_test_file },
+               { CPERF_SEG_SIZE,       parse_seg_sz },
+               { CPERF_BURST_SIZE,     parse_burst_sz },
+               { CPERF_EXTENDED_SIZE,  parse_extended_input_sz },
+               { CPERF_POOL_SIZE,      parse_pool_sz },
+               { CPERF_MAX_SGL_SEGS,   parse_max_num_sgl_segs },
+               { CPERF_NUM_ITER,       parse_num_iter },
+               { CPERF_OPTYPE,         parse_op_type },
+               { CPERF_HUFFMAN_ENC,    parse_huffman_enc },
+               { CPERF_LEVEL,          parse_level },
+               { CPERF_WINDOW_SIZE,    parse_window_sz },
+       };
+       unsigned int i;
+
+       for (i = 0; i < RTE_DIM(parsermap); i++) {
+               if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
+                               strlen(lgopts[opt_idx].name)) == 0)
+                       return parsermap[i].parser_fn(test_data, optarg);
+       }
+
+       return -EINVAL;
+}
+
+int
+comp_perf_options_parse(struct comp_test_data *test_data, int argc, char **argv)
+{
+       int opt, retval, opt_idx;
+
+       while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) {
+               switch (opt) {
+               case 'h':
+                       usage(argv[0]);
+                       rte_exit(EXIT_SUCCESS, "Displayed help\n");
+                       break;
+               /* long options */
+               case 0:
+                       retval = comp_perf_opts_parse_long(opt_idx, test_data);
+                       if (retval != 0)
+                               return retval;
+
+                       break;
+
+               default:
+                       usage(argv[0]);
+                       return -EINVAL;
+               }
+       }
+
+       return 0;
+}
+
+void
+comp_perf_options_default(struct comp_test_data *test_data)
+{
+       test_data->cdev_id = -1;
+       test_data->seg_sz = 2048;
+       test_data->burst_sz = 32;
+       test_data->pool_sz = 8192;
+       test_data->max_sgl_segs = UINT16_MAX;
+       test_data->num_iter = 10000;
+       test_data->huffman_enc = RTE_COMP_HUFFMAN_FIXED;
+       test_data->test_op = COMPRESS_DECOMPRESS;
+       test_data->window_sz = -1;
+       test_data->level.min = 1;
+       test_data->level.max = 9;
+       test_data->level.inc = 1;
+}
+
+int
+comp_perf_options_check(struct comp_test_data *test_data)
+{
+       if (test_data->driver_name[0] == '\0') {
+               RTE_LOG(ERR, USER1, "Driver name has to be set\n");
+               return -1;
+       }
+
+       if (test_data->input_file[0] == '\0') {
+               RTE_LOG(ERR, USER1, "Input file name has to be set\n");
+               return -1;
+       }
+
+       return 0;
+}
diff --git a/app/test-compress-perf/main.c b/app/test-compress-perf/main.c
new file mode 100644 (file)
index 0000000..f52b98d
--- /dev/null
@@ -0,0 +1,52 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2018 Intel Corporation
+ */
+
+#include <rte_malloc.h>
+#include <rte_eal.h>
+#include <rte_log.h>
+#include <rte_compressdev.h>
+
+#include "comp_perf_options.h"
+
+int
+main(int argc, char **argv)
+{
+       int ret;
+       struct comp_test_data *test_data;
+
+       /* Initialise DPDK EAL */
+       ret = rte_eal_init(argc, argv);
+       if (ret < 0)
+               rte_exit(EXIT_FAILURE, "Invalid EAL arguments!\n");
+       argc -= ret;
+       argv += ret;
+
+       test_data = rte_zmalloc_socket(NULL, sizeof(struct comp_test_data),
+                                       0, rte_socket_id());
+
+       if (test_data == NULL)
+               rte_exit(EXIT_FAILURE, "Cannot reserve memory in socket %d\n",
+                               rte_socket_id());
+
+       comp_perf_options_default(test_data);
+
+       if (comp_perf_options_parse(test_data, argc, argv) < 0) {
+               RTE_LOG(ERR, USER1,
+                       "Parsing one or more user options failed\n");
+               ret = EXIT_FAILURE;
+               goto err;
+       }
+
+       if (comp_perf_options_check(test_data) < 0) {
+               ret = EXIT_FAILURE;
+               goto err;
+       }
+
+       ret = EXIT_SUCCESS;
+
+err:
+       rte_free(test_data);
+
+       return ret;
+}
diff --git a/app/test-compress-perf/meson.build b/app/test-compress-perf/meson.build
new file mode 100644 (file)
index 0000000..ba6d64d
--- /dev/null
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright(c) 2018 Intel Corporation
+
+allow_experimental_apis = true
+sources = files('comp_perf_options_parse.c',
+               'main.c')
+deps = ['compressdev']
index 3ff98bb..fbbc671 100644 (file)
@@ -948,6 +948,11 @@ CONFIG_RTE_TEST_PMD_RECORD_BURST_STATS=n
 #
 CONFIG_RTE_TEST_BBDEV=y
 
+#
+# Compile the compression performance application
+#
+CONFIG_RTE_APP_COMPRESS_PERF=y
+
 #
 # Compile the crypto performance application
 #