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 == 0) {
330 RTE_LOG(ERR, USER1, "Segment size must be higher than 0\n");
338 parse_max_num_sgl_segs(struct comp_test_data *test_data, const char *arg)
340 int ret = parse_uint16_t(&test_data->max_sgl_segs, arg);
344 "Failed to parse max number of segments per mbuf chain\n");
348 if (test_data->max_sgl_segs == 0) {
349 RTE_LOG(ERR, USER1, "Max number of segments per mbuf chain "
350 "must be higher than 0\n");
358 parse_window_sz(struct comp_test_data *test_data, const char *arg)
360 int ret = parse_uint16_t((uint16_t *)&test_data->window_sz, arg);
363 RTE_LOG(ERR, USER1, "Failed to parse window size\n");
371 parse_driver_name(struct comp_test_data *test_data, const char *arg)
373 if (strlen(arg) > (sizeof(test_data->driver_name) - 1))
376 strlcpy(test_data->driver_name, arg,
377 sizeof(test_data->driver_name));
383 parse_test_file(struct comp_test_data *test_data, const char *arg)
385 if (strlen(arg) > (sizeof(test_data->input_file) - 1))
388 strlcpy(test_data->input_file, arg, sizeof(test_data->input_file));
394 parse_op_type(struct comp_test_data *test_data, const char *arg)
396 struct name_id_map optype_namemap[] = {
411 int id = get_str_key_id_mapping(optype_namemap,
412 RTE_DIM(optype_namemap), arg);
414 RTE_LOG(ERR, USER1, "Invalid operation type specified\n");
418 test_data->test_op = (enum comp_operation)id;
424 parse_huffman_enc(struct comp_test_data *test_data, const char *arg)
426 struct name_id_map huffman_namemap[] = {
429 RTE_COMP_HUFFMAN_DEFAULT
433 RTE_COMP_HUFFMAN_FIXED
437 RTE_COMP_HUFFMAN_DYNAMIC
441 int id = get_str_key_id_mapping(huffman_namemap,
442 RTE_DIM(huffman_namemap), arg);
444 RTE_LOG(ERR, USER1, "Invalid Huffmane encoding specified\n");
448 test_data->huffman_enc = (enum rte_comp_huffman)id;
454 parse_level(struct comp_test_data *test_data, const char *arg)
459 * Try parsing the argument as a range, if it fails,
462 if (parse_range(arg, &test_data->level.min, &test_data->level.max,
463 &test_data->level.inc) < 0) {
464 ret = parse_list(arg, test_data->level.list,
465 &test_data->level.min,
466 &test_data->level.max);
469 "Failed to parse compression level/s\n");
472 test_data->level.count = ret;
474 if (test_data->level.max > RTE_COMP_LEVEL_MAX) {
475 RTE_LOG(ERR, USER1, "Level cannot be higher than %u\n",
484 typedef int (*option_parser_t)(struct comp_test_data *test_data,
487 struct long_opt_parser {
488 const char *lgopt_name;
489 option_parser_t parser_fn;
493 static struct option lgopts[] = {
495 { CPERF_DRIVER_NAME, required_argument, 0, 0 },
496 { CPERF_TEST_FILE, required_argument, 0, 0 },
497 { CPERF_SEG_SIZE, required_argument, 0, 0 },
498 { CPERF_BURST_SIZE, required_argument, 0, 0 },
499 { CPERF_EXTENDED_SIZE, required_argument, 0, 0 },
500 { CPERF_POOL_SIZE, required_argument, 0, 0 },
501 { CPERF_MAX_SGL_SEGS, required_argument, 0, 0},
502 { CPERF_NUM_ITER, required_argument, 0, 0 },
503 { CPERF_OPTYPE, required_argument, 0, 0 },
504 { CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
505 { CPERF_LEVEL, required_argument, 0, 0 },
506 { CPERF_WINDOW_SIZE, required_argument, 0, 0 },
510 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
512 struct long_opt_parser parsermap[] = {
513 { CPERF_DRIVER_NAME, parse_driver_name },
514 { CPERF_TEST_FILE, parse_test_file },
515 { CPERF_SEG_SIZE, parse_seg_sz },
516 { CPERF_BURST_SIZE, parse_burst_sz },
517 { CPERF_EXTENDED_SIZE, parse_extended_input_sz },
518 { CPERF_POOL_SIZE, parse_pool_sz },
519 { CPERF_MAX_SGL_SEGS, parse_max_num_sgl_segs },
520 { CPERF_NUM_ITER, parse_num_iter },
521 { CPERF_OPTYPE, parse_op_type },
522 { CPERF_HUFFMAN_ENC, parse_huffman_enc },
523 { CPERF_LEVEL, parse_level },
524 { CPERF_WINDOW_SIZE, parse_window_sz },
528 for (i = 0; i < RTE_DIM(parsermap); i++) {
529 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
530 strlen(lgopts[opt_idx].name)) == 0)
531 return parsermap[i].parser_fn(test_data, optarg);
538 comp_perf_options_parse(struct comp_test_data *test_data, int argc, char **argv)
540 int opt, retval, opt_idx;
542 while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) {
546 rte_exit(EXIT_SUCCESS, "Displayed help\n");
550 retval = comp_perf_opts_parse_long(opt_idx, test_data);
566 comp_perf_options_default(struct comp_test_data *test_data)
568 test_data->cdev_id = -1;
569 test_data->seg_sz = 2048;
570 test_data->burst_sz = 32;
571 test_data->pool_sz = 8192;
572 test_data->max_sgl_segs = 16;
573 test_data->num_iter = 10000;
574 test_data->huffman_enc = RTE_COMP_HUFFMAN_DYNAMIC;
575 test_data->test_op = COMPRESS_DECOMPRESS;
576 test_data->window_sz = -1;
577 test_data->level.min = 1;
578 test_data->level.max = 9;
579 test_data->level.inc = 1;
583 comp_perf_options_check(struct comp_test_data *test_data)
585 if (test_data->driver_name[0] == '\0') {
586 RTE_LOG(ERR, USER1, "Driver name has to be set\n");
590 if (test_data->input_file[0] == '\0') {
591 RTE_LOG(ERR, USER1, "Input file name has to be set\n");