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_DRIVER_NAME ("driver-name")
19 #define CPERF_TEST_FILE ("input-file")
20 #define CPERF_SEG_SIZE ("seg-sz")
21 #define CPERF_BURST_SIZE ("burst-sz")
22 #define CPERF_EXTENDED_SIZE ("extended-input-sz")
23 #define CPERF_POOL_SIZE ("pool-sz")
24 #define CPERF_MAX_SGL_SEGS ("max-num-sgl-segs")
25 #define CPERF_NUM_ITER ("num-iter")
26 #define CPERF_OPTYPE ("operation")
27 #define CPERF_HUFFMAN_ENC ("huffman-enc")
28 #define CPERF_LEVEL ("compress-level")
29 #define CPERF_WINDOW_SIZE ("window-sz")
39 printf("%s [EAL options] --\n"
40 " --driver-name NAME: compress driver to use\n"
41 " --input-file NAME: file to compress and decompress\n"
42 " --extended-input-sz N: extend file data up to this size (default: no extension)\n"
43 " --seg-sz N: size of segment to store the data (default: 2048)\n"
44 " --burst-sz N: compress operation burst size\n"
45 " --pool-sz N: mempool size for compress operations/mbufs\n"
47 " --max-num-sgl-segs N: maximum number of segments for each mbuf\n"
49 " --num-iter N: number of times the file will be\n"
50 " compressed/decompressed (default: 10000)\n"
51 " --operation [comp/decomp/comp_and_decomp]: perform test on\n"
52 " compression, decompression or both operations\n"
53 " --huffman-enc [fixed/dynamic/default]: Huffman encoding\n"
54 " (default: dynamic)\n"
55 " --compress-level N: compression level, which could be a single value, list or range\n"
56 " (default: range between 1 and 9)\n"
57 " --window-sz N: base two log value of compression window size\n"
58 " (e.g.: 15 => 32k, default: max supported by PMD)\n"
59 " -h: prints this help\n",
64 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
69 for (i = 0; i < map_len; i++) {
71 if (strcmp(str_key, map[i].name) == 0)
79 parse_uint32_t(uint32_t *value, const char *arg)
82 unsigned long n = strtoul(arg, &end, 10);
84 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0'))
90 *value = (uint32_t) n;
96 parse_uint16_t(uint16_t *value, const char *arg)
99 int ret = parse_uint32_t(&val, arg);
104 if (val > UINT16_MAX)
107 *value = (uint16_t) val;
113 parse_range(const char *arg, uint8_t *min, uint8_t *max, uint8_t *inc)
118 char *copy_arg = strdup(arg);
120 if (copy_arg == NULL)
124 token = strtok(copy_arg, ":");
126 /* Parse minimum value */
128 number = strtoul(token, NULL, 10);
130 if (errno == EINVAL || errno == ERANGE)
137 token = strtok(NULL, ":");
139 /* Parse increment value */
141 number = strtoul(token, NULL, 10);
143 if (errno == EINVAL || errno == ERANGE ||
151 token = strtok(NULL, ":");
153 /* Parse maximum value */
155 number = strtoul(token, NULL, 10);
157 if (errno == EINVAL || errno == ERANGE ||
165 if (strtok(NULL, ":") != NULL)
177 parse_list(const char *arg, uint8_t *list, uint8_t *min, uint8_t *max)
185 char *copy_arg = strdup(arg);
187 if (copy_arg == NULL)
191 token = strtok(copy_arg, ",");
193 /* Parse first value */
195 number = strtoul(token, NULL, 10);
197 if (errno == EINVAL || errno == ERANGE)
200 list[count++] = number;
206 token = strtok(NULL, ",");
208 while (token != NULL) {
209 if (count == MAX_LIST) {
210 RTE_LOG(WARNING, USER1,
211 "Using only the first %u sizes\n",
216 number = strtoul(token, NULL, 10);
218 if (errno == EINVAL || errno == ERANGE)
221 list[count++] = number;
223 if (number < temp_min)
225 if (number > temp_max)
228 token = strtok(NULL, ",");
245 parse_num_iter(struct comp_test_data *test_data, const char *arg)
247 int ret = parse_uint32_t(&test_data->num_iter, arg);
250 RTE_LOG(ERR, USER1, "Failed to parse total iteration count\n");
254 if (test_data->num_iter == 0) {
256 "Total number of iterations must be higher than 0\n");
264 parse_pool_sz(struct comp_test_data *test_data, const char *arg)
266 int ret = parse_uint32_t(&test_data->pool_sz, arg);
269 RTE_LOG(ERR, USER1, "Failed to parse pool size");
273 if (test_data->pool_sz == 0) {
274 RTE_LOG(ERR, USER1, "Pool size must be higher than 0\n");
282 parse_burst_sz(struct comp_test_data *test_data, const char *arg)
284 int ret = parse_uint16_t(&test_data->burst_sz, arg);
287 RTE_LOG(ERR, USER1, "Failed to parse burst size/s\n");
291 if (test_data->burst_sz == 0) {
292 RTE_LOG(ERR, USER1, "Burst size must be higher than 0\n");
300 parse_extended_input_sz(struct comp_test_data *test_data, const char *arg)
303 int ret = parse_uint32_t(&tmp, arg);
306 RTE_LOG(ERR, USER1, "Failed to parse extended input size\n");
309 test_data->input_data_sz = tmp;
313 "Extended file size must be higher than 0\n");
320 parse_seg_sz(struct comp_test_data *test_data, const char *arg)
322 int ret = parse_uint16_t(&test_data->seg_sz, arg);
325 RTE_LOG(ERR, USER1, "Failed to parse segment size\n");
329 if (test_data->seg_sz < MIN_COMPRESSED_BUF_SIZE) {
330 RTE_LOG(ERR, USER1, "Segment size must be higher than %d\n",
331 MIN_COMPRESSED_BUF_SIZE - 1);
335 if (test_data->seg_sz > MAX_SEG_SIZE) {
336 RTE_LOG(ERR, USER1, "Segment size must be lower than %d\n",
345 parse_max_num_sgl_segs(struct comp_test_data *test_data, const char *arg)
347 int ret = parse_uint16_t(&test_data->max_sgl_segs, arg);
351 "Failed to parse max number of segments per mbuf chain\n");
355 if (test_data->max_sgl_segs == 0) {
356 RTE_LOG(ERR, USER1, "Max number of segments per mbuf chain "
357 "must be higher than 0\n");
365 parse_window_sz(struct comp_test_data *test_data, const char *arg)
367 int ret = parse_uint16_t((uint16_t *)&test_data->window_sz, arg);
370 RTE_LOG(ERR, USER1, "Failed to parse window size\n");
378 parse_driver_name(struct comp_test_data *test_data, const char *arg)
380 if (strlen(arg) > (sizeof(test_data->driver_name) - 1))
383 strlcpy(test_data->driver_name, arg,
384 sizeof(test_data->driver_name));
390 parse_test_file(struct comp_test_data *test_data, const char *arg)
392 if (strlen(arg) > (sizeof(test_data->input_file) - 1))
395 strlcpy(test_data->input_file, arg, sizeof(test_data->input_file));
401 parse_op_type(struct comp_test_data *test_data, const char *arg)
403 struct name_id_map optype_namemap[] = {
418 int id = get_str_key_id_mapping(optype_namemap,
419 RTE_DIM(optype_namemap), arg);
421 RTE_LOG(ERR, USER1, "Invalid operation type specified\n");
425 test_data->test_op = (enum comp_operation)id;
431 parse_huffman_enc(struct comp_test_data *test_data, const char *arg)
433 struct name_id_map huffman_namemap[] = {
436 RTE_COMP_HUFFMAN_DEFAULT
440 RTE_COMP_HUFFMAN_FIXED
444 RTE_COMP_HUFFMAN_DYNAMIC
448 int id = get_str_key_id_mapping(huffman_namemap,
449 RTE_DIM(huffman_namemap), arg);
451 RTE_LOG(ERR, USER1, "Invalid Huffmane encoding specified\n");
455 test_data->huffman_enc = (enum rte_comp_huffman)id;
461 parse_level(struct comp_test_data *test_data, const char *arg)
466 * Try parsing the argument as a range, if it fails,
469 if (parse_range(arg, &test_data->level.min, &test_data->level.max,
470 &test_data->level.inc) < 0) {
471 ret = parse_list(arg, test_data->level.list,
472 &test_data->level.min,
473 &test_data->level.max);
476 "Failed to parse compression level/s\n");
479 test_data->level.count = ret;
481 if (test_data->level.max > RTE_COMP_LEVEL_MAX) {
482 RTE_LOG(ERR, USER1, "Level cannot be higher than %u\n",
491 typedef int (*option_parser_t)(struct comp_test_data *test_data,
494 struct long_opt_parser {
495 const char *lgopt_name;
496 option_parser_t parser_fn;
500 static struct option lgopts[] = {
502 { CPERF_DRIVER_NAME, required_argument, 0, 0 },
503 { CPERF_TEST_FILE, required_argument, 0, 0 },
504 { CPERF_SEG_SIZE, required_argument, 0, 0 },
505 { CPERF_BURST_SIZE, required_argument, 0, 0 },
506 { CPERF_EXTENDED_SIZE, required_argument, 0, 0 },
507 { CPERF_POOL_SIZE, required_argument, 0, 0 },
508 { CPERF_MAX_SGL_SEGS, required_argument, 0, 0},
509 { CPERF_NUM_ITER, required_argument, 0, 0 },
510 { CPERF_OPTYPE, required_argument, 0, 0 },
511 { CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
512 { CPERF_LEVEL, required_argument, 0, 0 },
513 { CPERF_WINDOW_SIZE, required_argument, 0, 0 },
517 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
519 struct long_opt_parser parsermap[] = {
520 { CPERF_DRIVER_NAME, parse_driver_name },
521 { CPERF_TEST_FILE, parse_test_file },
522 { CPERF_SEG_SIZE, parse_seg_sz },
523 { CPERF_BURST_SIZE, parse_burst_sz },
524 { CPERF_EXTENDED_SIZE, parse_extended_input_sz },
525 { CPERF_POOL_SIZE, parse_pool_sz },
526 { CPERF_MAX_SGL_SEGS, parse_max_num_sgl_segs },
527 { CPERF_NUM_ITER, parse_num_iter },
528 { CPERF_OPTYPE, parse_op_type },
529 { CPERF_HUFFMAN_ENC, parse_huffman_enc },
530 { CPERF_LEVEL, parse_level },
531 { CPERF_WINDOW_SIZE, parse_window_sz },
535 for (i = 0; i < RTE_DIM(parsermap); i++) {
536 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
537 strlen(lgopts[opt_idx].name)) == 0)
538 return parsermap[i].parser_fn(test_data, optarg);
545 comp_perf_options_parse(struct comp_test_data *test_data, int argc, char **argv)
547 int opt, retval, opt_idx;
549 while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) {
553 rte_exit(EXIT_SUCCESS, "Displayed help\n");
557 retval = comp_perf_opts_parse_long(opt_idx, test_data);
573 comp_perf_options_default(struct comp_test_data *test_data)
575 test_data->cdev_id = -1;
576 test_data->seg_sz = 2048;
577 test_data->burst_sz = 32;
578 test_data->pool_sz = 8192;
579 test_data->max_sgl_segs = 16;
580 test_data->num_iter = 10000;
581 test_data->huffman_enc = RTE_COMP_HUFFMAN_DYNAMIC;
582 test_data->test_op = COMPRESS_DECOMPRESS;
583 test_data->window_sz = -1;
584 test_data->level.min = 1;
585 test_data->level.max = 9;
586 test_data->level.inc = 1;
590 comp_perf_options_check(struct comp_test_data *test_data)
592 if (test_data->driver_name[0] == '\0') {
593 RTE_LOG(ERR, USER1, "Driver name has to be set\n");
597 if (test_data->input_file[0] == '\0') {
598 RTE_LOG(ERR, USER1, "Input file name has to be set\n");