4 * Copyright(c) 2016-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 #include <rte_cryptodev.h>
37 #include <rte_malloc.h>
39 #include "cperf_options.h"
47 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
52 for (i = 0; i < map_len; i++) {
54 if (strcmp(str_key, map[i].name) == 0)
62 parse_cperf_test_type(struct cperf_options *opts, const char *arg)
64 struct name_id_map cperftest_namemap[] = {
66 cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT],
67 CPERF_TEST_TYPE_THROUGHPUT
70 cperf_test_type_strs[CPERF_TEST_TYPE_CYCLECOUNT],
71 CPERF_TEST_TYPE_CYCLECOUNT
74 cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY],
75 CPERF_TEST_TYPE_LATENCY
79 int id = get_str_key_id_mapping(
80 (struct name_id_map *)cperftest_namemap,
81 RTE_DIM(cperftest_namemap), arg);
83 RTE_LOG(ERR, USER1, "failed to parse test type");
87 opts->test = (enum cperf_perf_test_type)id;
93 parse_uint32_t(uint32_t *value, const char *arg)
96 unsigned long n = strtoul(arg, &end, 10);
98 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0'))
104 *value = (uint32_t) n;
110 parse_uint16_t(uint16_t *value, const char *arg)
113 int ret = parse_uint32_t(&val, arg);
118 if (val > UINT16_MAX)
121 *value = (uint16_t) val;
127 parse_total_ops(struct cperf_options *opts, const char *arg)
129 int ret = parse_uint32_t(&opts->total_ops, arg);
132 RTE_LOG(ERR, USER1, "failed to parse total operations count\n");
134 if (opts->total_ops == 0) {
136 "invalid total operations count number specified\n");
144 parse_pool_sz(struct cperf_options *opts, const char *arg)
146 int ret = parse_uint32_t(&opts->pool_sz, arg);
149 RTE_LOG(ERR, USER1, "failed to parse pool size");
154 parse_burst_sz(struct cperf_options *opts, const char *arg)
156 int ret = parse_uint32_t(&opts->burst_sz, arg);
159 RTE_LOG(ERR, USER1, "failed to parse burst size");
164 parse_buffer_sz(struct cperf_options *opts, const char *arg)
166 uint32_t i, valid_buf_sz[] = {
167 32, 64, 128, 256, 384, 512, 768, 1024, 1280, 1536, 1792,
171 if (parse_uint32_t(&opts->buffer_sz, arg)) {
172 RTE_LOG(ERR, USER1, "failed to parse buffer size");
176 for (i = 0; i < RTE_DIM(valid_buf_sz); i++)
177 if (valid_buf_sz[i] == opts->buffer_sz)
180 RTE_LOG(ERR, USER1, "invalid buffer size specified");
185 parse_segments_nb(struct cperf_options *opts, const char *arg)
187 int ret = parse_uint32_t(&opts->segments_nb, arg);
190 RTE_LOG(ERR, USER1, "failed to parse segments number\n");
194 if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) {
195 RTE_LOG(ERR, USER1, "invalid segments number specified\n");
203 parse_device_type(struct cperf_options *opts, const char *arg)
205 if (strlen(arg) > (sizeof(opts->device_type) - 1))
208 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1);
209 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0';
215 parse_op_type(struct cperf_options *opts, const char *arg)
217 struct name_id_map optype_namemap[] = {
219 cperf_op_type_strs[CPERF_CIPHER_ONLY],
223 cperf_op_type_strs[CPERF_AUTH_ONLY],
227 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH],
228 CPERF_CIPHER_THEN_AUTH
231 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER],
232 CPERF_AUTH_THEN_CIPHER
235 cperf_op_type_strs[CPERF_AEAD],
240 int id = get_str_key_id_mapping(optype_namemap,
241 RTE_DIM(optype_namemap), arg);
243 RTE_LOG(ERR, USER1, "invalid opt type specified\n");
247 opts->op_type = (enum cperf_op_type)id;
253 parse_sessionless(struct cperf_options *opts,
254 const char *arg __rte_unused)
256 opts->sessionless = 1;
261 parse_out_of_place(struct cperf_options *opts,
262 const char *arg __rte_unused)
264 opts->out_of_place = 1;
269 parse_verify(struct cperf_options *opts,
270 const char *arg __rte_unused)
278 parse_test_file(struct cperf_options *opts,
281 opts->test_file = strdup(arg);
282 if (access(opts->test_file, F_OK) != -1)
284 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n");
290 parse_test_name(struct cperf_options *opts,
293 char *test_name = (char *) rte_zmalloc(NULL,
294 sizeof(char) * (strlen(arg) + 3), 0);
295 snprintf(test_name, strlen(arg) + 3, "[%s]", arg);
296 opts->test_name = test_name;
302 parse_silent(struct cperf_options *opts,
303 const char *arg __rte_unused)
311 parse_cipher_algo(struct cperf_options *opts, const char *arg)
314 enum rte_crypto_cipher_algorithm cipher_algo;
316 if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) {
317 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n");
321 opts->cipher_algo = cipher_algo;
327 parse_cipher_op(struct cperf_options *opts, const char *arg)
329 struct name_id_map cipher_op_namemap[] = {
331 rte_crypto_cipher_operation_strings
332 [RTE_CRYPTO_CIPHER_OP_ENCRYPT],
333 RTE_CRYPTO_CIPHER_OP_ENCRYPT },
335 rte_crypto_cipher_operation_strings
336 [RTE_CRYPTO_CIPHER_OP_DECRYPT],
337 RTE_CRYPTO_CIPHER_OP_DECRYPT
341 int id = get_str_key_id_mapping(cipher_op_namemap,
342 RTE_DIM(cipher_op_namemap), arg);
344 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n");
348 opts->cipher_op = (enum rte_crypto_cipher_operation)id;
354 parse_cipher_key_sz(struct cperf_options *opts, const char *arg)
356 return parse_uint16_t(&opts->cipher_key_sz, arg);
360 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg)
362 return parse_uint16_t(&opts->cipher_iv_sz, arg);
366 parse_auth_algo(struct cperf_options *opts, const char *arg)
368 enum rte_crypto_auth_algorithm auth_algo;
370 if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) {
371 RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n");
375 opts->auth_algo = auth_algo;
381 parse_auth_op(struct cperf_options *opts, const char *arg)
383 struct name_id_map auth_op_namemap[] = {
385 rte_crypto_auth_operation_strings
386 [RTE_CRYPTO_AUTH_OP_GENERATE],
387 RTE_CRYPTO_AUTH_OP_GENERATE },
389 rte_crypto_auth_operation_strings
390 [RTE_CRYPTO_AUTH_OP_VERIFY],
391 RTE_CRYPTO_AUTH_OP_VERIFY
395 int id = get_str_key_id_mapping(auth_op_namemap,
396 RTE_DIM(auth_op_namemap), arg);
398 RTE_LOG(ERR, USER1, "invalid authentication operation specified"
403 opts->auth_op = (enum rte_crypto_auth_operation)id;
409 parse_auth_key_sz(struct cperf_options *opts, const char *arg)
411 return parse_uint16_t(&opts->auth_key_sz, arg);
415 parse_auth_digest_sz(struct cperf_options *opts, const char *arg)
417 return parse_uint16_t(&opts->auth_digest_sz, arg);
421 parse_auth_aad_sz(struct cperf_options *opts, const char *arg)
423 return parse_uint16_t(&opts->auth_aad_sz, arg);
427 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused)
434 typedef int (*option_parser_t)(struct cperf_options *opts,
437 struct long_opt_parser {
438 const char *lgopt_name;
439 option_parser_t parser_fn;
443 static struct option lgopts[] = {
445 { CPERF_PTEST_TYPE, required_argument, 0, 0 },
447 { CPERF_POOL_SIZE, required_argument, 0, 0 },
448 { CPERF_TOTAL_OPS, required_argument, 0, 0 },
449 { CPERF_BURST_SIZE, required_argument, 0, 0 },
450 { CPERF_BUFFER_SIZE, required_argument, 0, 0 },
451 { CPERF_SEGMENTS_NB, required_argument, 0, 0 },
453 { CPERF_DEVTYPE, required_argument, 0, 0 },
454 { CPERF_OPTYPE, required_argument, 0, 0 },
456 { CPERF_SILENT, no_argument, 0, 0 },
457 { CPERF_SESSIONLESS, no_argument, 0, 0 },
458 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 },
459 { CPERF_VERIFY, no_argument, 0, 0 },
460 { CPERF_TEST_FILE, required_argument, 0, 0 },
461 { CPERF_TEST_NAME, required_argument, 0, 0 },
463 { CPERF_CIPHER_ALGO, required_argument, 0, 0 },
464 { CPERF_CIPHER_OP, required_argument, 0, 0 },
466 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 },
467 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 },
469 { CPERF_AUTH_ALGO, required_argument, 0, 0 },
470 { CPERF_AUTH_OP, required_argument, 0, 0 },
472 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 },
473 { CPERF_AUTH_DIGEST_SZ, required_argument, 0, 0 },
474 { CPERF_AUTH_AAD_SZ, required_argument, 0, 0 },
475 { CPERF_CSV, no_argument, 0, 0},
481 cperf_options_default(struct cperf_options *opts)
483 opts->test = CPERF_TEST_TYPE_THROUGHPUT;
485 opts->pool_sz = 8192;
486 opts->total_ops = 10000000;
488 opts->buffer_sz = 64;
489 opts->segments_nb = 1;
491 strncpy(opts->device_type, "crypto_aesni_mb",
492 sizeof(opts->device_type));
494 opts->op_type = CPERF_CIPHER_THEN_AUTH;
498 opts->test_file = NULL;
499 opts->test_name = NULL;
500 opts->sessionless = 0;
501 opts->out_of_place = 0;
504 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC;
505 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
506 opts->cipher_key_sz = 16;
507 opts->cipher_iv_sz = 16;
509 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
510 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE;
512 opts->auth_key_sz = 64;
513 opts->auth_digest_sz = 12;
514 opts->auth_aad_sz = 0;
518 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts)
520 struct long_opt_parser parsermap[] = {
521 { CPERF_PTEST_TYPE, parse_cperf_test_type },
522 { CPERF_SILENT, parse_silent },
523 { CPERF_POOL_SIZE, parse_pool_sz },
524 { CPERF_TOTAL_OPS, parse_total_ops },
525 { CPERF_BURST_SIZE, parse_burst_sz },
526 { CPERF_BUFFER_SIZE, parse_buffer_sz },
527 { CPERF_SEGMENTS_NB, parse_segments_nb },
528 { CPERF_DEVTYPE, parse_device_type },
529 { CPERF_OPTYPE, parse_op_type },
530 { CPERF_SESSIONLESS, parse_sessionless },
531 { CPERF_OUT_OF_PLACE, parse_out_of_place },
532 { CPERF_VERIFY, parse_verify },
533 { CPERF_TEST_FILE, parse_test_file },
534 { CPERF_TEST_NAME, parse_test_name },
535 { CPERF_CIPHER_ALGO, parse_cipher_algo },
536 { CPERF_CIPHER_OP, parse_cipher_op },
537 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz },
538 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz },
539 { CPERF_AUTH_ALGO, parse_auth_algo },
540 { CPERF_AUTH_OP, parse_auth_op },
541 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz },
542 { CPERF_AUTH_DIGEST_SZ, parse_auth_digest_sz },
543 { CPERF_AUTH_AAD_SZ, parse_auth_aad_sz },
544 { CPERF_CSV, parse_csv_friendly},
548 for (i = 0; i < RTE_DIM(parsermap); i++) {
549 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
550 strlen(lgopts[opt_idx].name)) == 0)
551 return parsermap[i].parser_fn(opts, optarg);
558 cperf_options_parse(struct cperf_options *options, int argc, char **argv)
560 int opt, retval, opt_idx;
562 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) {
567 retval = cperf_opts_parse_long(opt_idx, options);
582 cperf_options_check(struct cperf_options *options)
584 if (options->segments_nb > options->buffer_sz) {
586 "Segments number greater than buffer size.\n");
590 if (options->verify && options->test_file == NULL) {
591 RTE_LOG(ERR, USER1, "Define path to the file with test"
596 if (options->test_name != NULL && options->test_file == NULL) {
597 RTE_LOG(ERR, USER1, "Define path to the file with test"
602 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY &&
603 options->test_file == NULL) {
604 RTE_LOG(ERR, USER1, "Define path to the file with test"
609 if (options->verify &&
610 options->total_ops > options->pool_sz) {
611 RTE_LOG(ERR, USER1, "Total number of ops must be less than or"
612 " equal to the pool size.\n");
616 if (options->op_type == CPERF_CIPHER_THEN_AUTH) {
617 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
619 RTE_CRYPTO_AUTH_OP_GENERATE) {
620 RTE_LOG(ERR, USER1, "Option cipher then auth must use"
621 " options: encrypt and generate.\n");
624 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) {
625 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT &&
627 RTE_CRYPTO_AUTH_OP_VERIFY) {
628 RTE_LOG(ERR, USER1, "Option auth then cipher must use"
629 " options: decrypt and verify.\n");
632 } else if (options->op_type == CPERF_AEAD) {
633 if (!(options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
635 RTE_CRYPTO_AUTH_OP_GENERATE) &&
636 !(options->cipher_op ==
637 RTE_CRYPTO_CIPHER_OP_DECRYPT &&
639 RTE_CRYPTO_AUTH_OP_VERIFY)) {
640 RTE_LOG(ERR, USER1, "Use together options: encrypt and"
641 " generate or decrypt and verify.\n");
646 if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_GCM ||
647 options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CCM ||
648 options->auth_algo == RTE_CRYPTO_AUTH_AES_GCM ||
649 options->auth_algo == RTE_CRYPTO_AUTH_AES_CCM ||
650 options->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
651 if (options->op_type != CPERF_AEAD) {
652 RTE_LOG(ERR, USER1, "Use --optype aead\n");
661 cperf_options_dump(struct cperf_options *opts)
663 printf("# Crypto Performance Application Options:\n");
665 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]);
667 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz);
668 printf("# total number of ops: %u\n", opts->total_ops);
669 printf("# burst size: %u\n", opts->burst_sz);
670 printf("# buffer size: %u\n", opts->buffer_sz);
671 printf("# segments per buffer: %u\n", opts->segments_nb);
673 printf("# cryptodev type: %s\n", opts->device_type);
675 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]);
676 printf("# verify operation: %s\n", opts->verify ? "yes" : "no");
677 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no");
678 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no");
682 if (opts->op_type == CPERF_AUTH_ONLY ||
683 opts->op_type == CPERF_CIPHER_THEN_AUTH ||
684 opts->op_type == CPERF_AUTH_THEN_CIPHER ||
685 opts->op_type == CPERF_AEAD) {
686 printf("# auth algorithm: %s\n",
687 rte_crypto_auth_algorithm_strings[opts->auth_algo]);
688 printf("# auth operation: %s\n",
689 rte_crypto_auth_operation_strings[opts->auth_op]);
690 printf("# auth key size: %u\n", opts->auth_key_sz);
691 printf("# auth digest size: %u\n", opts->auth_digest_sz);
692 printf("# auth aad size: %u\n", opts->auth_aad_sz);
696 if (opts->op_type == CPERF_CIPHER_ONLY ||
697 opts->op_type == CPERF_CIPHER_THEN_AUTH ||
698 opts->op_type == CPERF_AUTH_THEN_CIPHER ||
699 opts->op_type == CPERF_AEAD) {
700 printf("# cipher algorithm: %s\n",
701 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]);
702 printf("# cipher operation: %s\n",
703 rte_crypto_cipher_operation_strings[opts->cipher_op]);
704 printf("# cipher key size: %u\n", opts->cipher_key_sz);
705 printf("# cipher iv size: %u\n", opts->cipher_iv_sz);