From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id 3C0A9F614 for ; Fri, 3 Mar 2017 17:11:14 +0100 (CET) Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 03 Mar 2017 08:11:13 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.35,237,1484035200"; d="scan'208";a="1118073442" Received: from silpixa00381631.ir.intel.com (HELO silpixa00381631.ger.corp.intel.com) ([10.237.222.122]) by fmsmga001.fm.intel.com with ESMTP; 03 Mar 2017 08:11:12 -0800 From: Pablo de Lara To: declan.doherty@intel.com Cc: dev@dpdk.org, Pablo de Lara Date: Fri, 3 Mar 2017 16:13:12 +0000 Message-Id: <1488557592-46193-4-git-send-email-pablo.de.lara.guarch@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1488557592-46193-1-git-send-email-pablo.de.lara.guarch@intel.com> References: <1488557592-46193-1-git-send-email-pablo.de.lara.guarch@intel.com> Subject: [dpdk-dev] [PATCH 3/3] app/crypto-perf: add range/list of sizes X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 03 Mar 2017 16:11:16 -0000 So far, the crypto performance application was only able to test one buffer size and one burst size. With this commit, multiple sizes can be passed, either as a range of values or as a list of values. Signed-off-by: Pablo de Lara --- app/test-crypto-perf/cperf_ops.c | 20 +- app/test-crypto-perf/cperf_options.h | 29 +- app/test-crypto-perf/cperf_options_parsing.c | 234 +++++++++++-- app/test-crypto-perf/cperf_test_latency.c | 400 +++++++++++------------ app/test-crypto-perf/cperf_test_throughput.c | 340 ++++++++++--------- app/test-crypto-perf/cperf_test_vector_parsing.c | 12 +- app/test-crypto-perf/cperf_test_vectors.c | 8 +- app/test-crypto-perf/cperf_test_verify.c | 115 +++---- app/test-crypto-perf/cperf_verify_parser.c | 4 +- app/test-crypto-perf/main.c | 50 ++- doc/guides/tools/cryptoperf.rst | 15 + 11 files changed, 707 insertions(+), 520 deletions(-) diff --git a/app/test-crypto-perf/cperf_ops.c b/app/test-crypto-perf/cperf_ops.c index b8c0398..e25e011 100644 --- a/app/test-crypto-perf/cperf_ops.c +++ b/app/test-crypto-perf/cperf_ops.c @@ -53,7 +53,7 @@ cperf_set_ops_null_cipher(struct rte_crypto_op **ops, sym_op->m_dst = bufs_out[i]; /* cipher parameters */ - sym_op->cipher.data.length = options->buffer_sz; + sym_op->cipher.data.length = options->test_buffer_size; sym_op->cipher.data.offset = 0; } @@ -78,7 +78,7 @@ cperf_set_ops_null_auth(struct rte_crypto_op **ops, sym_op->m_dst = bufs_out[i]; /* auth parameters */ - sym_op->auth.data.length = options->buffer_sz; + sym_op->auth.data.length = options->test_buffer_size; sym_op->auth.data.offset = 0; } @@ -107,7 +107,7 @@ cperf_set_ops_cipher(struct rte_crypto_op **ops, sym_op->cipher.iv.phys_addr = test_vector->iv.phys_addr; sym_op->cipher.iv.length = test_vector->iv.length; - sym_op->cipher.data.length = options->buffer_sz; + sym_op->cipher.data.length = options->test_buffer_size; sym_op->cipher.data.offset = 0; } @@ -139,7 +139,7 @@ cperf_set_ops_auth(struct rte_crypto_op **ops, sym_op->auth.digest.length = options->auth_digest_sz; } else { - uint32_t offset = options->buffer_sz; + uint32_t offset = options->test_buffer_size; struct rte_mbuf *buf, *tbuf; if (options->out_of_place) { @@ -166,7 +166,7 @@ cperf_set_ops_auth(struct rte_crypto_op **ops, } - sym_op->auth.data.length = options->buffer_sz; + sym_op->auth.data.length = options->test_buffer_size; sym_op->auth.data.offset = 0; } @@ -195,7 +195,7 @@ cperf_set_ops_cipher_auth(struct rte_crypto_op **ops, sym_op->cipher.iv.phys_addr = test_vector->iv.phys_addr; sym_op->cipher.iv.length = test_vector->iv.length; - sym_op->cipher.data.length = options->buffer_sz; + sym_op->cipher.data.length = options->test_buffer_size; sym_op->cipher.data.offset = 0; /* authentication parameters */ @@ -206,7 +206,7 @@ cperf_set_ops_cipher_auth(struct rte_crypto_op **ops, sym_op->auth.digest.length = options->auth_digest_sz; } else { - uint32_t offset = options->buffer_sz; + uint32_t offset = options->test_buffer_size; struct rte_mbuf *buf, *tbuf; if (options->out_of_place) { @@ -232,7 +232,7 @@ cperf_set_ops_cipher_auth(struct rte_crypto_op **ops, sym_op->auth.aad.length = options->auth_aad_sz; } - sym_op->auth.data.length = options->buffer_sz; + sym_op->auth.data.length = options->test_buffer_size; sym_op->auth.data.offset = 0; } @@ -261,7 +261,7 @@ cperf_set_ops_aead(struct rte_crypto_op **ops, sym_op->cipher.iv.phys_addr = test_vector->iv.phys_addr; sym_op->cipher.iv.length = test_vector->iv.length; - sym_op->cipher.data.length = options->buffer_sz; + sym_op->cipher.data.length = options->test_buffer_size; sym_op->cipher.data.offset = RTE_ALIGN_CEIL(options->auth_aad_sz, 16); @@ -302,7 +302,7 @@ cperf_set_ops_aead(struct rte_crypto_op **ops, sym_op->auth.digest.length = options->auth_digest_sz; } - sym_op->auth.data.length = options->buffer_sz; + sym_op->auth.data.length = options->test_buffer_size; sym_op->auth.data.offset = options->auth_aad_sz; } diff --git a/app/test-crypto-perf/cperf_options.h b/app/test-crypto-perf/cperf_options.h index 823059d..fc34c48 100644 --- a/app/test-crypto-perf/cperf_options.h +++ b/app/test-crypto-perf/cperf_options.h @@ -32,6 +32,7 @@ #define CPERF_AUTH_AAD_SZ ("auth-aad-sz") #define CPERF_CSV ("csv-friendly") +#define MAX_LIST 32 enum cperf_perf_test_type { CPERF_TEST_TYPE_THROUGHPUT, @@ -58,21 +59,14 @@ struct cperf_options { uint32_t pool_sz; uint32_t total_ops; - uint32_t burst_sz; - uint32_t buffer_sz; uint32_t segments_nb; - - char device_type[RTE_CRYPTODEV_NAME_LEN]; - enum cperf_op_type op_type; + uint32_t test_buffer_size; uint32_t sessionless:1; uint32_t out_of_place:1; uint32_t silent:1; uint32_t csv:1; - char *test_file; - char *test_name; - enum rte_crypto_cipher_algorithm cipher_algo; enum rte_crypto_cipher_operation cipher_op; @@ -85,6 +79,25 @@ struct cperf_options { uint16_t auth_key_sz; uint16_t auth_digest_sz; uint16_t auth_aad_sz; + + char device_type[RTE_CRYPTODEV_NAME_LEN]; + enum cperf_op_type op_type; + + char *test_file; + char *test_name; + + uint32_t buffer_size_list[MAX_LIST]; + uint8_t buffer_size_count; + uint32_t max_buffer_size; + uint32_t min_buffer_size; + uint32_t inc_buffer_size; + + uint32_t burst_size_list[MAX_LIST]; + uint8_t burst_size_count; + uint32_t max_burst_size; + uint32_t min_burst_size; + uint32_t inc_burst_size; + }; void diff --git a/app/test-crypto-perf/cperf_options_parsing.c b/app/test-crypto-perf/cperf_options_parsing.c index d89c239..3a3259f 100644 --- a/app/test-crypto-perf/cperf_options_parsing.c +++ b/app/test-crypto-perf/cperf_options_parsing.c @@ -38,6 +38,9 @@ #include "cperf_options.h" +#define AES_BLOCK_SIZE 16 +#define DES_BLOCK_SIZE 8 + struct name_id_map { const char *name; uint32_t id; @@ -124,6 +127,132 @@ parse_uint16_t(uint16_t *value, const char *arg) } static int +parse_range(const char *arg, uint32_t *min, uint32_t *max, uint32_t *inc) +{ + char *token; + uint32_t number; + + char *copy_arg = strdup(arg); + + if (copy_arg == NULL) + return -1; + + token = strtok(copy_arg, ":"); + + /* Parse minimum value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_range; + + *min = number; + } else + goto err_range; + + token = strtok(NULL, ":"); + + /* Parse increment value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_range; + + *inc = number; + } else + goto err_range; + + token = strtok(NULL, ":"); + + /* Parse maximum value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0 || + number < *min) + goto err_range; + + *max = number; + } else + goto err_range; + + if (strtok(NULL, ":") != NULL) + goto err_range; + + free(copy_arg); + return 0; + +err_range: + free(copy_arg); + return -1; +} + +static int +parse_list(const char *arg, uint32_t *list, uint32_t *min, uint32_t *max) +{ + char *token; + uint32_t number; + uint8_t count = 0; + + char *copy_arg = strdup(arg); + + if (copy_arg == NULL) + return -1; + + token = strtok(copy_arg, ","); + + /* Parse first value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_list; + + list[count++] = number; + *min = number; + *max = number; + } else + goto err_list; + + token = strtok(NULL, ","); + + while (token != NULL) { + if (count == MAX_LIST) { + RTE_LOG(WARNING, USER1, "Using only the first %u sizes\n", + MAX_LIST); + break; + } + + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_list; + + list[count++] = number; + + if (number < *min) + *min = number; + if (number > *max) + *max = number; + + token = strtok(NULL, ","); + } + + free(copy_arg); + return count; + +err_list: + free(copy_arg); + return -1; +} + +static int parse_total_ops(struct cperf_options *opts, const char *arg) { int ret = parse_uint32_t(&opts->total_ops, arg); @@ -153,32 +282,43 @@ parse_pool_sz(struct cperf_options *opts, const char *arg) static int parse_burst_sz(struct cperf_options *opts, const char *arg) { - int ret = parse_uint32_t(&opts->burst_sz, arg); + int ret; + + /* Try parsing the argument as a range, if it fails, parse it as a list */ + if (parse_range(arg, &opts->min_burst_size, &opts->max_burst_size, + &opts->inc_burst_size) < 0) { + ret = parse_list(arg, opts->burst_size_list, + &opts->min_burst_size, + &opts->max_burst_size); + if (ret < 0) { + RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); + return -1; + } + opts->burst_size_count = ret; + } - if (ret) - RTE_LOG(ERR, USER1, "failed to parse burst size"); - return ret; + return 0; } static int parse_buffer_sz(struct cperf_options *opts, const char *arg) { - uint32_t i, valid_buf_sz[] = { - 32, 64, 128, 256, 384, 512, 768, 1024, 1280, 1536, 1792, - 2048 - }; - - if (parse_uint32_t(&opts->buffer_sz, arg)) { - RTE_LOG(ERR, USER1, "failed to parse buffer size"); - return -1; + int ret; + + /* Try parsing the argument as a range, if it fails, parse it as a list */ + if (parse_range(arg, &opts->min_buffer_size, &opts->max_buffer_size, + &opts->inc_buffer_size) < 0) { + ret = parse_list(arg, opts->buffer_size_list, + &opts->min_buffer_size, + &opts->max_buffer_size); + if (ret < 0) { + RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); + return -1; + } + opts->buffer_size_count = ret; } - for (i = 0; i < RTE_DIM(valid_buf_sz); i++) - if (valid_buf_sz[i] == opts->buffer_sz) - return 0; - - RTE_LOG(ERR, USER1, "invalid buffer size specified"); - return -1; + return 0; } static int @@ -474,8 +614,19 @@ cperf_options_default(struct cperf_options *opts) opts->pool_sz = 8192; opts->total_ops = 10000000; - opts->burst_sz = 32; - opts->buffer_sz = 64; + + opts->buffer_size_list[0] = 64; + opts->buffer_size_count = 1; + opts->max_buffer_size = 64; + opts->min_buffer_size = 64; + opts->inc_buffer_size = 0; + + opts->burst_size_list[0] = 32; + opts->burst_size_count = 1; + opts->max_burst_size = 32; + opts->min_burst_size = 32; + opts->inc_burst_size = 0; + opts->segments_nb = 1; strncpy(opts->device_type, "crypto_aesni_mb", @@ -569,7 +720,9 @@ cperf_options_parse(struct cperf_options *options, int argc, char **argv) int cperf_options_check(struct cperf_options *options) { - if (options->segments_nb > options->buffer_sz) { + uint32_t buffer_size; + + if (options->segments_nb > options->min_buffer_size) { RTE_LOG(ERR, USER1, "Segments number greater than buffer size.\n"); return -EINVAL; @@ -632,6 +785,33 @@ cperf_options_check(struct cperf_options *options) } } + if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CBC || + options->cipher_algo == RTE_CRYPTO_CIPHER_AES_ECB) { + for (buffer_size = options->min_buffer_size; + buffer_size < options->max_buffer_size; + buffer_size += options->inc_buffer_size) { + if ((buffer_size % AES_BLOCK_SIZE) != 0) { + RTE_LOG(ERR, USER1, "Some of the buffer sizes are " + "not suitable for the algorithm selected\n"); + return -EINVAL; + } + } + } + + if (options->cipher_algo == RTE_CRYPTO_CIPHER_DES_CBC || + options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_CBC || + options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_ECB) { + for (buffer_size = options->min_buffer_size; + buffer_size < options->max_buffer_size; + buffer_size += options->inc_buffer_size) { + if ((buffer_size % DES_BLOCK_SIZE) != 0) { + RTE_LOG(ERR, USER1, "Some of the buffer sizes are " + "not suitable for the algorithm selected\n"); + return -EINVAL; + } + } + } + return 0; } @@ -644,9 +824,15 @@ cperf_options_dump(struct cperf_options *opts) printf("#\n"); printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); printf("# total number of ops: %u\n", opts->total_ops); - printf("# burst size: %u\n", opts->burst_sz); - printf("# buffer size: %u\n", opts->buffer_sz); - printf("# segments per buffer: %u\n", opts->segments_nb); + printf("# buffer size:\n"); + printf("#\t min: %u\n", opts->min_buffer_size); + printf("#\t max: %u\n", opts->max_buffer_size); + printf("#\t inc: %u\n", opts->inc_buffer_size); + printf("# burst sizes:\n"); + printf("#\t min: %u\n", opts->min_burst_size); + printf("#\t max: %u\n", opts->max_burst_size); + printf("#\t inc: %u\n", opts->inc_burst_size); + printf("\n# segments per buffer: %u\n", opts->segments_nb); printf("#\n"); printf("# cryptodev type: %s\n", opts->device_type); printf("#\n"); diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c index 25f7749..84d03cd 100644 --- a/app/test-crypto-perf/cperf_test_latency.c +++ b/app/test-crypto-perf/cperf_test_latency.c @@ -39,26 +39,6 @@ #include "cperf_ops.h" -struct cperf_latency_results { - - uint64_t ops_failed; - - uint64_t enqd_tot; - uint64_t enqd_max; - uint64_t enqd_min; - - uint64_t deqd_tot; - uint64_t deqd_max; - uint64_t deqd_min; - - uint64_t cycles_tot; - uint64_t cycles_max; - uint64_t cycles_min; - - uint64_t burst_num; - uint64_t num; -}; - struct cperf_op_result { uint64_t tsc_start; uint64_t tsc_end; @@ -84,7 +64,6 @@ struct cperf_latency_ctx { const struct cperf_options *options; const struct cperf_test_vector *test_vector; struct cperf_op_result *res; - struct cperf_latency_results results; }; #define max(a, b) (a > b ? (uint64_t)a : (uint64_t)b) @@ -136,8 +115,8 @@ cperf_mbuf_create(struct rte_mempool *mempool, const struct cperf_test_vector *test_vector) { struct rte_mbuf *mbuf; - uint32_t segment_sz = options->buffer_sz / segments_nb; - uint32_t last_sz = options->buffer_sz % segments_nb; + uint32_t segment_sz = options->max_buffer_size / segments_nb; + uint32_t last_sz = options->max_buffer_size % segments_nb; uint8_t *mbuf_data; uint8_t *test_data = (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? @@ -239,8 +218,8 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id, options->pool_sz * options->segments_nb, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - (options->buffer_sz / options->segments_nb) + - (options->buffer_sz % options->segments_nb) + + (options->max_buffer_size / options->segments_nb) + + (options->max_buffer_size % options->segments_nb) + options->auth_digest_sz), rte_socket_id()); @@ -248,9 +227,6 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id, goto err; /* Generate mbufs_in with plaintext populated for test */ - if (ctx->options->pool_sz % ctx->options->burst_sz) - goto err; - ctx->mbufs_in = rte_malloc(NULL, (sizeof(struct rte_mbuf *) * ctx->options->pool_sz), 0); @@ -273,7 +249,7 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id, pool_name, options->pool_sz, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - options->buffer_sz + + options->max_buffer_size + options->auth_digest_sz), rte_socket_id()); @@ -324,20 +300,17 @@ cperf_latency_test_runner(void *arg) { struct cperf_latency_ctx *ctx = arg; struct cperf_op_result *pres; + uint32_t i; + uint16_t test_burst_size; + uint8_t burst_size_idx = 0; + + static int only_once; if (ctx == NULL) return 0; - struct rte_crypto_op *ops[ctx->options->burst_sz]; - struct rte_crypto_op *ops_processed[ctx->options->burst_sz]; - uint64_t ops_enqd = 0, ops_deqd = 0; - uint16_t ops_unused = 0; - uint64_t m_idx = 0, b_idx = 0, i; - - uint64_t tsc_val, tsc_end, tsc_start; - uint64_t tsc_max = 0, tsc_min = ~0UL, tsc_tot = 0, tsc_idx = 0; - uint64_t enqd_max = 0, enqd_min = ~0UL, enqd_tot = 0; - uint64_t deqd_max = 0, deqd_min = ~0UL, deqd_tot = 0; + struct rte_crypto_op *ops[ctx->options->max_burst_size]; + struct rte_crypto_op *ops_processed[ctx->options->max_burst_size]; uint32_t lcore = rte_lcore_id(); @@ -360,143 +333,210 @@ cperf_latency_test_runner(void *arg) for (i = 0; i < ctx->options->total_ops; i++) rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); - while (enqd_tot < ctx->options->total_ops) { + /* Get first size from range or list */ + if (ctx->options->inc_burst_size != 0) + test_burst_size = ctx->options->min_burst_size; + else + test_burst_size = ctx->options->burst_size_list[0]; + + while (test_burst_size <= ctx->options->max_burst_size) { + uint64_t ops_enqd = 0, ops_deqd = 0; + uint16_t ops_unused = 0; + uint64_t m_idx = 0, b_idx = 0, i; + + uint64_t tsc_val, tsc_end, tsc_start; + uint64_t tsc_max = 0, tsc_min = ~0UL, tsc_tot = 0, tsc_idx = 0; + uint64_t enqd_max = 0, enqd_min = ~0UL, enqd_tot = 0; + uint64_t deqd_max = 0, deqd_min = ~0UL, deqd_tot = 0; + + while (enqd_tot < ctx->options->total_ops) { + + uint16_t burst_size = ((enqd_tot + test_burst_size) + <= ctx->options->total_ops) ? + test_burst_size : + ctx->options->total_ops - + enqd_tot; + uint16_t ops_needed = burst_size - ops_unused; + + /* Allocate crypto ops from pool */ + if (ops_needed != rte_crypto_op_bulk_alloc( + ctx->crypto_op_pool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC, + ops, ops_needed)) + return -1; + + /* Setup crypto op, attach mbuf etc */ + (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx], + &ctx->mbufs_out[m_idx], + ops_needed, ctx->sess, ctx->options, + ctx->test_vector); + + tsc_start = rte_rdtsc_precise(); - uint16_t burst_size = ((enqd_tot + ctx->options->burst_sz) - <= ctx->options->total_ops) ? - ctx->options->burst_sz : - ctx->options->total_ops - - enqd_tot; - uint16_t ops_needed = burst_size - ops_unused; +#ifdef CPERF_LINEARIZATION_ENABLE + if (linearize) { + /* PMD doesn't support scatter-gather and source buffer + * is segmented. + * We need to linearize it before enqueuing. + */ + for (i = 0; i < burst_size; i++) + rte_pktmbuf_linearize(ops[i]->sym->m_src); + } +#endif /* CPERF_LINEARIZATION_ENABLE */ - /* Allocate crypto ops from pool */ - if (ops_needed != rte_crypto_op_bulk_alloc( - ctx->crypto_op_pool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC, - ops, ops_needed)) - return -1; + /* Enqueue burst of ops on crypto device */ + ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, + ops, burst_size); - /* Setup crypto op, attach mbuf etc */ - (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx], - &ctx->mbufs_out[m_idx], - ops_needed, ctx->sess, ctx->options, - ctx->test_vector); + /* Dequeue processed burst of ops from crypto device */ + ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, + ops_processed, test_burst_size); - tsc_start = rte_rdtsc_precise(); + tsc_end = rte_rdtsc_precise(); -#ifdef CPERF_LINEARIZATION_ENABLE - if (linearize) { - /* PMD doesn't support scatter-gather and source buffer - * is segmented. - * We need to linearize it before enqueuing. + for (i = 0; i < ops_needed; i++) { + ctx->res[tsc_idx].tsc_start = tsc_start; + ops[i]->opaque_data = (void *)&ctx->res[tsc_idx]; + tsc_idx++; + } + + /* + * Calculate number of ops not enqueued (mainly for hw + * accelerators whose ingress queue can fill up). */ - for (i = 0; i < burst_size; i++) - rte_pktmbuf_linearize(ops[i]->sym->m_src); - } -#endif /* CPERF_LINEARIZATION_ENABLE */ + ops_unused = burst_size - ops_enqd; + + if (likely(ops_deqd)) { + /* + * free crypto ops so they can be reused. We don't free + * the mbufs here as we don't want to reuse them as + * the crypto operation will change the data and cause + * failures. + */ + for (i = 0; i < ops_deqd; i++) { + pres = (struct cperf_op_result *) + (ops_processed[i]->opaque_data); + pres->status = ops_processed[i]->status; + pres->tsc_end = tsc_end; + + rte_crypto_op_free(ops_processed[i]); + } + + deqd_tot += ops_deqd; + deqd_max = max(ops_deqd, deqd_max); + deqd_min = min(ops_deqd, deqd_min); + } - /* Enqueue burst of ops on crypto device */ - ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, - ops, burst_size); + enqd_tot += ops_enqd; + enqd_max = max(ops_enqd, enqd_max); + enqd_min = min(ops_enqd, enqd_min); - /* Dequeue processed burst of ops from crypto device */ - ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); + m_idx += ops_needed; + m_idx = m_idx + test_burst_size > ctx->options->pool_sz ? + 0 : m_idx; + b_idx++; + } - tsc_end = rte_rdtsc_precise(); + /* Dequeue any operations still in the crypto device */ + while (deqd_tot < ctx->options->total_ops) { + /* Sending 0 length burst to flush sw crypto device */ + rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); - for (i = 0; i < ops_needed; i++) { - ctx->res[tsc_idx].tsc_start = tsc_start; - ops[i]->opaque_data = (void *)&ctx->res[tsc_idx]; - tsc_idx++; - } + /* dequeue burst */ + ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, + ops_processed, test_burst_size); - /* - * Calculate number of ops not enqueued (mainly for hw - * accelerators whose ingress queue can fill up). - */ - ops_unused = burst_size - ops_enqd; + tsc_end = rte_rdtsc_precise(); - if (likely(ops_deqd)) { - /* - * free crypto ops so they can be reused. We don't free - * the mbufs here as we don't want to reuse them as - * the crypto operation will change the data and cause - * failures. - */ - for (i = 0; i < ops_deqd; i++) { - pres = (struct cperf_op_result *) - (ops_processed[i]->opaque_data); - pres->status = ops_processed[i]->status; - pres->tsc_end = tsc_end; + if (ops_deqd != 0) { + for (i = 0; i < ops_deqd; i++) { + pres = (struct cperf_op_result *) + (ops_processed[i]->opaque_data); + pres->status = ops_processed[i]->status; + pres->tsc_end = tsc_end; + + rte_crypto_op_free(ops_processed[i]); + } - rte_crypto_op_free(ops_processed[i]); + deqd_tot += ops_deqd; + deqd_max = max(ops_deqd, deqd_max); + deqd_min = min(ops_deqd, deqd_min); } + } - deqd_tot += ops_deqd; - deqd_max = max(ops_deqd, deqd_max); - deqd_min = min(ops_deqd, deqd_min); + for (i = 0; i < tsc_idx; i++) { + tsc_val = ctx->res[i].tsc_end - ctx->res[i].tsc_start; + tsc_max = max(tsc_val, tsc_max); + tsc_min = min(tsc_val, tsc_min); + tsc_tot += tsc_val; } - enqd_tot += ops_enqd; - enqd_max = max(ops_enqd, enqd_max); - enqd_min = min(ops_enqd, enqd_min); + double time_tot, time_avg, time_max, time_min; - m_idx += ops_needed; - m_idx = m_idx + ctx->options->burst_sz > ctx->options->pool_sz ? - 0 : m_idx; - b_idx++; - } + const uint64_t tunit = 1000000; /* us */ + const uint64_t tsc_hz = rte_get_tsc_hz(); - /* Dequeue any operations still in the crypto device */ - while (deqd_tot < ctx->options->total_ops) { - /* Sending 0 length burst to flush sw crypto device */ - rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); + uint64_t enqd_avg = enqd_tot / b_idx; + uint64_t deqd_avg = deqd_tot / b_idx; + uint64_t tsc_avg = tsc_tot / tsc_idx; - /* dequeue burst */ - ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); + time_tot = tunit*(double)(tsc_tot) / tsc_hz; + time_avg = tunit*(double)(tsc_avg) / tsc_hz; + time_max = tunit*(double)(tsc_max) / tsc_hz; + time_min = tunit*(double)(tsc_min) / tsc_hz; - tsc_end = rte_rdtsc_precise(); + if (ctx->options->csv) { + if (!only_once) + printf("\n# lcore, Buffer Size, Burst Size, Pakt Seq #, " + "Packet Size, cycles, time (us)"); - if (ops_deqd != 0) { - for (i = 0; i < ops_deqd; i++) { - pres = (struct cperf_op_result *) - (ops_processed[i]->opaque_data); - pres->status = ops_processed[i]->status; - pres->tsc_end = tsc_end; + for (i = 0; i < ctx->options->total_ops; i++) { + + printf("\n%u;%u;%u;%"PRIu64";%"PRIu64";%.3f", + ctx->lcore_id, ctx->options->test_buffer_size, + test_burst_size, i + 1, + ctx->res[i].tsc_end - ctx->res[i].tsc_start, + tunit * (double) (ctx->res[i].tsc_end + - ctx->res[i].tsc_start) + / tsc_hz); - rte_crypto_op_free(ops_processed[i]); } + only_once = 1; + } else { + printf("\n# Device %d on lcore %u\n", ctx->dev_id, + ctx->lcore_id); + printf("\n# total operations: %u", ctx->options->total_ops); + printf("\n# Buffer size: %u", ctx->options->test_buffer_size); + printf("\n# Burst size: %u", test_burst_size); + printf("\n# Number of bursts: %"PRIu64, + b_idx); + + printf("\n#"); + printf("\n# \t Total\t Average\t Maximum\t " + " Minimum"); + printf("\n# enqueued\t%12"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" + "%10"PRIu64, enqd_tot, enqd_avg, enqd_max, enqd_min); + printf("\n# dequeued\t%12"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" + "%10"PRIu64, deqd_tot, deqd_avg, deqd_max, deqd_min); + printf("\n# cycles\t%12"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" + "%10"PRIu64, tsc_tot, tsc_avg, tsc_max, tsc_min); + printf("\n# time [us]\t%12.0f\t%10.3f\t%10.3f\t%10.3f", time_tot, + time_avg, time_max, time_min); + printf("\n\n"); - deqd_tot += ops_deqd; - deqd_max = max(ops_deqd, deqd_max); - deqd_min = min(ops_deqd, deqd_min); } - } - for (i = 0; i < tsc_idx; i++) { - tsc_val = ctx->res[i].tsc_end - ctx->res[i].tsc_start; - tsc_max = max(tsc_val, tsc_max); - tsc_min = min(tsc_val, tsc_min); - tsc_tot += tsc_val; + /* Get next size from range or list */ + if (ctx->options->inc_burst_size != 0) + test_burst_size += ctx->options->inc_burst_size; + else { + if (++burst_size_idx == ctx->options->burst_size_count) + break; + test_burst_size = + ctx->options->burst_size_list[burst_size_idx]; + } } - ctx->results.enqd_tot = enqd_tot; - ctx->results.enqd_max = enqd_max; - ctx->results.enqd_min = enqd_min; - - ctx->results.deqd_tot = deqd_tot; - ctx->results.deqd_max = deqd_max; - ctx->results.deqd_min = deqd_min; - - ctx->results.cycles_tot = tsc_tot; - ctx->results.cycles_max = tsc_max; - ctx->results.cycles_min = tsc_min; - - ctx->results.burst_num = b_idx; - ctx->results.num = tsc_idx; - return 0; } @@ -504,74 +544,10 @@ void cperf_latency_test_destructor(void *arg) { struct cperf_latency_ctx *ctx = arg; - uint64_t i; + if (ctx == NULL) return; - static int only_once; - uint64_t etot, eavg, emax, emin; - uint64_t dtot, davg, dmax, dmin; - uint64_t ctot, cavg, cmax, cmin; - double ttot, tavg, tmax, tmin; - - const uint64_t tunit = 1000000; /* us */ - const uint64_t tsc_hz = rte_get_tsc_hz(); - - etot = ctx->results.enqd_tot; - eavg = ctx->results.enqd_tot / ctx->results.burst_num; - emax = ctx->results.enqd_max; - emin = ctx->results.enqd_min; - - dtot = ctx->results.deqd_tot; - davg = ctx->results.deqd_tot / ctx->results.burst_num; - dmax = ctx->results.deqd_max; - dmin = ctx->results.deqd_min; - - ctot = ctx->results.cycles_tot; - cavg = ctx->results.cycles_tot / ctx->results.num; - cmax = ctx->results.cycles_max; - cmin = ctx->results.cycles_min; - - ttot = tunit*(double)(ctot) / tsc_hz; - tavg = tunit*(double)(cavg) / tsc_hz; - tmax = tunit*(double)(cmax) / tsc_hz; - tmin = tunit*(double)(cmin) / tsc_hz; - - if (ctx->options->csv) { - if (!only_once) - printf("\n# lcore, Pakt Seq #, Packet Size, cycles," - " time (us)"); - - for (i = 0; i < ctx->options->total_ops; i++) { - - printf("\n%u;%"PRIu64";%"PRIu64";%.3f", - ctx->lcore_id, i + 1, - ctx->res[i].tsc_end - ctx->res[i].tsc_start, - tunit * (double) (ctx->res[i].tsc_end - - ctx->res[i].tsc_start) - / tsc_hz); - } - only_once = 1; - } else { - printf("\n# Device %d on lcore %u\n", ctx->dev_id, - ctx->lcore_id); - printf("\n# total operations: %u", ctx->options->total_ops); - printf("\n# burst number: %"PRIu64, - ctx->results.burst_num); - printf("\n#"); - printf("\n# \t Total\t Average\t Maximum\t " - " Minimum"); - printf("\n# enqueued\t%12"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" - "%10"PRIu64, etot, eavg, emax, emin); - printf("\n# dequeued\t%12"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" - "%10"PRIu64, dtot, davg, dmax, dmin); - printf("\n# cycles\t%12"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" - "%10"PRIu64, ctot, cavg, cmax, cmin); - printf("\n# time [us]\t%12.0f\t%10.3f\t%10.3f\t%10.3f", ttot, - tavg, tmax, tmin); - printf("\n\n"); - - } cperf_latency_test_free(ctx, ctx->options->pool_sz); } diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c index 7108075..183ff2a 100644 --- a/app/test-crypto-perf/cperf_test_throughput.c +++ b/app/test-crypto-perf/cperf_test_throughput.c @@ -38,18 +38,6 @@ #include "cperf_test_throughput.h" #include "cperf_ops.h" -struct cperf_throughput_results { - uint64_t ops_enqueued; - uint64_t ops_dequeued; - - uint64_t ops_enqueued_failed; - uint64_t ops_dequeued_failed; - - double ops_per_second; - double throughput_gbps; - double cycles_per_byte; -}; - struct cperf_throughput_ctx { uint8_t dev_id; uint16_t qp_id; @@ -68,8 +56,6 @@ struct cperf_throughput_ctx { const struct cperf_options *options; const struct cperf_test_vector *test_vector; - struct cperf_throughput_results results; - }; static void @@ -117,8 +103,8 @@ cperf_mbuf_create(struct rte_mempool *mempool, const struct cperf_test_vector *test_vector) { struct rte_mbuf *mbuf; - uint32_t segment_sz = options->buffer_sz / segments_nb; - uint32_t last_sz = options->buffer_sz % segments_nb; + uint32_t segment_sz = options->max_buffer_size / segments_nb; + uint32_t last_sz = options->max_buffer_size % segments_nb; uint8_t *mbuf_data; uint8_t *test_data = (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? @@ -220,8 +206,8 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id, options->pool_sz * options->segments_nb, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - (options->buffer_sz / options->segments_nb) + - (options->buffer_sz % options->segments_nb) + + (options->max_buffer_size / options->segments_nb) + + (options->max_buffer_size % options->segments_nb) + options->auth_digest_sz), rte_socket_id()); @@ -229,9 +215,6 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id, goto err; /* Generate mbufs_in with plaintext populated for test */ - if (ctx->options->pool_sz % ctx->options->burst_sz) - goto err; - ctx->mbufs_in = rte_malloc(NULL, (sizeof(struct rte_mbuf *) * ctx->options->pool_sz), 0); @@ -252,7 +235,7 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id, pool_name, options->pool_sz, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - options->buffer_sz + + options->max_buffer_size + options->auth_digest_sz), rte_socket_id()); @@ -296,16 +279,14 @@ int cperf_throughput_test_runner(void *test_ctx) { struct cperf_throughput_ctx *ctx = test_ctx; + uint32_t i; + uint16_t test_burst_size; + uint8_t burst_size_idx = 0; - uint64_t ops_enqd = 0, ops_enqd_total = 0, ops_enqd_failed = 0; - uint64_t ops_deqd = 0, ops_deqd_total = 0, ops_deqd_failed = 0; - - uint64_t i, m_idx = 0, tsc_start, tsc_end, tsc_duration; - - uint16_t ops_unused = 0; + static int only_once; - struct rte_crypto_op *ops[ctx->options->burst_sz]; - struct rte_crypto_op *ops_processed[ctx->options->burst_sz]; + struct rte_crypto_op *ops[ctx->options->max_burst_size]; + struct rte_crypto_op *ops_processed[ctx->options->max_burst_size]; uint32_t lcore = rte_lcore_id(); @@ -324,131 +305,189 @@ cperf_throughput_test_runner(void *test_ctx) ctx->lcore_id = lcore; - if (!ctx->options->csv) - printf("\n# Running throughput test on device: %u, lcore: %u\n", - ctx->dev_id, lcore); - /* Warm up the host CPU before starting the test */ for (i = 0; i < ctx->options->total_ops; i++) rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); - tsc_start = rte_rdtsc_precise(); + /* Get first size from range or list */ + if (ctx->options->inc_burst_size != 0) + test_burst_size = ctx->options->min_burst_size; + else + test_burst_size = ctx->options->burst_size_list[0]; + + while (test_burst_size <= ctx->options->max_burst_size) { + uint64_t ops_enqd = 0, ops_enqd_total = 0, ops_enqd_failed = 0; + uint64_t ops_deqd = 0, ops_deqd_total = 0, ops_deqd_failed = 0; + + uint64_t i, m_idx = 0, tsc_start, tsc_end, tsc_duration; + + uint16_t ops_unused = 0; - while (ops_enqd_total < ctx->options->total_ops) { + tsc_start = rte_rdtsc_precise(); - uint16_t burst_size = ((ops_enqd_total + ctx->options->burst_sz) - <= ctx->options->total_ops) ? - ctx->options->burst_sz : - ctx->options->total_ops - - ops_enqd_total; + while (ops_enqd_total < ctx->options->total_ops) { - uint16_t ops_needed = burst_size - ops_unused; + uint16_t burst_size = ((ops_enqd_total + test_burst_size + <= ctx->options->total_ops) ? + test_burst_size : + ctx->options->total_ops - + ops_enqd_total); - /* Allocate crypto ops from pool */ - if (ops_needed != rte_crypto_op_bulk_alloc( - ctx->crypto_op_pool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC, - ops, ops_needed)) - return -1; + uint16_t ops_needed = burst_size - ops_unused; - /* Setup crypto op, attach mbuf etc */ - (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx], - &ctx->mbufs_out[m_idx], - ops_needed, ctx->sess, ctx->options, - ctx->test_vector); + /* Allocate crypto ops from pool */ + if (ops_needed != rte_crypto_op_bulk_alloc( + ctx->crypto_op_pool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC, + ops, ops_needed)) + return -1; + + /* Setup crypto op, attach mbuf etc */ + (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx], + &ctx->mbufs_out[m_idx], + ops_needed, ctx->sess, ctx->options, + ctx->test_vector); #ifdef CPERF_LINEARIZATION_ENABLE - if (linearize) { - /* PMD doesn't support scatter-gather and source buffer - * is segmented. - * We need to linearize it before enqueuing. - */ - for (i = 0; i < burst_size; i++) - rte_pktmbuf_linearize(ops[i]->sym->m_src); - } + if (linearize) { + /* PMD doesn't support scatter-gather and source buffer + * is segmented. + * We need to linearize it before enqueuing. + */ + for (i = 0; i < burst_size; i++) + rte_pktmbuf_linearize(ops[i]->sym->m_src); + } #endif /* CPERF_LINEARIZATION_ENABLE */ - /* Enqueue burst of ops on crypto device */ - ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, - ops, burst_size); - if (ops_enqd < burst_size) - ops_enqd_failed++; - - /** - * Calculate number of ops not enqueued (mainly for hw - * accelerators whose ingress queue can fill up). - */ - ops_unused = burst_size - ops_enqd; - ops_enqd_total += ops_enqd; - - - /* Dequeue processed burst of ops from crypto device */ - ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); - - if (likely(ops_deqd)) { - /* free crypto ops so they can be reused. We don't free - * the mbufs here as we don't want to reuse them as - * the crypto operation will change the data and cause - * failures. - */ - for (i = 0; i < ops_deqd; i++) - rte_crypto_op_free(ops_processed[i]); + /* Enqueue burst of ops on crypto device */ + ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, + ops, burst_size); + if (ops_enqd < burst_size) + ops_enqd_failed++; - ops_deqd_total += ops_deqd; - } else { /** - * Count dequeue polls which didn't return any - * processed operations. This statistic is mainly - * relevant to hw accelerators. + * Calculate number of ops not enqueued (mainly for hw + * accelerators whose ingress queue can fill up). */ - ops_deqd_failed++; - } + ops_unused = burst_size - ops_enqd; + ops_enqd_total += ops_enqd; + + + /* Dequeue processed burst of ops from crypto device */ + ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, + ops_processed, test_burst_size); + + if (likely(ops_deqd)) { + /* free crypto ops so they can be reused. We don't free + * the mbufs here as we don't want to reuse them as + * the crypto operation will change the data and cause + * failures. + */ + for (i = 0; i < ops_deqd; i++) + rte_crypto_op_free(ops_processed[i]); + + ops_deqd_total += ops_deqd; + } else { + /** + * Count dequeue polls which didn't return any + * processed operations. This statistic is mainly + * relevant to hw accelerators. + */ + ops_deqd_failed++; + } - m_idx += ops_needed; - m_idx = m_idx + ctx->options->burst_sz > ctx->options->pool_sz ? - 0 : m_idx; - } + m_idx += ops_needed; + m_idx = m_idx + test_burst_size > ctx->options->pool_sz ? + 0 : m_idx; + } - /* Dequeue any operations still in the crypto device */ + /* Dequeue any operations still in the crypto device */ - while (ops_deqd_total < ctx->options->total_ops) { - /* Sending 0 length burst to flush sw crypto device */ - rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); + while (ops_deqd_total < ctx->options->total_ops) { + /* Sending 0 length burst to flush sw crypto device */ + rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); - /* dequeue burst */ - ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); - if (ops_deqd == 0) - ops_deqd_failed++; - else { - for (i = 0; i < ops_deqd; i++) - rte_crypto_op_free(ops_processed[i]); + /* dequeue burst */ + ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, + ops_processed, test_burst_size); + if (ops_deqd == 0) + ops_deqd_failed++; + else { + for (i = 0; i < ops_deqd; i++) + rte_crypto_op_free(ops_processed[i]); - ops_deqd_total += ops_deqd; + ops_deqd_total += ops_deqd; + } } - } - - tsc_end = rte_rdtsc_precise(); - tsc_duration = (tsc_end - tsc_start); - /* Calculate average operations processed per second */ - ctx->results.ops_per_second = ((double)ctx->options->total_ops / - tsc_duration) * rte_get_tsc_hz(); - - /* Calculate average throughput (Gbps) in bits per second */ - ctx->results.throughput_gbps = ((ctx->results.ops_per_second * - ctx->options->buffer_sz * 8) / 1000000000); - - /* Calculate average cycles per byte */ - ctx->results.cycles_per_byte = ((double)tsc_duration / - ctx->options->total_ops) / ctx->options->buffer_sz; + tsc_end = rte_rdtsc_precise(); + tsc_duration = (tsc_end - tsc_start); + + /* Calculate average operations processed per second */ + double ops_per_second = ((double)ctx->options->total_ops / + tsc_duration) * rte_get_tsc_hz(); + + /* Calculate average throughput (Gbps) in bits per second */ + double throughput_gbps = ((ops_per_second * + ctx->options->test_buffer_size * 8) / 1000000000); + + /* Calculate average cycles per packet */ + double cycles_per_packet = ((double)tsc_duration / + ctx->options->total_ops) / ctx->options->test_buffer_size; + + if (!ctx->options->csv) { + if (!only_once) + printf("%12s%12s%12s%12s%12s%12s%12s%12s%12s%12s\n\n", + "lcore id", "Buf Size", "Burst Size", + "Enqueued", "Dequeued", "Failed Enq", + "Failed Deq", "MOps", "Gbps", + "Cycles/Buf"); + only_once = 1; + + printf("%12u%12u%12u%12"PRIu64"%12"PRIu64"%12"PRIu64 + "%12"PRIu64"%12.4f%12.4f%12.2f\n", + ctx->lcore_id, + ctx->options->test_buffer_size, + test_burst_size, + ops_enqd_total, + ops_deqd_total, + ops_enqd_failed, + ops_deqd_failed, + ops_per_second/1000000, + throughput_gbps, + cycles_per_packet); + } else { + if (!only_once) + printf("# lcore id, Buffer Size(B)," + "Burst Size,Enqueued,Dequeued,Failed Enq," + "Failed Deq,Ops(Millions),Throughput(Gbps)," + "Cycles/Buf\n\n"); + only_once = 1; + + printf("%10u;%10u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";" + "%.f3;%.f3;%.f3\n", + ctx->lcore_id, + ctx->options->test_buffer_size, + test_burst_size, + ops_enqd_total, + ops_deqd_total, + ops_enqd_failed, + ops_deqd_failed, + ops_per_second/1000000, + throughput_gbps, + cycles_per_packet); + } - ctx->results.ops_enqueued = ops_enqd_total; - ctx->results.ops_dequeued = ops_deqd_total; + /* Get next size from range or list */ + if (ctx->options->inc_burst_size != 0) + test_burst_size += ctx->options->inc_burst_size; + else { + if (++burst_size_idx == ctx->options->burst_size_count) + break; + test_burst_size = ctx->options->burst_size_list[burst_size_idx]; + } - ctx->results.ops_enqueued_failed = ops_enqd_failed; - ctx->results.ops_dequeued_failed = ops_deqd_failed; + } return 0; } @@ -458,50 +497,9 @@ void cperf_throughput_test_destructor(void *arg) { struct cperf_throughput_ctx *ctx = arg; - struct cperf_throughput_results *results = &ctx->results; - static int only_once; if (ctx == NULL) return; - if (!ctx->options->csv) { - printf("\n# Device %d on lcore %u\n", - ctx->dev_id, ctx->lcore_id); - printf("# Buffer Size(B)\t Enqueued\t Dequeued\tFailed Enq" - "\tFailed Deq\tOps(Millions)\tThroughput(Gbps)" - "\tCycles Per Byte\n"); - - printf("\n%16u\t%10"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" - "%10"PRIu64"\t%16.4f\t%16.4f\t%15.2f\n", - ctx->options->buffer_sz, - results->ops_enqueued, - results->ops_dequeued, - results->ops_enqueued_failed, - results->ops_dequeued_failed, - results->ops_per_second/1000000, - results->throughput_gbps, - results->cycles_per_byte); - } else { - if (!only_once) - printf("\n# CPU lcore id, Burst Size(B), " - "Buffer Size(B),Enqueued,Dequeued,Failed Enq," - "Failed Deq,Ops(Millions),Throughput(Gbps)," - "Cycles Per Byte\n"); - only_once = 1; - - printf("%u;%u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";" - "%.f3;%.f3;%.f3\n", - ctx->lcore_id, - ctx->options->burst_sz, - ctx->options->buffer_sz, - results->ops_enqueued, - results->ops_dequeued, - results->ops_enqueued_failed, - results->ops_dequeued_failed, - results->ops_per_second/1000000, - results->throughput_gbps, - results->cycles_per_byte); - } - cperf_throughput_test_free(ctx, ctx->options->pool_sz); } diff --git a/app/test-crypto-perf/cperf_test_vector_parsing.c b/app/test-crypto-perf/cperf_test_vector_parsing.c index d1c01d2..f384e3d 100644 --- a/app/test-crypto-perf/cperf_test_vector_parsing.c +++ b/app/test-crypto-perf/cperf_test_vector_parsing.c @@ -264,12 +264,12 @@ parse_entry(char *entry, struct cperf_test_vector *vector, if (tc_found) vector->plaintext.length = data_length; else { - if (opts->buffer_sz > data_length) { + if (opts->max_buffer_size > data_length) { printf("Global plaintext shorter than " "buffer_sz\n"); return -1; } - vector->plaintext.length = opts->buffer_sz; + vector->plaintext.length = opts->max_buffer_size; } } else if (strstr(key_token, "cipher_key")) { @@ -321,12 +321,12 @@ parse_entry(char *entry, struct cperf_test_vector *vector, if (tc_found) vector->ciphertext.length = data_length; else { - if (opts->buffer_sz > data_length) { + if (opts->max_buffer_size > data_length) { printf("Global ciphertext shorter than " "buffer_sz\n"); return -1; } - vector->ciphertext.length = opts->buffer_sz; + vector->ciphertext.length = opts->max_buffer_size; } } else if (strstr(key_token, "aad")) { @@ -498,10 +498,10 @@ cperf_test_vector_get_from_file(struct cperf_options *opts) /* other values not included in the file */ test_vector->data.cipher_offset = 0; - test_vector->data.cipher_length = opts->buffer_sz; + test_vector->data.cipher_length = opts->max_buffer_size; test_vector->data.auth_offset = 0; - test_vector->data.auth_length = opts->buffer_sz; + test_vector->data.auth_length = opts->max_buffer_size; return test_vector; } diff --git a/app/test-crypto-perf/cperf_test_vectors.c b/app/test-crypto-perf/cperf_test_vectors.c index 6307f25..d421432 100644 --- a/app/test-crypto-perf/cperf_test_vectors.c +++ b/app/test-crypto-perf/cperf_test_vectors.c @@ -399,7 +399,7 @@ cperf_test_vector_get_dummy(struct cperf_options *options) return t_vec; t_vec->plaintext.data = plaintext; - t_vec->plaintext.length = options->buffer_sz; + t_vec->plaintext.length = options->max_buffer_size; if (options->op_type == CPERF_CIPHER_ONLY || options->op_type == CPERF_CIPHER_THEN_AUTH || @@ -422,11 +422,11 @@ cperf_test_vector_get_dummy(struct cperf_options *options) } memcpy(t_vec->iv.data, iv, options->cipher_iv_sz); } - t_vec->ciphertext.length = options->buffer_sz; + t_vec->ciphertext.length = options->max_buffer_size; t_vec->iv.phys_addr = rte_malloc_virt2phy(t_vec->iv.data); t_vec->iv.length = options->cipher_iv_sz; t_vec->data.cipher_offset = 0; - t_vec->data.cipher_length = options->buffer_sz; + t_vec->data.cipher_length = options->max_buffer_size; } if (options->op_type == CPERF_AUTH_ONLY || @@ -493,7 +493,7 @@ cperf_test_vector_get_dummy(struct cperf_options *options) t_vec->digest.length = options->auth_digest_sz; memcpy(t_vec->digest.data, digest, options->auth_digest_sz); t_vec->data.auth_offset = 0; - t_vec->data.auth_length = options->buffer_sz; + t_vec->data.auth_length = options->max_buffer_size; } return t_vec; diff --git a/app/test-crypto-perf/cperf_test_verify.c b/app/test-crypto-perf/cperf_test_verify.c index be157e6..3245704 100644 --- a/app/test-crypto-perf/cperf_test_verify.c +++ b/app/test-crypto-perf/cperf_test_verify.c @@ -38,16 +38,6 @@ #include "cperf_test_verify.h" #include "cperf_ops.h" -struct cperf_verify_results { - uint64_t ops_enqueued; - uint64_t ops_dequeued; - - uint64_t ops_enqueued_failed; - uint64_t ops_dequeued_failed; - - uint64_t ops_failed; -}; - struct cperf_verify_ctx { uint8_t dev_id; uint16_t qp_id; @@ -66,8 +56,6 @@ struct cperf_verify_ctx { const struct cperf_options *options; const struct cperf_test_vector *test_vector; - struct cperf_verify_results results; - }; struct cperf_op_result { @@ -119,8 +107,8 @@ cperf_mbuf_create(struct rte_mempool *mempool, const struct cperf_test_vector *test_vector) { struct rte_mbuf *mbuf; - uint32_t segment_sz = options->buffer_sz / segments_nb; - uint32_t last_sz = options->buffer_sz % segments_nb; + uint32_t segment_sz = options->max_buffer_size / segments_nb; + uint32_t last_sz = options->max_buffer_size % segments_nb; uint8_t *mbuf_data; uint8_t *test_data = (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? @@ -222,8 +210,8 @@ cperf_verify_test_constructor(uint8_t dev_id, uint16_t qp_id, options->pool_sz * options->segments_nb, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - (options->buffer_sz / options->segments_nb) + - (options->buffer_sz % options->segments_nb) + + (options->max_buffer_size / options->segments_nb) + + (options->max_buffer_size % options->segments_nb) + options->auth_digest_sz), rte_socket_id()); @@ -231,9 +219,6 @@ cperf_verify_test_constructor(uint8_t dev_id, uint16_t qp_id, goto err; /* Generate mbufs_in with plaintext populated for test */ - if (ctx->options->pool_sz % ctx->options->burst_sz) - goto err; - ctx->mbufs_in = rte_malloc(NULL, (sizeof(struct rte_mbuf *) * ctx->options->pool_sz), 0); @@ -254,7 +239,7 @@ cperf_verify_test_constructor(uint8_t dev_id, uint16_t qp_id, pool_name, options->pool_sz, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - options->buffer_sz + + options->max_buffer_size + options->auth_digest_sz), rte_socket_id()); @@ -401,12 +386,15 @@ cperf_verify_test_runner(void *test_ctx) uint64_t ops_enqd = 0, ops_enqd_total = 0, ops_enqd_failed = 0; uint64_t ops_deqd = 0, ops_deqd_total = 0, ops_deqd_failed = 0; + uint64_t ops_failed = 0; + + static int only_once; uint64_t i, m_idx = 0; uint16_t ops_unused = 0; - struct rte_crypto_op *ops[ctx->options->burst_sz]; - struct rte_crypto_op *ops_processed[ctx->options->burst_sz]; + struct rte_crypto_op *ops[ctx->options->max_burst_size]; + struct rte_crypto_op *ops_processed[ctx->options->max_burst_size]; uint32_t lcore = rte_lcore_id(); @@ -431,9 +419,9 @@ cperf_verify_test_runner(void *test_ctx) while (ops_enqd_total < ctx->options->total_ops) { - uint16_t burst_size = ((ops_enqd_total + ctx->options->burst_sz) + uint16_t burst_size = ((ops_enqd_total + ctx->options->max_burst_size) <= ctx->options->total_ops) ? - ctx->options->burst_sz : + ctx->options->max_burst_size : ctx->options->total_ops - ops_enqd_total; @@ -479,10 +467,10 @@ cperf_verify_test_runner(void *test_ctx) /* Dequeue processed burst of ops from crypto device */ ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); + ops_processed, ctx->options->max_burst_size); m_idx += ops_needed; - if (m_idx + ctx->options->burst_sz > ctx->options->pool_sz) + if (m_idx + ctx->options->max_burst_size > ctx->options->pool_sz) m_idx = 0; if (ops_deqd == 0) { @@ -498,7 +486,7 @@ cperf_verify_test_runner(void *test_ctx) for (i = 0; i < ops_deqd; i++) { if (cperf_verify_op(ops_processed[i], ctx->options, ctx->test_vector)) - ctx->results.ops_failed++; + ops_failed++; /* free crypto ops so they can be reused. We don't free * the mbufs here as we don't want to reuse them as * the crypto operation will change the data and cause @@ -517,7 +505,7 @@ cperf_verify_test_runner(void *test_ctx) /* dequeue burst */ ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); + ops_processed, ctx->options->max_burst_size); if (ops_deqd == 0) { ops_deqd_failed++; continue; @@ -526,7 +514,7 @@ cperf_verify_test_runner(void *test_ctx) for (i = 0; i < ops_deqd; i++) { if (cperf_verify_op(ops_processed[i], ctx->options, ctx->test_vector)) - ctx->results.ops_failed++; + ops_failed++; /* free crypto ops so they can be reused. We don't free * the mbufs here as we don't want to reuse them as * the crypto operation will change the data and cause @@ -537,59 +525,52 @@ cperf_verify_test_runner(void *test_ctx) } } - ctx->results.ops_enqueued = ops_enqd_total; - ctx->results.ops_dequeued = ops_deqd_total; - - ctx->results.ops_enqueued_failed = ops_enqd_failed; - ctx->results.ops_dequeued_failed = ops_deqd_failed; - - return 0; -} - - - -void -cperf_verify_test_destructor(void *arg) -{ - struct cperf_verify_ctx *ctx = arg; - struct cperf_verify_results *results = &ctx->results; - static int only_once; - - if (ctx == NULL) - return; - if (!ctx->options->csv) { printf("\n# Device %d on lcore %u\n", ctx->dev_id, ctx->lcore_id); - printf("# Buffer Size(B)\t Enqueued\t Dequeued\tFailed Enq" + printf("# Buffer Size(B)\t Burst Size\t Enqueued\t Dequeued\tFailed Enq" "\tFailed Deq\tEmpty Polls\n"); - printf("\n%16u\t%10"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" + printf("\n%16u\t%16u\t%10"PRIu64"\t%10"PRIu64"\t%10"PRIu64"\t" "%10"PRIu64"\t%10"PRIu64"\n", - ctx->options->buffer_sz, - results->ops_enqueued, - results->ops_dequeued, - results->ops_enqueued_failed, - results->ops_dequeued_failed, - results->ops_failed); + ctx->options->max_buffer_size, + ctx->options->max_burst_size, + ops_enqd_total, + ops_deqd_total, + ops_enqd_failed, + ops_deqd_failed, + ops_failed); } else { if (!only_once) - printf("\n# CPU lcore id, Burst Size(B), " - "Buffer Size(B),Enqueued,Dequeued,Failed Enq," + printf("\n# CPU lcore id, Buffer Size(B), " + "Burst Size(B), Enqueued,Dequeued,Failed Enq," "Failed Deq,Empty Polls\n"); only_once = 1; printf("%u;%u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";" "%"PRIu64"\n", ctx->lcore_id, - ctx->options->burst_sz, - ctx->options->buffer_sz, - results->ops_enqueued, - results->ops_dequeued, - results->ops_enqueued_failed, - results->ops_dequeued_failed, - results->ops_failed); + ctx->options->max_buffer_size, + ctx->options->max_burst_size, + ops_enqd_total, + ops_deqd_total, + ops_enqd_failed, + ops_deqd_failed, + ops_failed); } + return 0; +} + + + +void +cperf_verify_test_destructor(void *arg) +{ + struct cperf_verify_ctx *ctx = arg; + + if (ctx == NULL) + return; + cperf_verify_test_free(ctx, ctx->options->pool_sz); } diff --git a/app/test-crypto-perf/cperf_verify_parser.c b/app/test-crypto-perf/cperf_verify_parser.c index 5640d84..422f92d 100644 --- a/app/test-crypto-perf/cperf_verify_parser.c +++ b/app/test-crypto-perf/cperf_verify_parser.c @@ -305,10 +305,10 @@ cperf_test_vector_get_from_file(struct cperf_options *opts) /* other values not included in the file */ test_vector->data.cipher_offset = 0; - test_vector->data.cipher_length = opts->buffer_sz; + test_vector->data.cipher_length = opts->max_buffer_size; test_vector->data.auth_offset = 0; - test_vector->data.auth_length = opts->buffer_sz; + test_vector->data.auth_length = opts->max_buffer_size; return test_vector; } diff --git a/app/test-crypto-perf/main.c b/app/test-crypto-perf/main.c index da37972..94230d9 100644 --- a/app/test-crypto-perf/main.c +++ b/app/test-crypto-perf/main.c @@ -179,11 +179,11 @@ cperf_check_test_vector(struct cperf_options *opts, } else if (opts->cipher_algo != RTE_CRYPTO_CIPHER_NULL) { if (test_vec->plaintext.data == NULL) return -1; - if (test_vec->plaintext.length != opts->buffer_sz) + if (test_vec->plaintext.length != opts->max_buffer_size) return -1; if (test_vec->ciphertext.data == NULL) return -1; - if (test_vec->ciphertext.length != opts->buffer_sz) + if (test_vec->ciphertext.length != opts->max_buffer_size) return -1; if (test_vec->iv.data == NULL) return -1; @@ -198,7 +198,7 @@ cperf_check_test_vector(struct cperf_options *opts, if (opts->auth_algo != RTE_CRYPTO_AUTH_NULL) { if (test_vec->plaintext.data == NULL) return -1; - if (test_vec->plaintext.length != opts->buffer_sz) + if (test_vec->plaintext.length != opts->max_buffer_size) return -1; if (test_vec->auth_key.data == NULL) return -1; @@ -215,16 +215,16 @@ cperf_check_test_vector(struct cperf_options *opts, if (opts->cipher_algo == RTE_CRYPTO_CIPHER_NULL) { if (test_vec->plaintext.data == NULL) return -1; - if (test_vec->plaintext.length != opts->buffer_sz) + if (test_vec->plaintext.length != opts->max_buffer_size) return -1; } else if (opts->cipher_algo != RTE_CRYPTO_CIPHER_NULL) { if (test_vec->plaintext.data == NULL) return -1; - if (test_vec->plaintext.length != opts->buffer_sz) + if (test_vec->plaintext.length != opts->max_buffer_size) return -1; if (test_vec->ciphertext.data == NULL) return -1; - if (test_vec->ciphertext.length != opts->buffer_sz) + if (test_vec->ciphertext.length != opts->max_buffer_size) return -1; if (test_vec->iv.data == NULL) return -1; @@ -248,7 +248,7 @@ cperf_check_test_vector(struct cperf_options *opts, } else if (opts->op_type == CPERF_AEAD) { if (test_vec->plaintext.data == NULL) return -1; - if (test_vec->plaintext.length != opts->buffer_sz) + if (test_vec->plaintext.length != opts->max_buffer_size) return -1; if (test_vec->aad.data == NULL) return -1; @@ -275,6 +275,8 @@ main(int argc, char **argv) uint8_t cdev_id, i; uint8_t enabled_cdevs[RTE_CRYPTO_MAX_DEVS] = { 0 }; + uint8_t buffer_size_idx = 0; + int ret; uint32_t lcore_id; @@ -370,21 +372,37 @@ main(int argc, char **argv) i++; } - i = 0; - RTE_LCORE_FOREACH_SLAVE(lcore_id) { + /* Get first size from range or list */ + if (opts.inc_buffer_size != 0) + opts.test_buffer_size = opts.min_buffer_size; + else + opts.test_buffer_size = opts.buffer_size_list[0]; - if (i == nb_cryptodevs) - break; + while (opts.test_buffer_size <= opts.max_buffer_size) { + i = 0; + RTE_LCORE_FOREACH_SLAVE(lcore_id) { - cdev_id = enabled_cdevs[i]; + if (i == nb_cryptodevs) + break; - rte_eal_remote_launch(cperf_testmap[opts.test].runner, + cdev_id = enabled_cdevs[i]; + + rte_eal_remote_launch(cperf_testmap[opts.test].runner, ctx[cdev_id], lcore_id); - i++; + i++; + } + rte_eal_mp_wait_lcore(); + + /* Get next size from range or list */ + if (opts.inc_buffer_size != 0) + opts.test_buffer_size += opts.inc_buffer_size; + else { + if (++buffer_size_idx == opts.buffer_size_count) + break; + opts.test_buffer_size = opts.buffer_size_list[buffer_size_idx]; + } } - rte_eal_mp_wait_lcore(); - i = 0; RTE_LCORE_FOREACH_SLAVE(lcore_id) { diff --git a/doc/guides/tools/cryptoperf.rst b/doc/guides/tools/cryptoperf.rst index 6328dab..1389db6 100644 --- a/doc/guides/tools/cryptoperf.rst +++ b/doc/guides/tools/cryptoperf.rst @@ -150,10 +150,25 @@ The following are the appication command-line options: Set the number of packets per burst. + This can be set as: + * Single value (i.e. ``--burst-sz 16``) + * Range of values, using the following structure ``min:inc:max``, + where ``min`` is minimum size, ``inc`` is the increment size and ``max`` + is the maximum size (i.e. ``--burst-sz 16:2:32``) + * List of values, up to 32 values, separated in commas (i.e. ``--burst-sz 16,24,32``) + * ``--buffer-sz `` Set the size of single packet (plaintext or ciphertext in it). + This can be set as: + * Single value (i.e. ``--buffer-sz 16``) + * Range of values, using the following structure ``min:inc:max``, + where ``min`` is minimum size, ``inc`` is the increment size and ``max`` + is the maximum size (i.e. ``--buffer-sz 16:2:32``) + * List of values, up to 32 values, separated in commas (i.e. ``--buffer-sz 32,64,128``) + + * ``--segments-nb `` Set the number of segments per packet. -- 2.7.4