app/compress-perf: improve results report

[dpdk.git] / app / test-compress-perf / comp_perf_options_parse.c

diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c
index add5c8a..01e19ea 100644 (file)
--- a/app/test-compress-perf/comp_perf_options_parse.c
+++ b/app/test-compress-perf/comp_perf_options_parse.c
@@ -15,6 +15,7 @@
 
 #include "comp_perf_options.h"
 
+#define CPERF_PTEST_TYPE       ("ptest")
 #define CPERF_DRIVER_NAME      ("driver-name")
 #define CPERF_TEST_FILE                ("input-file")
 #define CPERF_SEG_SIZE         ("seg-sz")
@@ -37,6 +38,7 @@ static void
 usage(char *progname)
 {
        printf("%s [EAL options] --\n"
+               " --ptest benchmark / verify :"
                " --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"
@@ -50,8 +52,8 @@ usage(char *progname)
                "               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"
+               " --huffman-enc [fixed/dynamic/default]: Huffman encoding\n"
+               "               (default: dynamic)\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"
@@ -75,6 +77,33 @@ get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
        return -1;
 }
 
+static int
+parse_cperf_test_type(struct comp_test_data *test_data, const char *arg)
+{
+       struct name_id_map cperftest_namemap[] = {
+               {
+                       cperf_test_type_strs[CPERF_TEST_TYPE_BENCHMARK],
+                       CPERF_TEST_TYPE_BENCHMARK
+               },
+               {
+                       cperf_test_type_strs[CPERF_TEST_TYPE_VERIFY],
+                       CPERF_TEST_TYPE_VERIFY
+               }
+       };
+
+       int id = get_str_key_id_mapping(
+                       (struct name_id_map *)cperftest_namemap,
+                       RTE_DIM(cperftest_namemap), arg);
+       if (id < 0) {
+               RTE_LOG(ERR, USER1, "failed to parse test type");
+               return -1;
+       }
+
+       test_data->test = (enum cperf_test_type)id;
+
+       return 0;
+}
+
 static int
 parse_uint32_t(uint32_t *value, const char *arg)
 {
@@ -326,8 +355,15 @@ parse_seg_sz(struct comp_test_data *test_data, const char *arg)
                return -1;
        }
 
-       if (test_data->seg_sz == 0) {
-               RTE_LOG(ERR, USER1, "Segment size must be higher than 0\n");
+       if (test_data->seg_sz < MIN_COMPRESSED_BUF_SIZE) {
+               RTE_LOG(ERR, USER1, "Segment size must be higher than %d\n",
+                       MIN_COMPRESSED_BUF_SIZE - 1);
+               return -1;
+       }
+
+       if (test_data->seg_sz > MAX_SEG_SIZE) {
+               RTE_LOG(ERR, USER1, "Segment size must be lower than %d\n",
+                       MAX_SEG_SIZE + 1);
                return -1;
        }
 
@@ -357,12 +393,14 @@ parse_max_num_sgl_segs(struct comp_test_data *test_data, const char *arg)
 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);
+       uint16_t tmp;
+       int ret = parse_uint16_t(&tmp, arg);
 
        if (ret) {
                RTE_LOG(ERR, USER1, "Failed to parse window size\n");
                return -1;
        }
+       test_data->window_sz = (int)tmp;
 
        return 0;
 }
@@ -373,7 +411,7 @@ 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,
+       strlcpy(test_data->driver_name, arg,
                        sizeof(test_data->driver_name));
 
        return 0;
@@ -385,7 +423,7 @@ 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));
+       strlcpy(test_data->input_file, arg, sizeof(test_data->input_file));
 
        return 0;
 }
@@ -431,6 +469,10 @@ parse_huffman_enc(struct comp_test_data *test_data, const char *arg)
                {
                        "fixed",
                        RTE_COMP_HUFFMAN_FIXED
+               },
+               {
+                       "dynamic",
+                       RTE_COMP_HUFFMAN_DYNAMIC
                }
        };
 
@@ -455,19 +497,20 @@ parse_level(struct comp_test_data *test_data, const char *arg)
         * 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 (parse_range(arg, &test_data->level_lst.min,
+                       &test_data->level_lst.max,
+                       &test_data->level_lst.inc) < 0) {
+               ret = parse_list(arg, test_data->level_lst.list,
+                                       &test_data->level_lst.min,
+                                       &test_data->level_lst.max);
                if (ret < 0) {
                        RTE_LOG(ERR, USER1,
                                "Failed to parse compression level/s\n");
                        return -1;
                }
-               test_data->level.count = ret;
+               test_data->level_lst.count = ret;
 
-               if (test_data->level.max > RTE_COMP_LEVEL_MAX) {
+               if (test_data->level_lst.max > RTE_COMP_LEVEL_MAX) {
                        RTE_LOG(ERR, USER1, "Level cannot be higher than %u\n",
                                        RTE_COMP_LEVEL_MAX);
                        return -1;
@@ -488,6 +531,7 @@ struct long_opt_parser {
 
 static struct option lgopts[] = {
 
+       { CPERF_PTEST_TYPE, required_argument, 0, 0 },
        { CPERF_DRIVER_NAME, required_argument, 0, 0 },
        { CPERF_TEST_FILE, required_argument, 0, 0 },
        { CPERF_SEG_SIZE, required_argument, 0, 0 },
@@ -506,6 +550,7 @@ static int
 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
 {
        struct long_opt_parser parsermap[] = {
+               { CPERF_PTEST_TYPE,     parse_cperf_test_type },
                { CPERF_DRIVER_NAME,    parse_driver_name },
                { CPERF_TEST_FILE,      parse_test_file },
                { CPERF_SEG_SIZE,       parse_seg_sz },
@@ -561,18 +606,18 @@ 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)
 {
-       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 = 16;
        test_data->num_iter = 10000;
-       test_data->huffman_enc = RTE_COMP_HUFFMAN_FIXED;
+       test_data->huffman_enc = RTE_COMP_HUFFMAN_DYNAMIC;
        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;
+       test_data->level_lst.min = RTE_COMP_LEVEL_MIN;
+       test_data->level_lst.max = RTE_COMP_LEVEL_MAX;
+       test_data->level_lst.inc = 1;
+       test_data->test = CPERF_TEST_TYPE_BENCHMARK;
 }
 
 int