From df52cb3b6e132603b00e55cbaf8071811bd8b20e Mon Sep 17 00:00:00 2001 From: Sergio Gonzalez Monroy Date: Mon, 27 Mar 2017 12:26:01 +0100 Subject: [PATCH] app/crypto-perf: move verify as single test type In order to simplify throughput and latency tests, verify option has been removed from these and moved as a separate test. Signed-off-by: Sergio Gonzalez Monroy Acked-by: Pablo de Lara --- app/test-crypto-perf/Makefile | 1 + app/test-crypto-perf/cperf_ops.h | 5 - app/test-crypto-perf/cperf_options.h | 5 +- app/test-crypto-perf/cperf_options_parsing.c | 22 +- app/test-crypto-perf/cperf_test_latency.c | 117 ---- app/test-crypto-perf/cperf_test_throughput.c | 160 ----- app/test-crypto-perf/cperf_test_verify.c | 593 +++++++++++++++++++ app/test-crypto-perf/cperf_test_verify.h | 58 ++ app/test-crypto-perf/main.c | 9 +- doc/guides/tools/cryptoperf.rst | 12 +- 10 files changed, 673 insertions(+), 309 deletions(-) create mode 100644 app/test-crypto-perf/cperf_test_verify.c create mode 100644 app/test-crypto-perf/cperf_test_verify.h diff --git a/app/test-crypto-perf/Makefile b/app/test-crypto-perf/Makefile index 5120b88b6d..e4a989fe69 100644 --- a/app/test-crypto-perf/Makefile +++ b/app/test-crypto-perf/Makefile @@ -42,6 +42,7 @@ SRCS-y += cperf_options_parsing.c SRCS-y += cperf_test_vectors.c SRCS-y += cperf_test_throughput.c SRCS-y += cperf_test_latency.c +SRCS-y += cperf_test_verify.c SRCS-y += cperf_test_vector_parsing.c include $(RTE_SDK)/mk/rte.app.mk diff --git a/app/test-crypto-perf/cperf_ops.h b/app/test-crypto-perf/cperf_ops.h index 11e2117aae..1b748daf0a 100644 --- a/app/test-crypto-perf/cperf_ops.h +++ b/app/test-crypto-perf/cperf_ops.h @@ -50,11 +50,6 @@ typedef int (*cperf_populate_ops_t)(struct rte_crypto_op **ops, const struct cperf_options *options, const struct cperf_test_vector *test_vector); - -typedef int (*cperf_verify_crypto_op_t)(struct rte_mbuf *m, - const struct cperf_options *options, - const struct cperf_test_vector *test_vector); - struct cperf_op_fns { cperf_sessions_create_t sess_create; cperf_populate_ops_t populate_ops; diff --git a/app/test-crypto-perf/cperf_options.h b/app/test-crypto-perf/cperf_options.h index c0d919fdae..573f6eac29 100644 --- a/app/test-crypto-perf/cperf_options.h +++ b/app/test-crypto-perf/cperf_options.h @@ -17,7 +17,6 @@ #define CPERF_OPTYPE ("optype") #define CPERF_SESSIONLESS ("sessionless") #define CPERF_OUT_OF_PLACE ("out-of-place") -#define CPERF_VERIFY ("verify") #define CPERF_TEST_FILE ("test-file") #define CPERF_TEST_NAME ("test-name") @@ -36,7 +35,8 @@ enum cperf_perf_test_type { CPERF_TEST_TYPE_THROUGHPUT, - CPERF_TEST_TYPE_LATENCY + CPERF_TEST_TYPE_LATENCY, + CPERF_TEST_TYPE_VERIFY }; @@ -66,7 +66,6 @@ struct cperf_options { uint32_t sessionless:1; uint32_t out_of_place:1; - uint32_t verify:1; uint32_t silent:1; uint32_t csv:1; diff --git a/app/test-crypto-perf/cperf_options_parsing.c b/app/test-crypto-perf/cperf_options_parsing.c index f93e0c17a4..4c94bde337 100644 --- a/app/test-crypto-perf/cperf_options_parsing.c +++ b/app/test-crypto-perf/cperf_options_parsing.c @@ -66,6 +66,10 @@ parse_cperf_test_type(struct cperf_options *opts, const char *arg) cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT], CPERF_TEST_TYPE_THROUGHPUT }, + { + cperf_test_type_strs[CPERF_TEST_TYPE_VERIFY], + CPERF_TEST_TYPE_VERIFY + }, { cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY], CPERF_TEST_TYPE_LATENCY @@ -261,15 +265,6 @@ parse_out_of_place(struct cperf_options *opts, return 0; } -static int -parse_verify(struct cperf_options *opts, - const char *arg __rte_unused) -{ - opts->verify = 1; - - return 0; -} - static int parse_test_file(struct cperf_options *opts, const char *arg) @@ -452,7 +447,6 @@ static struct option lgopts[] = { { CPERF_SILENT, no_argument, 0, 0 }, { CPERF_SESSIONLESS, no_argument, 0, 0 }, { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, - { CPERF_VERIFY, no_argument, 0, 0 }, { CPERF_TEST_FILE, required_argument, 0, 0 }, { CPERF_TEST_NAME, required_argument, 0, 0 }, @@ -490,7 +484,6 @@ cperf_options_default(struct cperf_options *opts) opts->op_type = CPERF_CIPHER_THEN_AUTH; opts->silent = 0; - opts->verify = 0; opts->test_file = NULL; opts->test_name = NULL; opts->sessionless = 0; @@ -525,7 +518,6 @@ cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) { CPERF_OPTYPE, parse_op_type }, { CPERF_SESSIONLESS, parse_sessionless }, { CPERF_OUT_OF_PLACE, parse_out_of_place }, - { CPERF_VERIFY, parse_verify }, { CPERF_TEST_FILE, parse_test_file }, { CPERF_TEST_NAME, parse_test_name }, { CPERF_CIPHER_ALGO, parse_cipher_algo }, @@ -583,7 +575,8 @@ cperf_options_check(struct cperf_options *options) return -EINVAL; } - if (options->verify && options->test_file == NULL) { + if (options->test == CPERF_TEST_TYPE_VERIFY && + options->test_file == NULL) { RTE_LOG(ERR, USER1, "Define path to the file with test" " vectors.\n"); return -EINVAL; @@ -602,7 +595,7 @@ cperf_options_check(struct cperf_options *options) return -EINVAL; } - if (options->verify && + if (options->test == CPERF_TEST_TYPE_VERIFY && options->total_ops > options->pool_sz) { RTE_LOG(ERR, USER1, "Total number of ops must be less than or" " equal to the pool size.\n"); @@ -669,7 +662,6 @@ cperf_options_dump(struct cperf_options *opts) printf("# cryptodev type: %s\n", opts->device_type); printf("#\n"); printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); - printf("# verify operation: %s\n", opts->verify ? "yes" : "no"); printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c index 239a8e555d..c5273b1fdd 100644 --- a/app/test-crypto-perf/cperf_test_latency.c +++ b/app/test-crypto-perf/cperf_test_latency.c @@ -80,7 +80,6 @@ struct cperf_latency_ctx { struct rte_cryptodev_sym_session *sess; cperf_populate_ops_t populate_ops; - cperf_verify_crypto_op_t verify_op_output; const struct cperf_options *options; const struct cperf_test_vector *test_vector; @@ -318,100 +317,6 @@ err: return NULL; } -static int -cperf_latency_test_verifier(struct rte_mbuf *mbuf, - const struct cperf_options *options, - const struct cperf_test_vector *vector) -{ - const struct rte_mbuf *m; - uint32_t len; - uint16_t nb_segs; - uint8_t *data; - uint32_t cipher_offset, auth_offset; - uint8_t cipher, auth; - int res = 0; - - m = mbuf; - nb_segs = m->nb_segs; - len = 0; - while (m && nb_segs != 0) { - len += m->data_len; - m = m->next; - nb_segs--; - } - - data = rte_malloc(NULL, len, 0); - if (data == NULL) - return 1; - - m = mbuf; - nb_segs = m->nb_segs; - len = 0; - while (m && nb_segs != 0) { - memcpy(data + len, rte_pktmbuf_mtod(m, uint8_t *), - m->data_len); - len += m->data_len; - m = m->next; - nb_segs--; - } - - switch (options->op_type) { - case CPERF_CIPHER_ONLY: - cipher = 1; - cipher_offset = 0; - auth = 0; - auth_offset = 0; - break; - case CPERF_CIPHER_THEN_AUTH: - cipher = 1; - cipher_offset = 0; - auth = 1; - auth_offset = vector->plaintext.length; - break; - case CPERF_AUTH_ONLY: - cipher = 0; - cipher_offset = 0; - auth = 1; - auth_offset = vector->plaintext.length; - break; - case CPERF_AUTH_THEN_CIPHER: - cipher = 1; - cipher_offset = 0; - auth = 1; - auth_offset = vector->plaintext.length; - break; - case CPERF_AEAD: - cipher = 1; - cipher_offset = vector->aad.length; - auth = 1; - auth_offset = vector->aad.length + vector->plaintext.length; - break; - } - - if (cipher == 1) { - if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) - res += memcmp(data + cipher_offset, - vector->ciphertext.data, - vector->ciphertext.length); - else - res += memcmp(data + cipher_offset, - vector->plaintext.data, - vector->plaintext.length); - } - - if (auth == 1) { - if (options->auth_op == RTE_CRYPTO_AUTH_OP_GENERATE) - res += memcmp(data + auth_offset, - vector->digest.data, - vector->digest.length); - } - - if (res != 0) - res = 1; - - return res; -} - int cperf_latency_test_runner(void *arg) { @@ -571,26 +476,6 @@ cperf_latency_test_runner(void *arg) tsc_tot += tsc_val; } - if (ctx->options->verify) { - struct rte_mbuf **mbufs; - - if (ctx->options->out_of_place == 1) - mbufs = ctx->mbufs_out; - else - mbufs = ctx->mbufs_in; - - for (i = 0; i < ctx->options->total_ops; i++) { - - if (ctx->res[i].status != RTE_CRYPTO_OP_STATUS_SUCCESS - || cperf_latency_test_verifier(mbufs[i], - ctx->options, - ctx->test_vector)) { - - ctx->results.ops_failed++; - } - } - } - ctx->results.enqd_tot = enqd_tot; ctx->results.enqd_max = enqd_max; ctx->results.enqd_min = enqd_min; @@ -665,8 +550,6 @@ cperf_latency_test_destructor(void *arg) 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# verified failed: %"PRIu64, - ctx->results.ops_failed); printf("\n# burst number: %"PRIu64, ctx->results.burst_num); printf("\n#"); diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c index 6c04697a90..92176d7119 100644 --- a/app/test-crypto-perf/cperf_test_throughput.c +++ b/app/test-crypto-perf/cperf_test_throughput.c @@ -45,8 +45,6 @@ struct cperf_throughput_results { uint64_t ops_enqueued_failed; uint64_t ops_dequeued_failed; - uint64_t ops_failed; - double ops_per_second; double throughput_gbps; double cycles_per_byte; @@ -67,7 +65,6 @@ struct cperf_throughput_ctx { struct rte_cryptodev_sym_session *sess; cperf_populate_ops_t populate_ops; - cperf_verify_crypto_op_t verify_op_output; const struct cperf_options *options; const struct cperf_test_vector *test_vector; @@ -75,10 +72,6 @@ struct cperf_throughput_ctx { }; -struct cperf_op_result { - enum rte_crypto_op_status status; -}; - static void cperf_throughput_test_free(struct cperf_throughput_ctx *ctx, uint32_t mbuf_nb) { @@ -297,112 +290,10 @@ err: return NULL; } -static int -cperf_throughput_test_verifier(struct rte_mbuf *mbuf, - const struct cperf_options *options, - const struct cperf_test_vector *vector) -{ - const struct rte_mbuf *m; - uint32_t len; - uint16_t nb_segs; - uint8_t *data; - uint32_t cipher_offset, auth_offset; - uint8_t cipher, auth; - int res = 0; - - m = mbuf; - nb_segs = m->nb_segs; - len = 0; - while (m && nb_segs != 0) { - len += m->data_len; - m = m->next; - nb_segs--; - } - - data = rte_malloc(NULL, len, 0); - if (data == NULL) - return 1; - - m = mbuf; - nb_segs = m->nb_segs; - len = 0; - while (m && nb_segs != 0) { - memcpy(data + len, rte_pktmbuf_mtod(m, uint8_t *), - m->data_len); - len += m->data_len; - m = m->next; - nb_segs--; - } - - switch (options->op_type) { - case CPERF_CIPHER_ONLY: - cipher = 1; - cipher_offset = 0; - auth = 0; - auth_offset = 0; - break; - case CPERF_CIPHER_THEN_AUTH: - cipher = 1; - cipher_offset = 0; - auth = 1; - auth_offset = vector->plaintext.length; - break; - case CPERF_AUTH_ONLY: - cipher = 0; - cipher_offset = 0; - auth = 1; - auth_offset = vector->plaintext.length; - break; - case CPERF_AUTH_THEN_CIPHER: - cipher = 1; - cipher_offset = 0; - auth = 1; - auth_offset = vector->plaintext.length; - break; - case CPERF_AEAD: - cipher = 1; - cipher_offset = vector->aad.length; - auth = 1; - auth_offset = vector->aad.length + vector->plaintext.length; - break; - } - - if (cipher == 1) { - if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) - res += memcmp(data + cipher_offset, - vector->ciphertext.data, - vector->ciphertext.length); - else - res += memcmp(data + cipher_offset, - vector->plaintext.data, - vector->plaintext.length); - } - - if (auth == 1) { - if (options->auth_op == RTE_CRYPTO_AUTH_OP_GENERATE) - res += memcmp(data + auth_offset, - vector->digest.data, - vector->digest.length); - } - - if (res != 0) - res = 1; - - return res; -} - int cperf_throughput_test_runner(void *test_ctx) { struct cperf_throughput_ctx *ctx = test_ctx; - struct cperf_op_result *res, *pres; - - if (ctx->options->verify) { - res = rte_malloc(NULL, sizeof(struct cperf_op_result) * - ctx->options->total_ops, 0); - if (res == NULL) - return 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; @@ -410,7 +301,6 @@ cperf_throughput_test_runner(void *test_ctx) uint64_t i, m_idx = 0, tsc_start, tsc_end, tsc_duration; uint16_t ops_unused = 0; - uint64_t idx = 0; struct rte_crypto_op *ops[ctx->options->burst_sz]; struct rte_crypto_op *ops_processed[ctx->options->burst_sz]; @@ -465,13 +355,6 @@ cperf_throughput_test_runner(void *test_ctx) ops_needed, ctx->sess, ctx->options, ctx->test_vector); - if (ctx->options->verify) { - for (i = 0; i < ops_needed; i++) { - ops[i]->opaque_data = (void *)&res[idx]; - idx++; - } - } - #ifdef CPERF_LINEARIZATION_ENABLE if (linearize) { /* PMD doesn't support scatter-gather and source buffer @@ -502,16 +385,6 @@ cperf_throughput_test_runner(void *test_ctx) ops_processed, ctx->options->burst_sz); if (likely(ops_deqd)) { - - if (ctx->options->verify) { - void *opq; - for (i = 0; i < ops_deqd; i++) { - opq = (ops_processed[i]->opaque_data); - pres = (struct cperf_op_result *)opq; - pres->status = ops_processed[i]->status; - } - } - /* 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 @@ -547,15 +420,6 @@ cperf_throughput_test_runner(void *test_ctx) if (ops_deqd == 0) ops_deqd_failed++; else { - if (ctx->options->verify) { - void *opq; - for (i = 0; i < ops_deqd; i++) { - opq = (ops_processed[i]->opaque_data); - pres = (struct cperf_op_result *)opq; - pres->status = ops_processed[i]->status; - } - } - for (i = 0; i < ops_deqd; i++) rte_crypto_op_free(ops_processed[i]); @@ -566,28 +430,6 @@ cperf_throughput_test_runner(void *test_ctx) tsc_end = rte_rdtsc_precise(); tsc_duration = (tsc_end - tsc_start); - if (ctx->options->verify) { - struct rte_mbuf **mbufs; - - if (ctx->options->out_of_place == 1) - mbufs = ctx->mbufs_out; - else - mbufs = ctx->mbufs_in; - - for (i = 0; i < ctx->options->total_ops; i++) { - - if (res[i].status != RTE_CRYPTO_OP_STATUS_SUCCESS || - cperf_throughput_test_verifier( - mbufs[i], ctx->options, - ctx->test_vector)) { - - ctx->results.ops_failed++; - } - } - - rte_free(res); - } - /* Calculate average operations processed per second */ ctx->results.ops_per_second = ((double)ctx->options->total_ops / tsc_duration) * rte_get_tsc_hz(); @@ -596,7 +438,6 @@ cperf_throughput_test_runner(void *test_ctx) 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; @@ -611,7 +452,6 @@ cperf_throughput_test_runner(void *test_ctx) } - void cperf_throughput_test_destructor(void *arg) { diff --git a/app/test-crypto-perf/cperf_test_verify.c b/app/test-crypto-perf/cperf_test_verify.c new file mode 100644 index 0000000000..27fbd6cfa6 --- /dev/null +++ b/app/test-crypto-perf/cperf_test_verify.c @@ -0,0 +1,593 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2016-2017 Intel Corporation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#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; + uint8_t lcore_id; + + struct rte_mempool *pkt_mbuf_pool_in; + struct rte_mempool *pkt_mbuf_pool_out; + struct rte_mbuf **mbufs_in; + struct rte_mbuf **mbufs_out; + + struct rte_mempool *crypto_op_pool; + + struct rte_cryptodev_sym_session *sess; + + cperf_populate_ops_t populate_ops; + + const struct cperf_options *options; + const struct cperf_test_vector *test_vector; + struct cperf_verify_results results; + +}; + +struct cperf_op_result { + enum rte_crypto_op_status status; +}; + +static void +cperf_verify_test_free(struct cperf_verify_ctx *ctx, uint32_t mbuf_nb) +{ + uint32_t i; + + if (ctx) { + if (ctx->sess) + rte_cryptodev_sym_session_free(ctx->dev_id, ctx->sess); + + if (ctx->mbufs_in) { + for (i = 0; i < mbuf_nb; i++) + rte_pktmbuf_free(ctx->mbufs_in[i]); + + rte_free(ctx->mbufs_in); + } + + if (ctx->mbufs_out) { + for (i = 0; i < mbuf_nb; i++) { + if (ctx->mbufs_out[i] != NULL) + rte_pktmbuf_free(ctx->mbufs_out[i]); + } + + rte_free(ctx->mbufs_out); + } + + if (ctx->pkt_mbuf_pool_in) + rte_mempool_free(ctx->pkt_mbuf_pool_in); + + if (ctx->pkt_mbuf_pool_out) + rte_mempool_free(ctx->pkt_mbuf_pool_out); + + if (ctx->crypto_op_pool) + rte_mempool_free(ctx->crypto_op_pool); + + rte_free(ctx); + } +} + +static struct rte_mbuf * +cperf_mbuf_create(struct rte_mempool *mempool, + uint32_t segments_nb, + const struct cperf_options *options, + 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; + uint8_t *mbuf_data; + uint8_t *test_data = + (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? + test_vector->plaintext.data : + test_vector->ciphertext.data; + + mbuf = rte_pktmbuf_alloc(mempool); + if (mbuf == NULL) + goto error; + + mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, segment_sz); + if (mbuf_data == NULL) + goto error; + + memcpy(mbuf_data, test_data, segment_sz); + test_data += segment_sz; + segments_nb--; + + while (segments_nb) { + struct rte_mbuf *m; + + m = rte_pktmbuf_alloc(mempool); + if (m == NULL) + goto error; + + rte_pktmbuf_chain(mbuf, m); + + mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, segment_sz); + if (mbuf_data == NULL) + goto error; + + memcpy(mbuf_data, test_data, segment_sz); + test_data += segment_sz; + segments_nb--; + } + + if (last_sz) { + mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, last_sz); + if (mbuf_data == NULL) + goto error; + + memcpy(mbuf_data, test_data, last_sz); + } + + mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, + options->auth_digest_sz); + if (mbuf_data == NULL) + goto error; + + if (options->op_type == CPERF_AEAD) { + uint8_t *aead = (uint8_t *)rte_pktmbuf_prepend(mbuf, + RTE_ALIGN_CEIL(options->auth_aad_sz, 16)); + + if (aead == NULL) + goto error; + + memcpy(aead, test_vector->aad.data, test_vector->aad.length); + } + + return mbuf; +error: + if (mbuf != NULL) + rte_pktmbuf_free(mbuf); + + return NULL; +} + +void * +cperf_verify_test_constructor(uint8_t dev_id, uint16_t qp_id, + const struct cperf_options *options, + const struct cperf_test_vector *test_vector, + const struct cperf_op_fns *op_fns) +{ + struct cperf_verify_ctx *ctx = NULL; + unsigned int mbuf_idx = 0; + char pool_name[32] = ""; + + ctx = rte_malloc(NULL, sizeof(struct cperf_verify_ctx), 0); + if (ctx == NULL) + goto err; + + ctx->dev_id = dev_id; + ctx->qp_id = qp_id; + + ctx->populate_ops = op_fns->populate_ops; + ctx->options = options; + ctx->test_vector = test_vector; + + ctx->sess = op_fns->sess_create(dev_id, options, test_vector); + if (ctx->sess == NULL) + goto err; + + snprintf(pool_name, sizeof(pool_name), "cperf_pool_in_cdev_%d", + dev_id); + + ctx->pkt_mbuf_pool_in = rte_pktmbuf_pool_create(pool_name, + 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->auth_digest_sz), + rte_socket_id()); + + if (ctx->pkt_mbuf_pool_in == NULL) + 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); + + for (mbuf_idx = 0; mbuf_idx < options->pool_sz; mbuf_idx++) { + ctx->mbufs_in[mbuf_idx] = cperf_mbuf_create( + ctx->pkt_mbuf_pool_in, options->segments_nb, + options, test_vector); + if (ctx->mbufs_in[mbuf_idx] == NULL) + goto err; + } + + if (options->out_of_place == 1) { + + snprintf(pool_name, sizeof(pool_name), "cperf_pool_out_cdev_%d", + dev_id); + + ctx->pkt_mbuf_pool_out = rte_pktmbuf_pool_create( + pool_name, options->pool_sz, 0, 0, + RTE_PKTMBUF_HEADROOM + + RTE_CACHE_LINE_ROUNDUP( + options->buffer_sz + + options->auth_digest_sz), + rte_socket_id()); + + if (ctx->pkt_mbuf_pool_out == NULL) + goto err; + } + + ctx->mbufs_out = rte_malloc(NULL, + (sizeof(struct rte_mbuf *) * + ctx->options->pool_sz), 0); + + for (mbuf_idx = 0; mbuf_idx < options->pool_sz; mbuf_idx++) { + if (options->out_of_place == 1) { + ctx->mbufs_out[mbuf_idx] = cperf_mbuf_create( + ctx->pkt_mbuf_pool_out, 1, + options, test_vector); + if (ctx->mbufs_out[mbuf_idx] == NULL) + goto err; + } else { + ctx->mbufs_out[mbuf_idx] = NULL; + } + } + + snprintf(pool_name, sizeof(pool_name), "cperf_op_pool_cdev_%d", + dev_id); + + ctx->crypto_op_pool = rte_crypto_op_pool_create(pool_name, + RTE_CRYPTO_OP_TYPE_SYMMETRIC, options->pool_sz, 0, 0, + rte_socket_id()); + if (ctx->crypto_op_pool == NULL) + goto err; + + return ctx; +err: + cperf_verify_test_free(ctx, mbuf_idx); + + return NULL; +} + +static int +cperf_verify_op(struct rte_crypto_op *op, + const struct cperf_options *options, + const struct cperf_test_vector *vector) +{ + const struct rte_mbuf *m; + uint32_t len; + uint16_t nb_segs; + uint8_t *data; + uint32_t cipher_offset, auth_offset; + uint8_t cipher, auth; + int res = 0; + + if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) + return 1; + + if (op->sym->m_dst) + m = op->sym->m_dst; + else + m = op->sym->m_src; + nb_segs = m->nb_segs; + len = 0; + while (m && nb_segs != 0) { + len += m->data_len; + m = m->next; + nb_segs--; + } + + data = rte_malloc(NULL, len, 0); + if (data == NULL) + return 1; + + if (op->sym->m_dst) + m = op->sym->m_dst; + else + m = op->sym->m_src; + nb_segs = m->nb_segs; + len = 0; + while (m && nb_segs != 0) { + memcpy(data + len, rte_pktmbuf_mtod(m, uint8_t *), + m->data_len); + len += m->data_len; + m = m->next; + nb_segs--; + } + + switch (options->op_type) { + case CPERF_CIPHER_ONLY: + cipher = 1; + cipher_offset = 0; + auth = 0; + auth_offset = 0; + break; + case CPERF_CIPHER_THEN_AUTH: + cipher = 1; + cipher_offset = 0; + auth = 1; + auth_offset = vector->plaintext.length; + break; + case CPERF_AUTH_ONLY: + cipher = 0; + cipher_offset = 0; + auth = 1; + auth_offset = vector->plaintext.length; + break; + case CPERF_AUTH_THEN_CIPHER: + cipher = 1; + cipher_offset = 0; + auth = 1; + auth_offset = vector->plaintext.length; + break; + case CPERF_AEAD: + cipher = 1; + cipher_offset = vector->aad.length; + auth = 1; + auth_offset = vector->aad.length + vector->plaintext.length; + break; + } + + if (cipher == 1) { + if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) + res += memcmp(data + cipher_offset, + vector->ciphertext.data, + vector->ciphertext.length); + else + res += memcmp(data + cipher_offset, + vector->plaintext.data, + vector->plaintext.length); + } + + if (auth == 1) { + if (options->auth_op == RTE_CRYPTO_AUTH_OP_GENERATE) + res += memcmp(data + auth_offset, + vector->digest.data, + vector->digest.length); + } + + return !!res; +} + +int +cperf_verify_test_runner(void *test_ctx) +{ + struct cperf_verify_ctx *ctx = 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 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]; + + uint32_t lcore = rte_lcore_id(); + +#ifdef CPERF_LINEARIZATION_ENABLE + struct rte_cryptodev_info dev_info; + int linearize = 0; + + /* Check if source mbufs require coalescing */ + if (ctx->options->segments_nb > 1) { + rte_cryptodev_info_get(ctx->dev_id, &dev_info); + if ((dev_info.feature_flags & + RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) == 0) + linearize = 1; + } +#endif /* CPERF_LINEARIZATION_ENABLE */ + + ctx->lcore_id = lcore; + + if (!ctx->options->csv) + printf("\n# Running verify test on device: %u, lcore: %u\n", + ctx->dev_id, lcore); + + while (ops_enqd_total < ctx->options->total_ops) { + + 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; + + 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); + +#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 */ + + /* 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); + + m_idx += ops_needed; + if (m_idx + ctx->options->burst_sz > ctx->options->pool_sz) + m_idx = 0; + + if (ops_deqd == 0) { + /** + * Count dequeue polls which didn't return any + * processed operations. This statistic is mainly + * relevant to hw accelerators. + */ + ops_deqd_failed++; + continue; + } + + for (i = 0; i < ops_deqd; i++) { + if (cperf_verify_op(ops_processed[i], ctx->options, + ctx->test_vector)) + ctx->results.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 + * failures. + */ + rte_crypto_op_free(ops_processed[i]); + ops_deqd_total += ops_deqd; + } + } + + /* 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); + + /* 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++; + continue; + } + + for (i = 0; i < ops_deqd; i++) { + if (cperf_verify_op(ops_processed[i], ctx->options, + ctx->test_vector)) + ctx->results.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 + * failures. + */ + rte_crypto_op_free(ops_processed[i]); + ops_deqd_total += ops_deqd; + } + } + + 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" + "\tFailed Deq\tEmpty Polls\n"); + + printf("\n%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); + } else { + if (!only_once) + printf("\n# CPU lcore id, Burst Size(B), " + "Buffer 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); + } + + cperf_verify_test_free(ctx, ctx->options->pool_sz); +} diff --git a/app/test-crypto-perf/cperf_test_verify.h b/app/test-crypto-perf/cperf_test_verify.h new file mode 100644 index 0000000000..3fa78ee6ae --- /dev/null +++ b/app/test-crypto-perf/cperf_test_verify.h @@ -0,0 +1,58 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2016-2017 Intel Corporation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _CPERF_VERIFY_ +#define _CPERF_VERIFY_ + +#include + +#include + +#include "cperf.h" +#include "cperf_ops.h" +#include "cperf_options.h" +#include "cperf_test_vectors.h" + + +void * +cperf_verify_test_constructor(uint8_t dev_id, uint16_t qp_id, + const struct cperf_options *options, + const struct cperf_test_vector *test_vector, + const struct cperf_op_fns *ops_fn); + +int +cperf_verify_test_runner(void *test_ctx); + +void +cperf_verify_test_destructor(void *test_ctx); + +#endif /* _CPERF_VERIFY_ */ diff --git a/app/test-crypto-perf/main.c b/app/test-crypto-perf/main.c index 063ee477ad..3a80350f68 100644 --- a/app/test-crypto-perf/main.c +++ b/app/test-crypto-perf/main.c @@ -9,10 +9,12 @@ #include "cperf_test_vector_parsing.h" #include "cperf_test_throughput.h" #include "cperf_test_latency.h" +#include "cperf_test_verify.h" const char *cperf_test_type_strs[] = { [CPERF_TEST_TYPE_THROUGHPUT] = "throughput", - [CPERF_TEST_TYPE_LATENCY] = "latency" + [CPERF_TEST_TYPE_LATENCY] = "latency", + [CPERF_TEST_TYPE_VERIFY] = "verify" }; const char *cperf_op_type_strs[] = { @@ -33,6 +35,11 @@ const struct cperf_test cperf_testmap[] = { cperf_latency_test_constructor, cperf_latency_test_runner, cperf_latency_test_destructor + }, + [CPERF_TEST_TYPE_VERIFY] = { + cperf_verify_test_constructor, + cperf_verify_test_runner, + cperf_verify_test_destructor } }; diff --git a/doc/guides/tools/cryptoperf.rst b/doc/guides/tools/cryptoperf.rst index 478d256e94..dbf567270c 100644 --- a/doc/guides/tools/cryptoperf.rst +++ b/doc/guides/tools/cryptoperf.rst @@ -133,6 +133,7 @@ The following are the appication command-line options: throughput latency + verify * ``--silent`` @@ -191,11 +192,6 @@ The following are the appication command-line options: Enable out-of-place crypto operations mode. -* ``--verify`` - - Enable verify that all crypto operations were successful. - The verification is done after the performance test. - * ``--test-file `` Set test vector file path. See the Test Vector File chapter. @@ -368,7 +364,7 @@ on two cores for cipher encryption aes-cbc, ten operations in silent mode:: --cipher-op encrypt --optype cipher-only --silent --ptest latency --total-ops 10 -Call application for performance latency test of single open ssl PMD +Call application for verification test of single open ssl PMD for cipher encryption aes-gcm and auth generation aes-gcm,ten operations in silent mode, test vector provide in file "test_aes_gcm.data" with packet verification:: @@ -377,8 +373,8 @@ with packet verification:: --devtype crypto_openssl --cipher-algo aes-gcm --cipher-key-sz 16 --cipher-iv-sz 16 --cipher-op encrypt --auth-algo aes-gcm --auth-key-sz 16 --auth-digest-sz 16 --auth-aad-sz 16 --auth-op generate --optype aead - --silent --ptest latency --total-ops 10 - --test-file test_aes_gcm.data --verify + --silent --ptest verify --total-ops 10 + --test-file test_aes_gcm.data Test vector file for cipher algorithm aes cbc 256 with authorization sha:: -- 2.20.1