#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")
#define CPERF_HUFFMAN_ENC ("huffman-enc")
#define CPERF_LEVEL ("compress-level")
#define CPERF_WINDOW_SIZE ("window-sz")
+#define CPERF_EXTERNAL_MBUFS ("external-mbufs")
+
+/* cyclecount-specific options */
+#define CPERF_CYCLECOUNT_DELAY_US ("cc-delay-us")
struct name_id_map {
const char *name;
usage(char *progname)
{
printf("%s [EAL options] --\n"
+ " --ptest throughput / verify / pmd-cyclecount\n"
" --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"
" (default: range between 1 and 9)\n"
" --window-sz N: base two log value of compression window size\n"
" (e.g.: 15 => 32k, default: max supported by PMD)\n"
+ " --external-mbufs: use memzones as external buffers instead of\n"
+ " keeping the data directly in mbuf area\n"
+ " --cc-delay-us N: delay between enqueue and dequeue operations in microseconds\n"
+ " valid only for cyclecount perf test (default: 500 us)\n"
" -h: prints this help\n",
progname);
}
return -1;
}
+static int
+parse_cperf_test_type(struct comp_test_data *test_data, const char *arg)
+{
+ struct name_id_map cperftest_namemap[] = {
+ {
+ comp_perf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT],
+ CPERF_TEST_TYPE_THROUGHPUT
+ },
+ {
+ comp_perf_test_type_strs[CPERF_TEST_TYPE_VERIFY],
+ CPERF_TEST_TYPE_VERIFY
+ },
+ {
+ comp_perf_test_type_strs[CPERF_TEST_TYPE_PMDCC],
+ CPERF_TEST_TYPE_PMDCC
+ }
+ };
+
+ 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)
{
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;
}
* 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;
return 0;
}
+static int
+parse_external_mbufs(struct comp_test_data *test_data,
+ const char *arg __rte_unused)
+{
+ test_data->use_external_mbufs = 1;
+ return 0;
+}
+
+static int
+parse_cyclecount_delay_us(struct comp_test_data *test_data,
+ const char *arg)
+{
+ int ret = parse_uint32_t(&(test_data->cyclecount_delay), arg);
+
+ if (ret) {
+ RTE_LOG(ERR, USER1, "Failed to parse cyclecount delay\n");
+ return -1;
+ }
+ return 0;
+}
+
typedef int (*option_parser_t)(struct comp_test_data *test_data,
const char *arg);
struct long_opt_parser {
const char *lgopt_name;
option_parser_t parser_fn;
-
};
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 },
{ CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
{ CPERF_LEVEL, required_argument, 0, 0 },
{ CPERF_WINDOW_SIZE, required_argument, 0, 0 },
+ { CPERF_EXTERNAL_MBUFS, 0, 0, 0 },
+ { CPERF_CYCLECOUNT_DELAY_US, required_argument, 0, 0 },
{ NULL, 0, 0, 0 }
};
+
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 },
{ CPERF_HUFFMAN_ENC, parse_huffman_enc },
{ CPERF_LEVEL, parse_level },
{ CPERF_WINDOW_SIZE, parse_window_sz },
+ { CPERF_EXTERNAL_MBUFS, parse_external_mbufs },
+ { CPERF_CYCLECOUNT_DELAY_US, parse_cyclecount_delay_us },
};
unsigned int i;
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->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_THROUGHPUT;
+ test_data->use_external_mbufs = 0;
+ test_data->cyclecount_delay = 500;
}
int