1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Intel Corporation
13 #include <rte_string_fns.h>
16 #include "comp_perf_options.h"
18 #define CPERF_PTEST_TYPE ("ptest")
19 #define CPERF_DRIVER_NAME ("driver-name")
20 #define CPERF_TEST_FILE ("input-file")
21 #define CPERF_SEG_SIZE ("seg-sz")
22 #define CPERF_BURST_SIZE ("burst-sz")
23 #define CPERF_EXTENDED_SIZE ("extended-input-sz")
24 #define CPERF_POOL_SIZE ("pool-sz")
25 #define CPERF_MAX_SGL_SEGS ("max-num-sgl-segs")
26 #define CPERF_NUM_ITER ("num-iter")
27 #define CPERF_OPTYPE ("operation")
28 #define CPERF_HUFFMAN_ENC ("huffman-enc")
29 #define CPERF_LEVEL ("compress-level")
30 #define CPERF_WINDOW_SIZE ("window-sz")
31 #define CPERF_EXTERNAL_MBUFS ("external-mbufs")
41 printf("%s [EAL options] --\n"
42 " --ptest benchmark / verify :"
43 " --driver-name NAME: compress driver to use\n"
44 " --input-file NAME: file to compress and decompress\n"
45 " --extended-input-sz N: extend file data up to this size (default: no extension)\n"
46 " --seg-sz N: size of segment to store the data (default: 2048)\n"
47 " --burst-sz N: compress operation burst size\n"
48 " --pool-sz N: mempool size for compress operations/mbufs\n"
50 " --max-num-sgl-segs N: maximum number of segments for each mbuf\n"
52 " --num-iter N: number of times the file will be\n"
53 " compressed/decompressed (default: 10000)\n"
54 " --operation [comp/decomp/comp_and_decomp]: perform test on\n"
55 " compression, decompression or both operations\n"
56 " --huffman-enc [fixed/dynamic/default]: Huffman encoding\n"
57 " (default: dynamic)\n"
58 " --compress-level N: compression level, which could be a single value, list or range\n"
59 " (default: range between 1 and 9)\n"
60 " --window-sz N: base two log value of compression window size\n"
61 " (e.g.: 15 => 32k, default: max supported by PMD)\n"
62 " --external-mbufs: use memzones as external buffers instead of\n"
63 " keeping the data directly in mbuf area\n"
64 " -h: prints this help\n",
69 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
74 for (i = 0; i < map_len; i++) {
76 if (strcmp(str_key, map[i].name) == 0)
84 parse_cperf_test_type(struct comp_test_data *test_data, const char *arg)
86 struct name_id_map cperftest_namemap[] = {
88 comp_perf_test_type_strs[CPERF_TEST_TYPE_BENCHMARK],
89 CPERF_TEST_TYPE_BENCHMARK
92 comp_perf_test_type_strs[CPERF_TEST_TYPE_VERIFY],
93 CPERF_TEST_TYPE_VERIFY
97 int id = get_str_key_id_mapping(
98 (struct name_id_map *)cperftest_namemap,
99 RTE_DIM(cperftest_namemap), arg);
101 RTE_LOG(ERR, USER1, "failed to parse test type");
105 test_data->test = (enum cperf_test_type)id;
111 parse_uint32_t(uint32_t *value, const char *arg)
114 unsigned long n = strtoul(arg, &end, 10);
116 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0'))
122 *value = (uint32_t) n;
128 parse_uint16_t(uint16_t *value, const char *arg)
131 int ret = parse_uint32_t(&val, arg);
136 if (val > UINT16_MAX)
139 *value = (uint16_t) val;
145 parse_range(const char *arg, uint8_t *min, uint8_t *max, uint8_t *inc)
150 char *copy_arg = strdup(arg);
152 if (copy_arg == NULL)
156 token = strtok(copy_arg, ":");
158 /* Parse minimum value */
160 number = strtoul(token, NULL, 10);
162 if (errno == EINVAL || errno == ERANGE)
169 token = strtok(NULL, ":");
171 /* Parse increment value */
173 number = strtoul(token, NULL, 10);
175 if (errno == EINVAL || errno == ERANGE ||
183 token = strtok(NULL, ":");
185 /* Parse maximum value */
187 number = strtoul(token, NULL, 10);
189 if (errno == EINVAL || errno == ERANGE ||
197 if (strtok(NULL, ":") != NULL)
209 parse_list(const char *arg, uint8_t *list, uint8_t *min, uint8_t *max)
217 char *copy_arg = strdup(arg);
219 if (copy_arg == NULL)
223 token = strtok(copy_arg, ",");
225 /* Parse first value */
227 number = strtoul(token, NULL, 10);
229 if (errno == EINVAL || errno == ERANGE)
232 list[count++] = number;
238 token = strtok(NULL, ",");
240 while (token != NULL) {
241 if (count == MAX_LIST) {
242 RTE_LOG(WARNING, USER1,
243 "Using only the first %u sizes\n",
248 number = strtoul(token, NULL, 10);
250 if (errno == EINVAL || errno == ERANGE)
253 list[count++] = number;
255 if (number < temp_min)
257 if (number > temp_max)
260 token = strtok(NULL, ",");
277 parse_num_iter(struct comp_test_data *test_data, const char *arg)
279 int ret = parse_uint32_t(&test_data->num_iter, arg);
282 RTE_LOG(ERR, USER1, "Failed to parse total iteration count\n");
286 if (test_data->num_iter == 0) {
288 "Total number of iterations must be higher than 0\n");
296 parse_pool_sz(struct comp_test_data *test_data, const char *arg)
298 int ret = parse_uint32_t(&test_data->pool_sz, arg);
301 RTE_LOG(ERR, USER1, "Failed to parse pool size");
305 if (test_data->pool_sz == 0) {
306 RTE_LOG(ERR, USER1, "Pool size must be higher than 0\n");
314 parse_burst_sz(struct comp_test_data *test_data, const char *arg)
316 int ret = parse_uint16_t(&test_data->burst_sz, arg);
319 RTE_LOG(ERR, USER1, "Failed to parse burst size/s\n");
323 if (test_data->burst_sz == 0) {
324 RTE_LOG(ERR, USER1, "Burst size must be higher than 0\n");
332 parse_extended_input_sz(struct comp_test_data *test_data, const char *arg)
335 int ret = parse_uint32_t(&tmp, arg);
338 RTE_LOG(ERR, USER1, "Failed to parse extended input size\n");
341 test_data->input_data_sz = tmp;
345 "Extended file size must be higher than 0\n");
352 parse_seg_sz(struct comp_test_data *test_data, const char *arg)
354 int ret = parse_uint16_t(&test_data->seg_sz, arg);
357 RTE_LOG(ERR, USER1, "Failed to parse segment size\n");
361 if (test_data->seg_sz < MIN_COMPRESSED_BUF_SIZE) {
362 RTE_LOG(ERR, USER1, "Segment size must be higher than %d\n",
363 MIN_COMPRESSED_BUF_SIZE - 1);
367 if (test_data->seg_sz > MAX_SEG_SIZE) {
368 RTE_LOG(ERR, USER1, "Segment size must be lower than %d\n",
377 parse_max_num_sgl_segs(struct comp_test_data *test_data, const char *arg)
379 int ret = parse_uint16_t(&test_data->max_sgl_segs, arg);
383 "Failed to parse max number of segments per mbuf chain\n");
387 if (test_data->max_sgl_segs == 0) {
388 RTE_LOG(ERR, USER1, "Max number of segments per mbuf chain "
389 "must be higher than 0\n");
397 parse_window_sz(struct comp_test_data *test_data, const char *arg)
400 int ret = parse_uint16_t(&tmp, arg);
403 RTE_LOG(ERR, USER1, "Failed to parse window size\n");
406 test_data->window_sz = (int)tmp;
412 parse_driver_name(struct comp_test_data *test_data, const char *arg)
414 if (strlen(arg) > (sizeof(test_data->driver_name) - 1))
417 strlcpy(test_data->driver_name, arg,
418 sizeof(test_data->driver_name));
424 parse_test_file(struct comp_test_data *test_data, const char *arg)
426 if (strlen(arg) > (sizeof(test_data->input_file) - 1))
429 strlcpy(test_data->input_file, arg, sizeof(test_data->input_file));
435 parse_op_type(struct comp_test_data *test_data, const char *arg)
437 struct name_id_map optype_namemap[] = {
452 int id = get_str_key_id_mapping(optype_namemap,
453 RTE_DIM(optype_namemap), arg);
455 RTE_LOG(ERR, USER1, "Invalid operation type specified\n");
459 test_data->test_op = (enum comp_operation)id;
465 parse_huffman_enc(struct comp_test_data *test_data, const char *arg)
467 struct name_id_map huffman_namemap[] = {
470 RTE_COMP_HUFFMAN_DEFAULT
474 RTE_COMP_HUFFMAN_FIXED
478 RTE_COMP_HUFFMAN_DYNAMIC
482 int id = get_str_key_id_mapping(huffman_namemap,
483 RTE_DIM(huffman_namemap), arg);
485 RTE_LOG(ERR, USER1, "Invalid Huffmane encoding specified\n");
489 test_data->huffman_enc = (enum rte_comp_huffman)id;
495 parse_level(struct comp_test_data *test_data, const char *arg)
500 * Try parsing the argument as a range, if it fails,
503 if (parse_range(arg, &test_data->level_lst.min,
504 &test_data->level_lst.max,
505 &test_data->level_lst.inc) < 0) {
506 ret = parse_list(arg, test_data->level_lst.list,
507 &test_data->level_lst.min,
508 &test_data->level_lst.max);
511 "Failed to parse compression level/s\n");
514 test_data->level_lst.count = ret;
516 if (test_data->level_lst.max > RTE_COMP_LEVEL_MAX) {
517 RTE_LOG(ERR, USER1, "Level cannot be higher than %u\n",
527 parse_external_mbufs(struct comp_test_data *test_data,
528 const char *arg __rte_unused)
530 test_data->use_external_mbufs = 1;
534 typedef int (*option_parser_t)(struct comp_test_data *test_data,
537 struct long_opt_parser {
538 const char *lgopt_name;
539 option_parser_t parser_fn;
543 static struct option lgopts[] = {
545 { CPERF_PTEST_TYPE, required_argument, 0, 0 },
546 { CPERF_DRIVER_NAME, required_argument, 0, 0 },
547 { CPERF_TEST_FILE, required_argument, 0, 0 },
548 { CPERF_SEG_SIZE, required_argument, 0, 0 },
549 { CPERF_BURST_SIZE, required_argument, 0, 0 },
550 { CPERF_EXTENDED_SIZE, required_argument, 0, 0 },
551 { CPERF_POOL_SIZE, required_argument, 0, 0 },
552 { CPERF_MAX_SGL_SEGS, required_argument, 0, 0},
553 { CPERF_NUM_ITER, required_argument, 0, 0 },
554 { CPERF_OPTYPE, required_argument, 0, 0 },
555 { CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
556 { CPERF_LEVEL, required_argument, 0, 0 },
557 { CPERF_WINDOW_SIZE, required_argument, 0, 0 },
558 { CPERF_EXTERNAL_MBUFS, 0, 0, 0 },
563 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
565 struct long_opt_parser parsermap[] = {
566 { CPERF_PTEST_TYPE, parse_cperf_test_type },
567 { CPERF_DRIVER_NAME, parse_driver_name },
568 { CPERF_TEST_FILE, parse_test_file },
569 { CPERF_SEG_SIZE, parse_seg_sz },
570 { CPERF_BURST_SIZE, parse_burst_sz },
571 { CPERF_EXTENDED_SIZE, parse_extended_input_sz },
572 { CPERF_POOL_SIZE, parse_pool_sz },
573 { CPERF_MAX_SGL_SEGS, parse_max_num_sgl_segs },
574 { CPERF_NUM_ITER, parse_num_iter },
575 { CPERF_OPTYPE, parse_op_type },
576 { CPERF_HUFFMAN_ENC, parse_huffman_enc },
577 { CPERF_LEVEL, parse_level },
578 { CPERF_WINDOW_SIZE, parse_window_sz },
579 { CPERF_EXTERNAL_MBUFS, parse_external_mbufs },
583 for (i = 0; i < RTE_DIM(parsermap); i++) {
584 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
585 strlen(lgopts[opt_idx].name)) == 0)
586 return parsermap[i].parser_fn(test_data, optarg);
593 comp_perf_options_parse(struct comp_test_data *test_data, int argc, char **argv)
595 int opt, retval, opt_idx;
597 while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) {
601 rte_exit(EXIT_SUCCESS, "Displayed help\n");
605 retval = comp_perf_opts_parse_long(opt_idx, test_data);
621 comp_perf_options_default(struct comp_test_data *test_data)
623 test_data->seg_sz = 2048;
624 test_data->burst_sz = 32;
625 test_data->pool_sz = 8192;
626 test_data->max_sgl_segs = 16;
627 test_data->num_iter = 10000;
628 test_data->huffman_enc = RTE_COMP_HUFFMAN_DYNAMIC;
629 test_data->test_op = COMPRESS_DECOMPRESS;
630 test_data->window_sz = -1;
631 test_data->level_lst.min = RTE_COMP_LEVEL_MIN;
632 test_data->level_lst.max = RTE_COMP_LEVEL_MAX;
633 test_data->level_lst.inc = 1;
634 test_data->test = CPERF_TEST_TYPE_BENCHMARK;
635 test_data->use_external_mbufs = 0;
639 comp_perf_options_check(struct comp_test_data *test_data)
641 if (test_data->driver_name[0] == '\0') {
642 RTE_LOG(ERR, USER1, "Driver name has to be set\n");
646 if (test_data->input_file[0] == '\0') {
647 RTE_LOG(ERR, USER1, "Input file name has to be set\n");