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/default]: Huffman encoding\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 rte_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 rte_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 int id = get_str_key_id_mapping(huffman_namemap,
438 RTE_DIM(huffman_namemap), arg);
440 RTE_LOG(ERR, USER1, "Invalid Huffmane encoding specified\n");
444 test_data->huffman_enc = (enum rte_comp_huffman)id;
450 parse_level(struct comp_test_data *test_data, const char *arg)
455 * Try parsing the argument as a range, if it fails,
458 if (parse_range(arg, &test_data->level.min, &test_data->level.max,
459 &test_data->level.inc) < 0) {
460 ret = parse_list(arg, test_data->level.list,
461 &test_data->level.min,
462 &test_data->level.max);
465 "Failed to parse compression level/s\n");
468 test_data->level.count = ret;
470 if (test_data->level.max > RTE_COMP_LEVEL_MAX) {
471 RTE_LOG(ERR, USER1, "Level cannot be higher than %u\n",
480 typedef int (*option_parser_t)(struct comp_test_data *test_data,
483 struct long_opt_parser {
484 const char *lgopt_name;
485 option_parser_t parser_fn;
489 static struct option lgopts[] = {
491 { CPERF_DRIVER_NAME, required_argument, 0, 0 },
492 { CPERF_TEST_FILE, required_argument, 0, 0 },
493 { CPERF_SEG_SIZE, required_argument, 0, 0 },
494 { CPERF_BURST_SIZE, required_argument, 0, 0 },
495 { CPERF_EXTENDED_SIZE, required_argument, 0, 0 },
496 { CPERF_POOL_SIZE, required_argument, 0, 0 },
497 { CPERF_MAX_SGL_SEGS, required_argument, 0, 0},
498 { CPERF_NUM_ITER, required_argument, 0, 0 },
499 { CPERF_OPTYPE, required_argument, 0, 0 },
500 { CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
501 { CPERF_LEVEL, required_argument, 0, 0 },
502 { CPERF_WINDOW_SIZE, required_argument, 0, 0 },
506 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
508 struct long_opt_parser parsermap[] = {
509 { CPERF_DRIVER_NAME, parse_driver_name },
510 { CPERF_TEST_FILE, parse_test_file },
511 { CPERF_SEG_SIZE, parse_seg_sz },
512 { CPERF_BURST_SIZE, parse_burst_sz },
513 { CPERF_EXTENDED_SIZE, parse_extended_input_sz },
514 { CPERF_POOL_SIZE, parse_pool_sz },
515 { CPERF_MAX_SGL_SEGS, parse_max_num_sgl_segs },
516 { CPERF_NUM_ITER, parse_num_iter },
517 { CPERF_OPTYPE, parse_op_type },
518 { CPERF_HUFFMAN_ENC, parse_huffman_enc },
519 { CPERF_LEVEL, parse_level },
520 { CPERF_WINDOW_SIZE, parse_window_sz },
524 for (i = 0; i < RTE_DIM(parsermap); i++) {
525 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
526 strlen(lgopts[opt_idx].name)) == 0)
527 return parsermap[i].parser_fn(test_data, optarg);
534 comp_perf_options_parse(struct comp_test_data *test_data, int argc, char **argv)
536 int opt, retval, opt_idx;
538 while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) {
542 rte_exit(EXIT_SUCCESS, "Displayed help\n");
546 retval = comp_perf_opts_parse_long(opt_idx, test_data);
562 comp_perf_options_default(struct comp_test_data *test_data)
564 test_data->cdev_id = -1;
565 test_data->seg_sz = 2048;
566 test_data->burst_sz = 32;
567 test_data->pool_sz = 8192;
568 test_data->max_sgl_segs = 16;
569 test_data->num_iter = 10000;
570 test_data->huffman_enc = RTE_COMP_HUFFMAN_FIXED;
571 test_data->test_op = COMPRESS_DECOMPRESS;
572 test_data->window_sz = -1;
573 test_data->level.min = 1;
574 test_data->level.max = 9;
575 test_data->level.inc = 1;
579 comp_perf_options_check(struct comp_test_data *test_data)
581 if (test_data->driver_name[0] == '\0') {
582 RTE_LOG(ERR, USER1, "Driver name has to be set\n");
586 if (test_data->input_file[0] == '\0') {
587 RTE_LOG(ERR, USER1, "Input file name has to be set\n");