[PATCH 0/3] Crypto performance app improvements

[PATCH 0/3] Crypto performance app improvements

[Pablo de Lara]

With this patchset, user will be able to run performance tests
on different buffer and burst sizes, in a single run, instead
of having to run the application several times.

Also, the verify option has been removed and, instead,
a new verify test has been created, to simplify the throughput
and latency tests.

Pablo de Lara (2):
  app/crypto-perf: do not append digest if not used
  app/crypto-perf: add range/list of sizes

Sergio Gonzalez Monroy (1):
  app/crypto-perf: move verify as single test type

 app/test-crypto-perf/Makefile                    |   1 +
 app/test-crypto-perf/cperf_ops.c                 |  20 +-
 app/test-crypto-perf/cperf_ops.h                 |   5 -
 app/test-crypto-perf/cperf_options.h             |  34 +-
 app/test-crypto-perf/cperf_options_parsing.c     | 252 ++++++++--
 app/test-crypto-perf/cperf_test_latency.c        | 517 ++++++++------------
 app/test-crypto-perf/cperf_test_throughput.c     | 502 +++++++-------------
 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         | 576 +++++++++++++++++++++++
 app/test-crypto-perf/cperf_test_verify.h         |  58 +++
 app/test-crypto-perf/cperf_verify_parser.c       |   4 +-
 app/test-crypto-perf/main.c                      |  59 ++-
 doc/guides/tools/cryptoperf.rst                  |  27 +-
 14 files changed, 1314 insertions(+), 761 deletions(-)
 create mode 100644 app/test-crypto-perf/cperf_test_verify.c
 create mode 100644 app/test-crypto-perf/cperf_test_verify.h

-- 
2.7.4

[PATCH 1/3] app/crypto-perf: move verify as single test type

[Pablo de Lara]

From: Sergio Gonzalez Monroy <sergio.gonzalez.monroy@intel.com>

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 <sergio.gonzalez.monroy@intel.com>
---
 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 |  18 +-
 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, 669 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 276ba68..d04cc08 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
 
 # this application needs libraries first
diff --git a/app/test-crypto-perf/cperf_ops.h b/app/test-crypto-perf/cperf_ops.h
index 11e2117..1b748da 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 96b7511..823059d 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")
 
@@ -37,7 +36,8 @@
 enum cperf_perf_test_type {
 	CPERF_TEST_TYPE_THROUGHPUT,
 	CPERF_TEST_TYPE_CYCLECOUNT,
-	CPERF_TEST_TYPE_LATENCY
+	CPERF_TEST_TYPE_LATENCY,
+	CPERF_TEST_TYPE_VERIFY
 };
 
 
@@ -67,7 +67,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 da82ce9..d89c239 100644
--- a/app/test-crypto-perf/cperf_options_parsing.c
+++ b/app/test-crypto-perf/cperf_options_parsing.c
@@ -266,15 +266,6 @@ parse_out_of_place(struct cperf_options *opts,
 }
 
 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)
 {
@@ -456,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 },
 
@@ -494,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;
@@ -529,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 },
@@ -587,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;
@@ -606,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");
@@ -662,7 +651,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 5ec1b2c..fb91517 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 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id,
 	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)
 {
@@ -575,26 +480,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;
@@ -669,8 +554,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 6c04697..92176d7 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 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id,
 	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 0000000..27fbd6c
--- /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 <rte_malloc.h>
+#include <rte_cycles.h>
+#include <rte_crypto.h>
+#include <rte_cryptodev.h>
+
+#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 0000000..3fa78ee
--- /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 <stdint.h>
+
+#include <rte_mbuf.h>
+
+#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 c1eaaff..da37972 100644
--- a/app/test-crypto-perf/main.c
+++ b/app/test-crypto-perf/main.c
@@ -9,11 +9,13 @@
 #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_CYCLECOUNT] = "cycle-count",
-	[CPERF_TEST_TYPE_LATENCY] = "latency"
+	[CPERF_TEST_TYPE_LATENCY] = "latency",
+	[CPERF_TEST_TYPE_VERIFY] = "verify"
 };
 
 const char *cperf_op_type_strs[] = {
@@ -35,6 +37,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 1fc40c4..6328dab 100644
--- a/doc/guides/tools/cryptoperf.rst
+++ b/doc/guides/tools/cryptoperf.rst
@@ -132,6 +132,7 @@ The following are the appication command-line options:
 
            throughput
            latency
+           verify
 
 * ``--silent``
 
@@ -188,11 +189,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 <name>``
 
         Set test vector file path. See the Test Vector File chapter.
@@ -365,7 +361,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::
@@ -374,8 +370,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.7.4

[PATCH 2/3] app/crypto-perf: do not append digest if not used

[Pablo de Lara]

When testing cipher only operations, there is no need to append digest
at the end of the buffer.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_test_latency.c    |  8 +++++---
 app/test-crypto-perf/cperf_test_throughput.c | 10 ++++++----
 app/test-crypto-perf/cperf_test_verify.c     | 10 ++++++----
 3 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c
index fb91517..25f7749 100644
--- a/app/test-crypto-perf/cperf_test_latency.c
+++ b/app/test-crypto-perf/cperf_test_latency.c
@@ -182,10 +182,12 @@ cperf_mbuf_create(struct rte_mempool *mempool,
 		memcpy(mbuf_data, test_data, last_sz);
 	}
 
-	mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf,
+	if (options->op_type != CPERF_CIPHER_ONLY) {
+		mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf,
 			options->auth_digest_sz);
-	if (mbuf_data == NULL)
-		goto error;
+		if (mbuf_data == NULL)
+			goto error;
+	}
 
 	if (options->op_type == CPERF_AEAD) {
 		uint8_t *aead = (uint8_t *)rte_pktmbuf_prepend(mbuf,
diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c
index 92176d7..7108075 100644
--- a/app/test-crypto-perf/cperf_test_throughput.c
+++ b/app/test-crypto-perf/cperf_test_throughput.c
@@ -163,10 +163,12 @@ cperf_mbuf_create(struct rte_mempool *mempool,
 		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_CIPHER_ONLY) {
+		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,
diff --git a/app/test-crypto-perf/cperf_test_verify.c b/app/test-crypto-perf/cperf_test_verify.c
index 27fbd6c..be157e6 100644
--- a/app/test-crypto-perf/cperf_test_verify.c
+++ b/app/test-crypto-perf/cperf_test_verify.c
@@ -165,10 +165,12 @@ cperf_mbuf_create(struct rte_mempool *mempool,
 		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_CIPHER_ONLY) {
+		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,
-- 
2.7.4

[PATCH 3/3] app/crypto-perf: add range/list of sizes

[Pablo de Lara]

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 <pablo.de.lara.guarch@intel.com>
---
 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 <n>``
 
         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 <n>``
 
         Set the number of segments per packet.
-- 
2.7.4

[PATCH v2 0/9] Crypto performance app improvements

[Pablo de Lara]

This patchset makes the following changes in the crypto-perf app:

- Adds the option to run performance tests on different
  buffer and burst sizes, in a single run, instead of having to
  run the application several times.

- Cleans up the application, by removing unused functions and
  separating the verify option in a new test type

- Fixes several issues in the application (such as wrong test vectors)


Pablo de Lara (8):
  app/crypto-perf: remove cyclecount test type
  app/crypto-perf: remove unused file
  app/crypto-perf: fix AES CBC 128 test vectors
  app/crypto-perf: do not append digest if not used
  app/crypto-perf: display results in test runner
  app/crypto-perf: add range/list of sizes
  app/crypto-perf: add extra option checks
  app/crypto-perf: reorg options structure

Sergio Gonzalez Monroy (1):
  app/crypto-perf: move verify as single test type

 app/test-crypto-perf/Makefile                    |   1 +
 app/test-crypto-perf/cperf_ops.c                 |  20 +-
 app/test-crypto-perf/cperf_ops.h                 |   5 -
 app/test-crypto-perf/cperf_options.h             |  35 +-
 app/test-crypto-perf/cperf_options_parsing.c     | 308 ++++++++++--
 app/test-crypto-perf/cperf_test_latency.c        | 508 ++++++++------------
 app/test-crypto-perf/cperf_test_throughput.c     | 502 +++++++-------------
 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         | 579 +++++++++++++++++++++++
 app/test-crypto-perf/cperf_test_verify.h         |  58 +++
 app/test-crypto-perf/cperf_verify_parser.c       | 314 ------------
 app/test-crypto-perf/data/aes_cbc_128_sha.data   | 439 +++++++++--------
 app/test-crypto-perf/main.c                      |  71 ++-
 doc/guides/tools/cryptoperf.rst                  |  27 +-
 15 files changed, 1592 insertions(+), 1295 deletions(-)
 create mode 100644 app/test-crypto-perf/cperf_test_verify.c
 create mode 100644 app/test-crypto-perf/cperf_test_verify.h
 delete mode 100644 app/test-crypto-perf/cperf_verify_parser.c

-- 
2.7.4

[PATCH v2 1/9] app/crypto-perf: remove cyclecount test type

[Pablo de Lara]

Cyclecount test was not implemented, so it is removed.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_options.h         | 1 -
 app/test-crypto-perf/cperf_options_parsing.c | 4 ----
 app/test-crypto-perf/main.c                  | 2 --
 3 files changed, 7 deletions(-)

diff --git a/app/test-crypto-perf/cperf_options.h b/app/test-crypto-perf/cperf_options.h
index 96b7511..c0d919f 100644
--- a/app/test-crypto-perf/cperf_options.h
+++ b/app/test-crypto-perf/cperf_options.h
@@ -36,7 +36,6 @@
 
 enum cperf_perf_test_type {
 	CPERF_TEST_TYPE_THROUGHPUT,
-	CPERF_TEST_TYPE_CYCLECOUNT,
 	CPERF_TEST_TYPE_LATENCY
 };
 
diff --git a/app/test-crypto-perf/cperf_options_parsing.c b/app/test-crypto-perf/cperf_options_parsing.c
index d6afc85..f93e0c1 100644
--- a/app/test-crypto-perf/cperf_options_parsing.c
+++ b/app/test-crypto-perf/cperf_options_parsing.c
@@ -67,10 +67,6 @@ parse_cperf_test_type(struct cperf_options *opts, const char *arg)
 			CPERF_TEST_TYPE_THROUGHPUT
 		},
 		{
-			cperf_test_type_strs[CPERF_TEST_TYPE_CYCLECOUNT],
-			CPERF_TEST_TYPE_CYCLECOUNT
-		},
-		{
 			cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY],
 			CPERF_TEST_TYPE_LATENCY
 		}
diff --git a/app/test-crypto-perf/main.c b/app/test-crypto-perf/main.c
index fb3f72e..063ee47 100644
--- a/app/test-crypto-perf/main.c
+++ b/app/test-crypto-perf/main.c
@@ -12,7 +12,6 @@
 
 const char *cperf_test_type_strs[] = {
 	[CPERF_TEST_TYPE_THROUGHPUT] = "throughput",
-	[CPERF_TEST_TYPE_CYCLECOUNT] = "cycle-count",
 	[CPERF_TEST_TYPE_LATENCY] = "latency"
 };
 
@@ -30,7 +29,6 @@ const struct cperf_test cperf_testmap[] = {
 				cperf_throughput_test_runner,
 				cperf_throughput_test_destructor
 		},
-		[CPERF_TEST_TYPE_CYCLECOUNT] =  { NULL },
 		[CPERF_TEST_TYPE_LATENCY] = {
 				cperf_latency_test_constructor,
 				cperf_latency_test_runner,
-- 
2.7.4

[PATCH v2 2/9] app/crypto-perf: remove unused file

[Pablo de Lara]

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_verify_parser.c | 314 -----------------------------
 1 file changed, 314 deletions(-)
 delete mode 100644 app/test-crypto-perf/cperf_verify_parser.c

diff --git a/app/test-crypto-perf/cperf_verify_parser.c b/app/test-crypto-perf/cperf_verify_parser.c
deleted file mode 100644
index 5640d84..0000000
--- a/app/test-crypto-perf/cperf_verify_parser.c
+++ /dev/null
@@ -1,314 +0,0 @@
-#include <stdio.h>
-
-#include <rte_malloc.h>
-#include "cperf_options.h"
-#include "cperf_test_vectors.h"
-#include "cperf_verify_parser.h"
-
-int
-free_test_vector(struct cperf_test_vector *vector, struct cperf_options *opts)
-{
-	if (vector == NULL || opts == NULL)
-		return -1;
-
-	if (opts->test_file == NULL) {
-		if (vector->iv.data)
-			rte_free(vector->iv.data);
-		if (vector->aad.data)
-			rte_free(vector->aad.data);
-		if (vector->digest.data)
-			rte_free(vector->digest.data);
-		rte_free(vector);
-
-	} else {
-		if (vector->plaintext.data)
-			rte_free(vector->plaintext.data);
-		if (vector->cipher_key.data)
-			rte_free(vector->cipher_key.data);
-		if (vector->auth_key.data)
-			rte_free(vector->auth_key.data);
-		if (vector->iv.data)
-			rte_free(vector->iv.data);
-		if (vector->ciphertext.data)
-			rte_free(vector->ciphertext.data);
-		if (vector->aad.data)
-			rte_free(vector->aad.data);
-		if (vector->digest.data)
-			rte_free(vector->digest.data);
-		rte_free(vector);
-	}
-
-	return 0;
-}
-
-/* trim leading and trailing spaces */
-static char *
-trim(char *str)
-{
-	char *start, *end;
-
-	for (start = str; *start; start++) {
-		if (!isspace((unsigned char) start[0]))
-			break;
-	}
-
-	for (end = start + strlen(start); end > start + 1; end--) {
-		if (!isspace((unsigned char) end[-1]))
-			break;
-	}
-
-	*end = 0;
-
-	/* Shift from "start" to the beginning of the string */
-	if (start > str)
-		memmove(str, start, (end - start) + 1);
-
-	return str;
-}
-
-/* tokenization test values separated by a comma */
-static int
-parse_values(char *tokens, uint8_t **data, uint32_t *data_length)
-{
-	uint8_t n_tokens;
-	uint32_t data_size = 32;
-	uint8_t *values;
-	char *tok, *error = NULL;
-
-	tok = strtok(tokens, VALUE_DELIMITER);
-	if (tok == NULL)
-		return -1;
-
-	values = (uint8_t *) rte_zmalloc(NULL, sizeof(uint8_t) * data_size, 0);
-	if (values == NULL)
-		return -1;
-
-	n_tokens = 0;
-	while (tok != NULL) {
-		uint8_t *values_extended = NULL;
-
-		if (n_tokens >= data_size) {
-
-			data_size *= 2;
-
-			values_extended = (uint8_t *) rte_realloc(values,
-				sizeof(uint8_t) * data_size, 0);
-			if (values_extended == NULL) {
-				rte_free(values);
-				return -1;
-			}
-
-			values = values_extended;
-		}
-
-		values[n_tokens] = (uint8_t) strtoul(tok, &error, 0);
-		if ((error == NULL) || (*error != '\0')) {
-			printf("Failed with convert '%s'\n", tok);
-			rte_free(values);
-			return -1;
-		}
-
-		tok = strtok(NULL, VALUE_DELIMITER);
-		if (tok == NULL)
-			break;
-
-		n_tokens++;
-	}
-
-	uint8_t *resize_values = (uint8_t *) rte_realloc(values,
-		sizeof(uint8_t) * (n_tokens + 1), 0);
-
-	if (resize_values == NULL) {
-		rte_free(values);
-		return -1;
-	}
-
-	*data = resize_values;
-	*data_length = n_tokens + 1;
-
-	return 0;
-}
-
-/* checks the type of key and assigns data */
-static int
-parse_entry(char *entry, struct cperf_test_vector *vector)
-{
-	char *token, *key_token;
-	uint8_t *data = NULL;
-	int status;
-	uint32_t data_length;
-
-	/* get key */
-	token = strtok(entry, ENTRY_DELIMITER);
-	key_token = token;
-
-	/* get values for key */
-	token = strtok(NULL, ENTRY_DELIMITER);
-
-	if (token == NULL) {
-		printf("Expected 'key = values' but was '%.40s'..\n",
-			key_token);
-		return -1;
-	}
-
-	status = parse_values(token, &data, &data_length);
-	if (status)
-		return -1;
-
-	/* compare keys */
-	if (strstr(key_token, "plaintext")) {
-		if (vector->plaintext.data)
-			rte_free(vector->plaintext.data);
-		vector->plaintext.data = data;
-		vector->plaintext.length = data_length;
-	} else if (strstr(key_token, "cipher_key")) {
-		if (vector->cipher_key.data)
-			rte_free(vector->cipher_key.data);
-		vector->cipher_key.data = data;
-		vector->cipher_key.length = data_length;
-	} else if (strstr(key_token, "auth_key")) {
-		if (vector->auth_key.data)
-			rte_free(vector->auth_key.data);
-		vector->auth_key.data = data;
-		vector->auth_key.length = data_length;
-	} else if (strstr(key_token, "iv")) {
-		if (vector->iv.data)
-			rte_free(vector->iv.data);
-		vector->iv.data = data;
-		vector->iv.phys_addr = rte_malloc_virt2phy(vector->iv.data);
-		vector->iv.length = data_length;
-	} else if (strstr(key_token, "ciphertext")) {
-		if (vector->ciphertext.data)
-			rte_free(vector->ciphertext.data);
-		vector->ciphertext.data = data;
-		vector->ciphertext.length = data_length;
-	} else if (strstr(key_token, "aad")) {
-		if (vector->aad.data)
-			rte_free(vector->aad.data);
-		vector->aad.data = data;
-		vector->aad.phys_addr = rte_malloc_virt2phy(vector->aad.data);
-		vector->aad.length = data_length;
-	} else if (strstr(key_token, "digest")) {
-		if (vector->digest.data)
-			rte_free(vector->digest.data);
-		vector->digest.data = data;
-		vector->digest.phys_addr = rte_malloc_virt2phy(
-			vector->digest.data);
-		vector->digest.length = data_length;
-	} else {
-		printf("Not valid key: '%s'\n", trim(key_token));
-		return -1;
-	}
-
-	return 0;
-}
-
-/* searches in the file for registry keys and values */
-static int
-parse_file(struct cperf_test_vector *v_vec, const char *path)
-{
-	FILE *fp;
-	char *line = NULL, *entry = NULL;
-	ssize_t read;
-	size_t len = 0;
-	int status = 0;
-
-	fp = fopen(path, "r");
-	if (fp == NULL) {
-		printf("File %s does not exists\n", path);
-		return -1;
-	}
-
-	while ((read = getline(&line, &len, fp)) != -1) {
-		/* ignore comments and new lines */
-		if (line[0] == '#' || line[0] == '/' || line[0] == '\n'
-			|| line[0] == '\r' || line[0] == ' ')
-			continue;
-
-		trim(line);
-
-		/* buffer for multiline */
-		entry = (char *) rte_realloc(entry,
-					sizeof(char) * strlen(line) + 1, 0);
-		if (entry == NULL)
-			return -1;
-
-		memset(entry, 0, strlen(line) + 1);
-		strncpy(entry, line, strlen(line));
-
-		/* check if entry ends with , or = */
-		if (entry[strlen(entry) - 1] == ','
-			|| entry[strlen(entry) - 1] == '=') {
-			while ((read = getline(&line, &len, fp)) != -1) {
-				trim(line);
-
-				/* extend entry about length of new line */
-				char *entry_extended = (char *) rte_realloc(
-					entry, sizeof(char)
-						* (strlen(line) + strlen(entry))
-						+ 1, 0);
-
-				if (entry_extended == NULL)
-					goto err;
-				entry = entry_extended;
-
-				strncat(entry, line, strlen(line));
-
-				if (entry[strlen(entry) - 1] != ',')
-					break;
-			}
-		}
-		status = parse_entry(entry, v_vec);
-		if (status) {
-			printf("An error occurred while parsing!\n");
-			goto err;
-		}
-	}
-
-	fclose(fp);
-	free(line);
-	rte_free(entry);
-
-	return 0;
-
-err:
-	if (fp)
-		fclose(fp);
-	if (line)
-		free(line);
-	if (entry)
-		rte_free(entry);
-
-	return -1;
-}
-
-struct cperf_test_vector*
-cperf_test_vector_get_from_file(struct cperf_options *opts)
-{
-	int status;
-	struct cperf_test_vector *test_vector = NULL;
-
-	if (opts == NULL || opts->test_file == NULL)
-		return test_vector;
-
-	test_vector = (struct cperf_test_vector *) rte_zmalloc(NULL,
-		sizeof(struct cperf_test_vector), 0);
-	if (test_vector == NULL)
-		return test_vector;
-
-	/* filling the vector with data from a file */
-	status = parse_file(test_vector, opts->test_file);
-	if (status) {
-		free_test_vector(test_vector, opts);
-		return NULL;
-	}
-
-	/* other values not included in the file */
-	test_vector->data.cipher_offset = 0;
-	test_vector->data.cipher_length = opts->buffer_sz;
-
-	test_vector->data.auth_offset = 0;
-	test_vector->data.auth_length = opts->buffer_sz;
-
-	return test_vector;
-}
-- 
2.7.4

[PATCH v2 3/9] app/crypto-perf: fix AES CBC 128 test vectors

[Pablo de Lara]

Ciphertext and digests for different buffer sizes
were incorrect.

CC: stable@dpdk.org
Fixes: 5f1d85c5a8ab ("app/crypto-perf: add test vectors files")

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/data/aes_cbc_128_sha.data | 439 ++++++++++++-------------
 1 file changed, 219 insertions(+), 220 deletions(-)

diff --git a/app/test-crypto-perf/data/aes_cbc_128_sha.data b/app/test-crypto-perf/data/aes_cbc_128_sha.data
index f288e4a..0b054f5 100644
--- a/app/test-crypto-perf/data/aes_cbc_128_sha.data
+++ b/app/test-crypto-perf/data/aes_cbc_128_sha.data
@@ -140,134 +140,134 @@ plaintext =
 0xa4, 0x39, 0xe8, 0x8b, 0x2a, 0x50, 0xf5, 0x18, 0x70, 0xe2, 0xfc, 0xd6, 0xbe, 0xd3, 0x46, 0x4b
 
 ciphertext =
-0xd7, 0x0a, 0xed, 0x84, 0xf9, 0x13, 0x83, 0xd0, 0xbf, 0x57, 0xc2, 0x8b, 0xc9, 0x8c, 0x3a, 0x19,
-0x6a, 0x50, 0x01, 0xb7, 0xfe, 0xe2, 0x54, 0x0d, 0x94, 0x41, 0xcc, 0xcb, 0xe7, 0x41, 0x6f, 0x16,
-0xf7, 0x24, 0xd7, 0x01, 0x8d, 0xae, 0xc7, 0xa3, 0x4c, 0x36, 0xc2, 0x9c, 0x06, 0xba, 0xe2, 0x27,
-0x4f, 0xd2, 0xbb, 0x55, 0x65, 0xbb, 0xeb, 0x33, 0xe3, 0xaa, 0x6a, 0x47, 0x8c, 0xa4, 0xb4, 0x2f,
-0xe6, 0x20, 0xde, 0xde, 0x93, 0x59, 0x35, 0x79, 0x17, 0x84, 0x7d, 0x9b, 0xee, 0x72, 0x0a, 0x0f,
-0xb9, 0x59, 0xb3, 0xc5, 0xbc, 0x9c, 0xf1, 0xdb, 0x52, 0x5c, 0x90, 0xd2, 0x4d, 0x5a, 0x5e, 0xb9,
-0xdf, 0x27, 0x2c, 0xbd, 0xc2, 0xcf, 0x16, 0x30, 0xbe, 0xa4, 0x45, 0xeb, 0xc2, 0x6f, 0x01, 0x26,
-0x1a, 0xa6, 0xb1, 0x87, 0x4e, 0x6d, 0x95, 0x0c, 0xa6, 0x01, 0xca, 0x53, 0x5d, 0x0b, 0x35, 0x5c,
-0xa7, 0x42, 0x2f, 0x7a, 0x18, 0x4b, 0x18, 0x51, 0x0e, 0x80, 0xf0, 0x7e, 0xca, 0x0e, 0xec, 0x88,
-0x19, 0xa0, 0xce, 0x1f, 0xea, 0x61, 0x88, 0x26, 0xa9, 0xd1, 0xd0, 0xdf, 0x5c, 0x90, 0x87, 0x34,
-0xda, 0x68, 0x26, 0x49, 0xcf, 0xf7, 0x10, 0x7f, 0x09, 0x11, 0xde, 0x40, 0xd2, 0x17, 0x65, 0x6f,
-0x70, 0x3f, 0x43, 0xaa, 0x73, 0xbf, 0xb4, 0x4e, 0x07, 0x4e, 0x41, 0x89, 0xd3, 0xa7, 0xb3, 0x49,
-0x09, 0x05, 0xb5, 0x9d, 0x7d, 0x45, 0x11, 0x0b, 0x0f, 0x8a, 0x83, 0x2a, 0x94, 0x80, 0x4b, 0xcf,
-0xa3, 0x97, 0xb3, 0x93, 0x2f, 0xbc, 0x1f, 0xdf, 0xe7, 0xb7, 0xec, 0x3a, 0x39, 0xeb, 0xa9, 0x8d,
-0x7f, 0x9b, 0xf7, 0x12, 0xfc, 0x0c, 0x28, 0xe4, 0x82, 0x98, 0x88, 0xf7, 0x93, 0x4a, 0x0a, 0xdc,
-0x8d, 0x77, 0x2d, 0x7b, 0xd6, 0x6a, 0x6f, 0x0d, 0x54, 0x55, 0x0c, 0xe8, 0x6b, 0x71, 0xda, 0x7b,
-0x5a, 0xc5, 0x79, 0xa4, 0x2d, 0x61, 0xeb, 0x07, 0x95, 0x0a, 0x8a, 0x2c, 0x5c, 0xb0, 0xe2, 0x08,
-0xab, 0x07, 0x04, 0x3a, 0x00, 0xce, 0x6e, 0xc1, 0x7f, 0x0e, 0x65, 0x6a, 0xbe, 0x9c, 0xd5, 0xab,
-0x0f, 0x90, 0x6a, 0xfb, 0x45, 0x2f, 0x78, 0x80, 0xbe, 0x8a, 0x0c, 0xe1, 0x79, 0xf9, 0xfd, 0xbe,
-0x0d, 0xea, 0xfb, 0x57, 0x2b, 0x5f, 0xbf, 0x25, 0x8d, 0xa0, 0xd5, 0x4e, 0xac, 0x0d, 0x13, 0x66,
-0x75, 0xd0, 0xe3, 0x69, 0x2d, 0x1e, 0x85, 0xd1, 0x2b, 0xdb, 0xa0, 0xaa, 0x8d, 0x2c, 0x1d, 0xd2,
-0x69, 0x46, 0x4f, 0x3d, 0xe2, 0xd7, 0x80, 0xba, 0xa1, 0x53, 0x35, 0xb4, 0xd4, 0x4f, 0x33, 0x0e,
-0x03, 0xb8, 0xd0, 0xb8, 0x13, 0xc8, 0x12, 0xe6, 0x49, 0x0b, 0xe2, 0x0f, 0x2b, 0x09, 0xcf, 0x82,
-0x36, 0x9e, 0x87, 0x24, 0xc0, 0x66, 0xd8, 0xd2, 0x40, 0x33, 0xa4, 0x4b, 0x1f, 0x30, 0x9a, 0x1a,
-0x12, 0x65, 0x1e, 0xfc, 0x63, 0x3b, 0x31, 0x75, 0xc6, 0x85, 0xa4, 0xf0, 0x04, 0xb2, 0x56, 0x6c,
-0xeb, 0x0f, 0xae, 0xf4, 0x6a, 0x47, 0xae, 0x9c, 0xe1, 0x88, 0xc2, 0xf0, 0x7b, 0x28, 0xaa, 0xb8,
-0xb8, 0x23, 0x82, 0xec, 0xe1, 0xfa, 0x69, 0x71, 0xa9, 0x6c, 0x91, 0x05, 0x4e, 0x94, 0x41, 0x0c,
-0x53, 0x01, 0x35, 0x29, 0xc0, 0xc4, 0x75, 0x51, 0x0f, 0x61, 0x6a, 0x06, 0x02, 0x9b, 0x61, 0xd2,
-0x2a, 0xdd, 0xc8, 0x2b, 0x71, 0x2e, 0xcd, 0x94, 0xe6, 0x61, 0x88, 0xa5, 0xf9, 0xd5, 0xb8, 0x39,
-0xe6, 0x97, 0x4b, 0x1f, 0x8c, 0xf0, 0xfc, 0x2c, 0x9a, 0xd6, 0xc2, 0x4d, 0x56, 0x49, 0x2c, 0x7c,
-0x31, 0x00, 0x9c, 0x22, 0xf4, 0xad, 0xf0, 0x6d, 0x73, 0xe3, 0xda, 0x5a, 0x80, 0x8d, 0x25, 0xbd,
-0x6f, 0xe9, 0xb1, 0x39, 0x19, 0xd5, 0x5b, 0x4c, 0xc1, 0xb1, 0xa3, 0x57, 0xee, 0x41, 0xef, 0x23,
-0x7a, 0x47, 0xde, 0x56, 0x0c, 0x2d, 0x43, 0x77, 0xcc, 0x17, 0xc1, 0x6c, 0xf9, 0x90, 0xf2, 0xa0,
-0x1a, 0xb8, 0xab, 0x7a, 0x99, 0x90, 0xc8, 0x5b, 0x19, 0x20, 0x4e, 0xd9, 0x4b, 0xb4, 0x92, 0x71,
-0x27, 0x44, 0x30, 0x83, 0x6d, 0x39, 0x24, 0xa3, 0x0a, 0xa5, 0xf4, 0x5c, 0x31, 0x16, 0x26, 0xdb,
-0x62, 0xe1, 0x74, 0xf3, 0x89, 0xc6, 0x59, 0x6d, 0xcd, 0x10, 0xb9, 0xcc, 0x9a, 0x5b, 0x9a, 0x31,
-0xfa, 0xbb, 0x5b, 0x79, 0xc7, 0x05, 0x78, 0xcb, 0x15, 0x7f, 0x71, 0x51, 0x00, 0x95, 0xb0, 0x3b,
-0x82, 0x5d, 0xe2, 0x48, 0xfd, 0x19, 0xca, 0x87, 0xde, 0x16, 0x52, 0x61, 0xd0, 0x72, 0xbd, 0x00,
-0x7d, 0xae, 0x3f, 0x54, 0x2e, 0x36, 0xc8, 0x9d, 0xb9, 0x2b, 0xdf, 0x12, 0xe4, 0x46, 0x1b, 0x29,
-0xda, 0x6b, 0x8d, 0xa5, 0xfd, 0x28, 0xbc, 0x0f, 0x13, 0x27, 0x82, 0x06, 0x9f, 0xf2, 0xd3, 0x3e,
-0x80, 0x2b, 0x86, 0xf8, 0x2c, 0x4b, 0xd6, 0x82, 0x20, 0x9b, 0xa7, 0xa4, 0x7d, 0xd3, 0xf1, 0x9b,
-0xe3, 0x94, 0x6b, 0xd3, 0x12, 0x14, 0xd5, 0x70, 0x0e, 0x8e, 0x2c, 0xc2, 0x5f, 0x22, 0x37, 0x09,
-0x02, 0xbd, 0x03, 0x64, 0xd8, 0xc5, 0x61, 0xca, 0xe6, 0xea, 0x76, 0xf6, 0xce, 0x21, 0xb2, 0x00,
-0xef, 0x99, 0x4f, 0xd7, 0x9d, 0x8b, 0xaa, 0xa4, 0x2a, 0x37, 0x5a, 0x98, 0x71, 0x11, 0x1c, 0xf7,
-0xf1, 0x8e, 0x34, 0x80, 0x07, 0xfa, 0x8d, 0x5a, 0xb3, 0x84, 0xdf, 0xa6, 0xbe, 0x53, 0x87, 0x31,
-0xe3, 0xb1, 0xe1, 0xd0, 0x9e, 0x2e, 0xec, 0x5b, 0x46, 0xb9, 0x87, 0xa0, 0x45, 0xb4, 0x5b, 0x92,
-0x68, 0x98, 0x4c, 0x69, 0xa1, 0xf4, 0x49, 0x8e, 0xc9, 0x50, 0xf7, 0x9b, 0x99, 0x5b, 0x4e, 0x99,
-0xda, 0x8e, 0xa8, 0x39, 0x04, 0x21, 0x94, 0x06, 0x00, 0xdc, 0x45, 0xd8, 0xfe, 0x53, 0x0b, 0x7b,
-0xe5, 0x26, 0x27, 0x61, 0xaa, 0x37, 0x8f, 0x7d, 0x3f, 0xe7, 0xb4, 0xc7, 0x8d, 0x6f, 0xf6, 0x76,
-0x04, 0xed, 0x9f, 0x0d, 0x46, 0xf7, 0x4d, 0x3d, 0x2e, 0x9f, 0x92, 0x8c, 0x7a, 0x73, 0x82, 0x3b,
-0xfb, 0x04, 0x8e, 0xcb, 0xc2, 0xd9, 0xf3, 0x23, 0x35, 0x40, 0xde, 0xf0, 0x6f, 0xd2, 0xcd, 0xed,
-0xe2, 0xc7, 0xf6, 0x0b, 0x75, 0xbd, 0x33, 0x6f, 0x80, 0x23, 0x99, 0x07, 0xb8, 0x39, 0x47, 0x43,
-0x72, 0x55, 0xf1, 0xe6, 0xbf, 0x8e, 0xb9, 0x55, 0x75, 0x8b, 0xb0, 0x32, 0xdc, 0x60, 0xaa, 0xb8,
-0x66, 0xbe, 0xb2, 0xb8, 0xa3, 0x99, 0x9e, 0xef, 0xb5, 0x85, 0x1c, 0xe7, 0x6a, 0x8e, 0x07, 0x59,
-0x50, 0x65, 0xd2, 0x71, 0x0b, 0xc5, 0x6f, 0x4f, 0xa3, 0x45, 0xfc, 0xf2, 0x1d, 0x08, 0x85, 0x3e,
-0x50, 0x7c, 0xba, 0x16, 0x4c, 0xf5, 0x0d, 0x12, 0xe6, 0xe3, 0x87, 0x37, 0xd7, 0xe9, 0x2c, 0x7f,
-0xb5, 0x1a, 0xa2, 0x65, 0xdf, 0xfc, 0x32, 0x85, 0x0c, 0x12, 0x81, 0x49, 0xf4, 0x9b, 0xbb, 0xeb,
-0x69, 0xe4, 0x8a, 0x43, 0x56, 0x73, 0x32, 0xf5, 0xdf, 0x88, 0xba, 0xd7, 0xde, 0xfa, 0x1d, 0xfb,
-0xaa, 0xa3, 0xb6, 0x3b, 0x2d, 0xca, 0xe8, 0x9a, 0xb3, 0x21, 0x3c, 0xcf, 0x76, 0x72, 0x66, 0xe2,
-0x46, 0x74, 0xff, 0xae, 0x54, 0x52, 0x59, 0x55, 0x1c, 0x17, 0x1b, 0x82, 0x11, 0x6c, 0x1c, 0x42,
-0x3f, 0xbc, 0x1c, 0x81, 0x5a, 0x3f, 0x61, 0x82, 0xa3, 0xa7, 0x26, 0x1f, 0x4e, 0xd0, 0xaf, 0x0e,
-0xf9, 0xe0, 0x24, 0x8c, 0xe4, 0x3d, 0x3f, 0x2e, 0x73, 0x81, 0xaf, 0x25, 0xe3, 0xc6, 0x98, 0x4a,
-0x4c, 0xca, 0x65, 0x84, 0xd2, 0x64, 0xd1, 0xf4, 0x53, 0xe0, 0x6f, 0xac, 0x40, 0xea, 0x6e, 0x36,
-0xcf, 0x85, 0x4b, 0x94, 0x3e, 0x93, 0x8b, 0xb6, 0xe5, 0x0f, 0x7b, 0x3a, 0xe8, 0xf2, 0x78, 0xd0,
-0xc6, 0xb6, 0xdf, 0x66, 0xde, 0xc7, 0x7e, 0x1d, 0x10, 0x05, 0x60, 0x5d, 0xbd, 0x41, 0x5d, 0xfc,
-0x07, 0xd8, 0x9f, 0x6a, 0xf4, 0x65, 0xd2, 0x69, 0x88, 0x29, 0x72, 0x32, 0xe0, 0x53, 0x56, 0x04,
-0x20, 0x6d, 0x3c, 0x01, 0x7a, 0xd0, 0x63, 0x4a, 0x06, 0x9f, 0xe2, 0x88, 0x02, 0x39, 0xa1, 0xd7,
-0x81, 0x5e, 0x83, 0xcd, 0x09, 0x12, 0x56, 0xd4, 0x71, 0x85, 0x35, 0xe0, 0x0b, 0x55, 0x96, 0x6d,
-0x16, 0x88, 0xb5, 0x9d, 0x8f, 0xd6, 0x1e, 0xe6, 0x39, 0x47, 0x7f, 0xae, 0x47, 0x30, 0xb7, 0x28,
-0x72, 0x23, 0xfc, 0x10, 0xb8, 0xad, 0xf7, 0xd6, 0x57, 0x3c, 0xc5, 0xf7, 0xd5, 0x4f, 0xb8, 0xc1,
-0x02, 0xc2, 0xd5, 0x8c, 0xe5, 0x19, 0x0f, 0x69, 0xd3, 0x26, 0x9e, 0xb6, 0x6a, 0x43, 0xca, 0xf6,
-0x9f, 0x60, 0x7b, 0x4b, 0x34, 0x01, 0x00, 0x08, 0x51, 0xa4, 0x28, 0x6c, 0x10, 0x51, 0x18, 0x80,
-0x90, 0x0c, 0xd0, 0xb9, 0x0e, 0x29, 0xe4, 0x09, 0xd8, 0xd3, 0x74, 0x13, 0x4f, 0x28, 0x43, 0xc7,
-0xde, 0xec, 0xeb, 0xd7, 0xf9, 0xa2, 0xc4, 0x13, 0x94, 0x45, 0x37, 0x24, 0x6c, 0x33, 0x9c, 0xd3,
-0xb4, 0x38, 0x08, 0x9f, 0x9a, 0x8e, 0xf4, 0x40, 0xc5, 0x9a, 0xd3, 0x93, 0x6b, 0x45, 0xfa, 0x46,
-0xfd, 0xe0, 0x15, 0x38, 0xf0, 0xe7, 0xdc, 0x68, 0xcf, 0x35, 0x0f, 0x04, 0x6c, 0x1b, 0x50, 0xea,
-0x3a, 0xc4, 0x1c, 0x24, 0xf0, 0x5f, 0x9b, 0xf4, 0xcd, 0x05, 0x07, 0x88, 0xb6, 0x06, 0x94, 0x92,
-0xb9, 0xbd, 0x70, 0x74, 0x16, 0xea, 0x0b, 0x1e, 0xfd, 0x42, 0xe7, 0x03, 0x4a, 0xc1, 0x70, 0xef,
-0xdb, 0x3d, 0x87, 0x0b, 0x66, 0xf6, 0x2e, 0x9e, 0x77, 0x67, 0x2a, 0xc0, 0x4c, 0x43, 0xe7, 0xe0,
-0xa6, 0x01, 0xd5, 0xef, 0x00, 0xc4, 0xe3, 0x5b, 0x2e, 0x51, 0xeb, 0x73, 0x1d, 0x64, 0xa1, 0xcf,
-0x61, 0xf1, 0xdf, 0x5e, 0x21, 0x50, 0x71, 0x7e, 0xfe, 0x9c, 0x01, 0xc3, 0x34, 0x63, 0x61, 0x40,
-0x13, 0x51, 0x3e, 0x57, 0xb7, 0x74, 0x73, 0x8d, 0x93, 0x67, 0x87, 0x44, 0x6e, 0x8c, 0x35, 0x06,
-0x96, 0x3a, 0xe4, 0xa1, 0xa7, 0xe2, 0x36, 0x1b, 0x34, 0xc8, 0x28, 0xc2, 0x0d, 0x99, 0xf0, 0x6b,
-0x87, 0x7a, 0x11, 0xc6, 0x3c, 0xf1, 0x05, 0xf3, 0xde, 0x44, 0xdb, 0x80, 0x49, 0x40, 0x71, 0xaf,
-0x90, 0x21, 0xca, 0x49, 0x79, 0x35, 0xf7, 0xa0, 0x96, 0x91, 0x2b, 0x23, 0x84, 0x1b, 0x29, 0xaa,
-0x86, 0x8d, 0xa5, 0x47, 0x60, 0xdf, 0xc3, 0xf7, 0xd6, 0x07, 0x89, 0x8f, 0x40, 0xd5, 0x18, 0x12,
-0xba, 0x76, 0x86, 0x88, 0x9c, 0xe4, 0x05, 0x12, 0x2a, 0x95, 0x55, 0xab, 0x13, 0x0a, 0x43, 0x01,
-0xd5, 0x75, 0xde, 0x78, 0x75, 0xab, 0xf2, 0x34, 0x5d, 0x4b, 0x02, 0x31, 0x18, 0x3e, 0xb1, 0x69,
-0xff, 0xf9, 0x71, 0x0f, 0x69, 0x0f, 0xef, 0x69, 0xb4, 0xc6, 0x45, 0xd2, 0x1c, 0xca, 0xf0, 0xec,
-0x07, 0x07, 0x06, 0x97, 0xd1, 0xb5, 0xb7, 0xf3, 0x1d, 0x80, 0xef, 0x46, 0xc3, 0x23, 0xe5, 0x44,
-0x5b, 0x53, 0x96, 0xf1, 0x18, 0xda, 0xa7, 0xd5, 0x90, 0x72, 0x07, 0xac, 0x25, 0xde, 0x0a, 0x79,
-0x16, 0x8c, 0x4c, 0x7a, 0xe1, 0x35, 0x9d, 0xec, 0x0c, 0x39, 0xa8, 0xf4, 0xc2, 0xa1, 0xda, 0x7f,
-0x0b, 0x7c, 0x89, 0x5f, 0x5b, 0x53, 0x32, 0xd1, 0x80, 0xd1, 0x21, 0x82, 0x32, 0x5b, 0x5b, 0x87,
-0x98, 0x5a, 0x8f, 0x9f, 0xe1, 0x96, 0x7b, 0x43, 0xd9, 0x58, 0xd0, 0xe3, 0xd1, 0xfa, 0xa0, 0x7d,
-0x80, 0x00, 0xe1, 0x12, 0xc8, 0x13, 0xa7, 0xe1, 0xc5, 0x32, 0xc8, 0x0f, 0x03, 0x9c, 0xa2, 0x31,
-0xd8, 0x81, 0x07, 0x40, 0xc2, 0x0d, 0x2d, 0x25, 0xc0, 0x13, 0xa9, 0x57, 0x9d, 0x14, 0x78, 0x0e,
-0x3e, 0xab, 0x22, 0x5e, 0x29, 0x66, 0x3e, 0xea, 0x59, 0x1a, 0x6f, 0xa3, 0xbf, 0x29, 0x51, 0x3b,
-0x18, 0xe0, 0xab, 0x8c, 0xfb, 0xe6, 0x00, 0x57, 0x1c, 0x1d, 0xd2, 0x59, 0x7d, 0xa5, 0xf4, 0x8c,
-0xfa, 0xe6, 0x2a, 0x77, 0x09, 0x93, 0x3a, 0x7d, 0x9d, 0xa9, 0x3d, 0xf2, 0xae, 0xb7, 0xcc, 0x5c,
-0xa3, 0xf1, 0x00, 0x4b, 0x8c, 0xaf, 0xd7, 0xbc, 0x78, 0x35, 0x9b, 0x56, 0x64, 0xe9, 0x22, 0x60,
-0xd8, 0x67, 0x7e, 0x7d, 0x18, 0xc1, 0x44, 0x16, 0xcb, 0x9a, 0x79, 0x4d, 0x62, 0x31, 0x4d, 0xbe,
-0x07, 0x97, 0x0a, 0x7b, 0x46, 0x8a, 0x55, 0xcd, 0xbd, 0x3e, 0x06, 0x39, 0x55, 0x73, 0xac, 0x4d,
-0x2c, 0xc0, 0x35, 0x2c, 0x69, 0x99, 0xad, 0xfd, 0x47, 0x1e, 0xa8, 0xdc, 0x1c, 0xe2, 0x11, 0x1f,
-0x20, 0xe2, 0xda, 0x7d, 0x03, 0x48, 0xf4, 0x82, 0x22, 0xb5, 0x15, 0x21, 0xcc, 0xb2, 0xdb, 0x3a,
-0x8f, 0x30, 0xdf, 0xa6, 0x4d, 0x93, 0x6d, 0xd4, 0xd7, 0xf7, 0x38, 0xda, 0xa6, 0x38, 0x10, 0x81,
-0xdd, 0x70, 0xb0, 0x77, 0xa3, 0x7b, 0x4f, 0x6e, 0xb9, 0x62, 0xf2, 0x98, 0x32, 0x59, 0xd0, 0x4a,
-0xb3, 0x0a, 0x1a, 0x99, 0x0d, 0x4e, 0xd5, 0x06, 0xb0, 0xaa, 0xfe, 0x26, 0x86, 0x4d, 0xb1, 0xaf,
-0xd2, 0x0b, 0xc2, 0xf5, 0xee, 0x90, 0xf0, 0x72, 0xc0, 0x12, 0xe9, 0xa9, 0xdd, 0xc0, 0xe2, 0x77,
-0x4c, 0x74, 0x35, 0xa8, 0x8a, 0xc0, 0x72, 0x90, 0xb6, 0x1d, 0x97, 0xdd, 0xa3, 0x15, 0x7f, 0x5b,
-0x51, 0xe5, 0x35, 0x27, 0x56, 0x84, 0x42, 0x42, 0xc3, 0x8f, 0x8f, 0x86, 0x76, 0x0e, 0xd9, 0xac,
-0xea, 0xa5, 0xe3, 0x35, 0x42, 0x61, 0x4d, 0x74, 0xec, 0x67, 0x3e, 0x63, 0x05, 0x0e, 0xda, 0xcd,
-0xf7, 0x53, 0xe0, 0xa0, 0xd6, 0x16, 0xc1, 0x51, 0x8c, 0x02, 0xbc, 0xeb, 0x2f, 0xb6, 0xee, 0x6b,
-0x5f, 0x68, 0x48, 0x54, 0x5e, 0x0f, 0x97, 0x39, 0x26, 0xd9, 0x0c, 0xd4, 0xa0, 0xc0, 0xd3, 0x6f,
-0x06, 0x2c, 0x55, 0xb6, 0x96, 0x43, 0x8b, 0x70, 0x5c, 0x2e, 0xd1, 0xd7, 0x3e, 0x79, 0x21, 0xe3,
-0x09, 0x2c, 0x41, 0x5f, 0xcc, 0x95, 0xa1, 0x62, 0xcc, 0x28, 0x85, 0x09, 0xf7, 0x66, 0x82, 0x81,
-0xa6, 0x87, 0x22, 0xa1, 0xe5, 0x6b, 0x46, 0xfb, 0xeb, 0x3c, 0xb9, 0x29, 0xab, 0xab, 0x15, 0x96,
-0xa6, 0xb5, 0x34, 0x68, 0xd4, 0x94, 0xc8, 0xb2, 0xc9, 0x37, 0x15, 0x9a, 0xd2, 0xf7, 0xd9, 0xcf,
-0x07, 0x5b, 0xcf, 0xa4, 0x6a, 0x86, 0xcc, 0xfc, 0xf5, 0x10, 0xd1, 0x99, 0x5d, 0xf1, 0x90, 0xba,
-0x6a, 0xe6, 0x31, 0x2e, 0x92, 0xe9, 0x43, 0x7f, 0xf7, 0x83, 0x58, 0x9e, 0x17, 0x8b, 0xb6, 0x26,
-0xcc, 0x86, 0x12, 0x84, 0x74, 0x6c, 0x4c, 0xfb, 0xef, 0xb3, 0x90, 0xd9, 0x52, 0x6f, 0x2c, 0x56,
-0x42, 0x79, 0x52, 0xf6, 0xae, 0x0c, 0x55, 0x71, 0x9f, 0xf3, 0x80, 0xae, 0x97, 0x03, 0x2f, 0xab,
-0xee, 0x70, 0x9d, 0x06, 0x2c, 0x46, 0xca, 0x21, 0x03, 0x08, 0xef, 0x14, 0xdf, 0x77, 0x02, 0x89,
-0xd6, 0x46, 0x40, 0x3d, 0xb5, 0x95, 0xdb, 0x4b, 0x9c, 0x09, 0x23, 0xd4, 0x86, 0xe8, 0xe5, 0x0a,
-0xe1, 0xcc, 0x64, 0xd6, 0x11, 0x50, 0xb6, 0x2c, 0x8c, 0xc1, 0xd8, 0xeb, 0x8b, 0xbd, 0x65, 0x0a,
-0x22, 0x61, 0x0c, 0xe5, 0x16, 0x9a, 0xa6, 0x0f, 0xc3, 0x0d, 0xcf, 0x44, 0xa9, 0xe7, 0x26, 0x80,
-0x00, 0xef, 0x4d, 0x8a, 0xf1, 0x12, 0x73, 0x76, 0x8a, 0xdf, 0xf5, 0xc3, 0x60, 0x85, 0xd3, 0x19,
-0xc0, 0x81, 0x04, 0x92, 0xb1, 0x06, 0x6e, 0x1a, 0xf1, 0x3f, 0x27, 0x9a, 0xd3, 0x37, 0xa1, 0xb7,
-0x98, 0x13, 0x85, 0xa3, 0xc9, 0x51, 0x9a, 0x5e, 0x67, 0x50, 0xb1, 0x44, 0xa7, 0x90, 0xc4, 0x41
+0x75, 0x95, 0xb3, 0x48, 0x38, 0xf9, 0xe4, 0x88, 0xec, 0xf8, 0x3b, 0x09, 0x40, 0xd4, 0xd6, 0xea,
+0xf1, 0x80, 0x6d, 0xfb, 0xba, 0x9e, 0xee, 0xac, 0x6a, 0xf9, 0x8f, 0xb6, 0xe1, 0xff, 0xea, 0x19,
+0x17, 0xc2, 0x77, 0x8d, 0xc2, 0x8d, 0x6c, 0x89, 0xd1, 0x5f, 0xa6, 0xf3, 0x2c, 0xa7, 0x6a, 0x7f,
+0x50, 0x1b, 0xc9, 0x4d, 0xb4, 0x36, 0x64, 0x6e, 0xa6, 0xd9, 0x39, 0x8b, 0xcf, 0x8e, 0x0c, 0x55,
+0x4d, 0xb8, 0xe8, 0xf5, 0xb6, 0x5a, 0xd4, 0x49, 0x63, 0x24, 0xa2, 0xdf, 0xf0, 0x7a, 0x1c, 0x3b,
+0x74, 0x0c, 0x1d, 0x9b, 0xe2, 0x2b, 0x31, 0xb5, 0xe3, 0xca, 0x9f, 0xe4, 0x23, 0xe8, 0x64, 0x83,
+0x1a, 0xf1, 0xaa, 0xbf, 0xd0, 0x6a, 0xd6, 0x43, 0xd1, 0x2d, 0x2b, 0x7f, 0x38, 0x8d, 0x55, 0xd8,
+0xb2, 0xa9, 0x96, 0xec, 0xf5, 0xf9, 0x56, 0x50, 0x65, 0xc8, 0x63, 0x35, 0x22, 0xb0, 0xf4, 0x11,
+0xf3, 0x96, 0x16, 0xc3, 0x55, 0x90, 0xd0, 0x42, 0x3a, 0x5b, 0xc7, 0xfa, 0x67, 0x9b, 0x9f, 0xbd,
+0xca, 0xa5, 0x89, 0xd1, 0xe6, 0xfb, 0xbe, 0x3c, 0x7a, 0x29, 0xcb, 0xd7, 0xd2, 0xaf, 0xfc, 0x2d,
+0x1e, 0xb2, 0x6c, 0x4f, 0x5e, 0x31, 0x67, 0x6f, 0xa9, 0x8e, 0x54, 0x1f, 0xdb, 0x87, 0xd4, 0x11,
+0xa4, 0x99, 0x50, 0xcc, 0x52, 0xd0, 0xfa, 0x43, 0x70, 0x03, 0xa6, 0xff, 0xe0, 0xcb, 0x22, 0xbd,
+0xf3, 0x66, 0xf2, 0x4d, 0x82, 0x13, 0x94, 0x28, 0x89, 0xae, 0x82, 0xdc, 0xa5, 0x3e, 0xf2, 0xd2,
+0x01, 0xda, 0xef, 0xb4, 0x81, 0x77, 0x86, 0x29, 0x35, 0xad, 0xca, 0x14, 0x84, 0xdb, 0x86, 0xbd,
+0x8c, 0xf0, 0x8b, 0xc4, 0x2a, 0xb0, 0x87, 0xd8, 0x0b, 0xcd, 0x2c, 0x32, 0xe1, 0xce, 0xca, 0x15,
+0x82, 0x6e, 0xf5, 0xc8, 0x20, 0x38, 0xa2, 0x60, 0xaf, 0xe1, 0xdc, 0xe7, 0x7b, 0xa4, 0x75, 0x4b,
+0xf2, 0xd1, 0xfb, 0x25, 0x36, 0xbe, 0x84, 0x67, 0x94, 0x06, 0x20, 0xc0, 0x21, 0x30, 0x29, 0xdf,
+0x63, 0xf5, 0x56, 0x3a, 0x07, 0xef, 0x8d, 0xad, 0x62, 0x0f, 0x60, 0xbe, 0xb0, 0x8e, 0x10, 0x27,
+0xc6, 0x46, 0x90, 0xe5, 0x59, 0xaa, 0x16, 0x55, 0xca, 0x68, 0x6c, 0xbf, 0x19, 0x4e, 0xcd, 0xe8,
+0xb4, 0xf8, 0x94, 0xc4, 0x55, 0x9d, 0x7c, 0x3c, 0x06, 0x4e, 0x1a, 0x34, 0x1b, 0x16, 0x80, 0xe4,
+0x56, 0x98, 0xd4, 0xaa, 0xee, 0x66, 0xea, 0x91, 0x71, 0x44, 0xbd, 0xcb, 0xb1, 0xc5, 0x57, 0x49,
+0xa8, 0x4e, 0xe2, 0x03, 0xc6, 0xd5, 0x39, 0xd8, 0x69, 0xa8, 0xa0, 0xad, 0xad, 0x0d, 0x8d, 0xa7,
+0x80, 0xd3, 0xba, 0xc1, 0xae, 0xfe, 0xf5, 0xa2, 0x55, 0x8d, 0xa6, 0x2f, 0xb1, 0x4c, 0x67, 0x3e,
+0xb4, 0xaa, 0xed, 0xab, 0x89, 0xbc, 0xa5, 0x6c, 0x96, 0xe1, 0xc2, 0x27, 0x80, 0x55, 0xe3, 0x1b,
+0x5c, 0x20, 0xad, 0x02, 0x83, 0xa1, 0xc9, 0x51, 0xbd, 0x63, 0xf6, 0x08, 0x64, 0x38, 0x75, 0x7c,
+0x50, 0xd9, 0xae, 0xbb, 0x1b, 0xab, 0x33, 0xd5, 0x61, 0xf1, 0xda, 0xe4, 0x52, 0x6d, 0x97, 0x3c,
+0xdb, 0xec, 0x62, 0x37, 0x5b, 0xe9, 0x84, 0xda, 0x26, 0x26, 0xa2, 0xc2, 0x00, 0x67, 0x50, 0x82,
+0x0c, 0xa2, 0xd4, 0xb0, 0xc9, 0xe7, 0x6e, 0x2a, 0x2a, 0xaa, 0x5a, 0x8a, 0x3c, 0xfa, 0xb8, 0xd6,
+0x95, 0xdf, 0xb5, 0x20, 0x08, 0x65, 0xf4, 0x2f, 0x49, 0x2a, 0xeb, 0x06, 0xd4, 0x1a, 0x3a, 0x3d,
+0xc7, 0xfe, 0xd2, 0x5c, 0xb5, 0x00, 0x14, 0x67, 0x32, 0xb2, 0x17, 0xe2, 0x17, 0x50, 0x97, 0xf0,
+0x11, 0xb5, 0x1a, 0xe4, 0xa9, 0xe1, 0x40, 0x21, 0xbb, 0x75, 0x96, 0xb2, 0xc1, 0x90, 0x8a, 0x66,
+0xfd, 0x2c, 0x1a, 0xa6, 0xc0, 0x4a, 0x53, 0xcb, 0x3e, 0x10, 0x0f, 0x0a, 0x73, 0x3c, 0x6b, 0x4f,
+0xba, 0x14, 0x57, 0xce, 0xc8, 0xb7, 0xd8, 0x33, 0xf1, 0xc4, 0xba, 0x02, 0x13, 0xaa, 0xc6, 0x15,
+0x9e, 0xd6, 0xfd, 0x77, 0x05, 0x81, 0x92, 0x61, 0x3b, 0x35, 0x3f, 0xbd, 0x38, 0x22, 0x2a, 0x5f,
+0xc3, 0x09, 0xc5, 0x73, 0x22, 0x2d, 0x27, 0x8a, 0x42, 0xac, 0x06, 0xe2, 0x8b, 0x9e, 0x3d, 0x73,
+0xfb, 0xf2, 0x71, 0x06, 0x07, 0x26, 0xc7, 0x25, 0xdd, 0x19, 0x7a, 0x54, 0xd8, 0xb8, 0x66, 0x6b,
+0x73, 0xad, 0xc8, 0xa2, 0x24, 0x39, 0x4a, 0xab, 0xdc, 0x5a, 0x6e, 0x32, 0xd9, 0x4a, 0x12, 0xe4,
+0xbd, 0x39, 0xf8, 0x72, 0x6a, 0xdc, 0x46, 0xfb, 0x18, 0x08, 0x01, 0xc5, 0xd3, 0xe7, 0xa2, 0xe9,
+0xf4, 0xe4, 0xcc, 0xaf, 0x91, 0x1c, 0xc7, 0x57, 0xdc, 0x18, 0x53, 0x2a, 0x66, 0xeb, 0x29, 0xf9,
+0xc5, 0x0e, 0x5a, 0x1c, 0x0d, 0xcc, 0xca, 0xb1, 0x67, 0x75, 0xff, 0x91, 0x58, 0x71, 0xff, 0x01,
+0x56, 0xaa, 0x51, 0x75, 0xfc, 0x61, 0x8a, 0x2a, 0x1c, 0xb3, 0x0a, 0x4b, 0x9a, 0xea, 0xe3, 0xc4,
+0x2a, 0x07, 0xd2, 0xce, 0x6d, 0xfc, 0x34, 0xf8, 0xb0, 0xe9, 0xe3, 0x4b, 0x71, 0x1f, 0x5f, 0x0e,
+0xb9, 0x87, 0x25, 0x1c, 0xad, 0x7b, 0x52, 0xa0, 0x56, 0xcf, 0x90, 0xbe, 0x7d, 0xc0, 0x6c, 0x34,
+0x28, 0x49, 0x77, 0xd4, 0x66, 0x12, 0x40, 0xa9, 0xd4, 0x32, 0xbe, 0x10, 0xad, 0x11, 0x73, 0xed,
+0x10, 0x60, 0xc5, 0x76, 0x63, 0xe8, 0x1a, 0x12, 0x26, 0x94, 0xa4, 0xa7, 0xee, 0xc3, 0xd3, 0x47,
+0xb6, 0x2f, 0xa1, 0x18, 0xe5, 0x7a, 0xf4, 0x85, 0x97, 0x1e, 0x09, 0xdf, 0xd6, 0x92, 0xc5, 0x2e,
+0x3e, 0xe5, 0xa9, 0x70, 0x7b, 0x89, 0x91, 0x5b, 0x72, 0x9a, 0x53, 0x5c, 0xdd, 0xb9, 0xd5, 0xe0,
+0xab, 0xb3, 0xc5, 0x14, 0x74, 0xcb, 0x67, 0xdc, 0xbb, 0x7c, 0x98, 0x31, 0xde, 0x2a, 0x61, 0x79,
+0x48, 0xdf, 0xb5, 0x1f, 0xb6, 0x3f, 0xbd, 0x15, 0xc8, 0xdf, 0x69, 0xc1, 0x11, 0xfc, 0xd2, 0xcf,
+0x33, 0xac, 0xe3, 0xdf, 0xc9, 0x26, 0xc7, 0x3c, 0x3d, 0xa8, 0x2b, 0xf1, 0xb7, 0x34, 0x01, 0x9e,
+0x53, 0x5a, 0x98, 0xe7, 0x45, 0x3a, 0x46, 0x90, 0xe1, 0xa3, 0x5f, 0xd3, 0xc4, 0xbc, 0x64, 0xea,
+0x9d, 0x90, 0xcc, 0xfc, 0x35, 0xa3, 0xd1, 0x8b, 0xc1, 0x9b, 0x6f, 0xce, 0xdb, 0xe7, 0x43, 0x3b,
+0x3d, 0x2e, 0xff, 0xc5, 0x81, 0x27, 0x2f, 0xd2, 0x66, 0x85, 0x7c, 0x8c, 0x3d, 0x4f, 0x3d, 0xca,
+0xce, 0x3a, 0xdf, 0xbc, 0xa2, 0x76, 0x3b, 0xe9, 0xc0, 0xf0, 0x22, 0xd8, 0x3c, 0xb8, 0x67, 0x7b,
+0x9b, 0xf1, 0x8d, 0x30, 0x0c, 0x1a, 0xd9, 0xe1, 0xff, 0x85, 0x26, 0xf1, 0xe8, 0x99, 0x92, 0x24,
+0xec, 0xb0, 0x7a, 0x20, 0xe3, 0x36, 0xe0, 0xe7, 0xc6, 0x9d, 0xfe, 0x7e, 0x52, 0x08, 0x00, 0x8c,
+0xc3, 0x8b, 0x8d, 0x3b, 0xf8, 0x07, 0x8c, 0x1e, 0x26, 0xbd, 0x1b, 0x82, 0x80, 0xe4, 0xec, 0x7a,
+0xf5, 0x3b, 0xb6, 0x2a, 0x59, 0xf0, 0x0c, 0x3d, 0x36, 0xaf, 0x8a, 0x59, 0xc1, 0x57, 0xc1, 0x9c,
+0xf1, 0x6e, 0x81, 0x98, 0xc2, 0x18, 0x0a, 0xb8, 0xe3, 0xe8, 0xa6, 0xd6, 0x54, 0x3a, 0xfd, 0xb2,
+0x3e, 0x13, 0x3e, 0xfb, 0xf9, 0x34, 0xc4, 0x8c, 0x6f, 0xbe, 0x11, 0x5b, 0x2d, 0x81, 0x7b, 0x20,
+0xc9, 0xd3, 0xe6, 0x71, 0x3e, 0xae, 0xbf, 0x23, 0x09, 0xa0, 0x87, 0xe7, 0x49, 0x2d, 0xc9, 0x6a,
+0x8d, 0xa3, 0x5e, 0x8e, 0xeb, 0x18, 0x33, 0x3a, 0xf8, 0x00, 0x3d, 0x91, 0xf0, 0x6c, 0x80, 0x38,
+0x3b, 0x0c, 0xa1, 0xb1, 0x17, 0xb1, 0xe0, 0x6d, 0x63, 0x7c, 0xa4, 0xf5, 0x9a, 0x65, 0xc8, 0x3e,
+0x09, 0xc5, 0x57, 0x79, 0x7a, 0x2a, 0x17, 0x8b, 0xbb, 0xe2, 0x75, 0xb8, 0x87, 0x14, 0x7b, 0xc6,
+0x21, 0xa8, 0x9e, 0x31, 0xdc, 0x15, 0xee, 0x43, 0xf6, 0xc0, 0x11, 0x30, 0xa8, 0x45, 0xd3, 0x4b,
+0x61, 0xfe, 0x9a, 0x19, 0xae, 0x01, 0x40, 0xf7, 0x56, 0xcc, 0xc6, 0xa9, 0x35, 0x10, 0xe7, 0x58,
+0xbb, 0x13, 0x79, 0x19, 0x11, 0x47, 0x90, 0xf4, 0xa3, 0x40, 0xf2, 0xa1, 0xe0, 0xd0, 0xb0, 0xe4,
+0xca, 0xf3, 0x03, 0x3a, 0xd5, 0xd9, 0x67, 0xbc, 0x35, 0x6d, 0x74, 0xa0, 0xd2, 0x10, 0x9a, 0x5e,
+0x14, 0x7e, 0xb9, 0x10, 0x17, 0x1c, 0x1d, 0x44, 0x31, 0xe4, 0xcc, 0xa6, 0x95, 0xd2, 0x45, 0x1a,
+0xfc, 0x9a, 0x7c, 0x62, 0xf2, 0xd8, 0xc4, 0x4b, 0x4c, 0x87, 0x13, 0xb7, 0x61, 0xe5, 0x7e, 0xa7,
+0x47, 0xac, 0x97, 0xf0, 0x86, 0x2b, 0xe6, 0x1e, 0x8c, 0xd0, 0x66, 0x86, 0xfa, 0x18, 0x1f, 0x12,
+0xa7, 0x84, 0x6f, 0x0d, 0x66, 0x1e, 0xe5, 0xf3, 0xb8, 0x1b, 0x37, 0xe4, 0x9a, 0x12, 0x81, 0x10,
+0x18, 0xad, 0xdd, 0x9d, 0x5a, 0x4b, 0xce, 0xf5, 0xcb, 0x31, 0x6d, 0x2e, 0xa5, 0x82, 0x40, 0x87,
+0x5c, 0x08, 0x62, 0xc2, 0xc2, 0x5d, 0xea, 0x78, 0x0a, 0xc1, 0x96, 0x99, 0xe5, 0xf4, 0x12, 0x5c,
+0xf1, 0xee, 0x70, 0x59, 0xc6, 0x5e, 0xc5, 0xfa, 0xb3, 0xa3, 0x62, 0x71, 0xd8, 0x22, 0x6a, 0x99,
+0xf9, 0xb7, 0xbe, 0x58, 0x45, 0x9a, 0x5a, 0xc1, 0xa9, 0x3f, 0x99, 0x7a, 0x16, 0x46, 0x52, 0x21,
+0x4b, 0x0c, 0x52, 0xce, 0xa6, 0x6c, 0x44, 0xf7, 0x77, 0xc2, 0x10, 0x11, 0x13, 0xe2, 0x19, 0x2e,
+0x5e, 0xb5, 0x4a, 0x5b, 0xfc, 0x66, 0x9d, 0xe1, 0xd0, 0x9d, 0xde, 0x46, 0xf2, 0xad, 0x35, 0x97,
+0x64, 0xa9, 0x05, 0x0e, 0x3b, 0x0f, 0xf9, 0xc7, 0xe0, 0xcd, 0x3b, 0x8c, 0xff, 0x6b, 0xde, 0xb0,
+0x7f, 0x3e, 0x1f, 0x3f, 0x7b, 0x66, 0xbd, 0x52, 0x40, 0x18, 0xde, 0x91, 0x61, 0xca, 0xae, 0x40,
+0x56, 0x9b, 0x46, 0x5f, 0xd9, 0x2f, 0x13, 0x62, 0x7e, 0x22, 0xec, 0x4b, 0x64, 0x8d, 0x21, 0xa2,
+0xe9, 0x83, 0xbb, 0xec, 0x7f, 0xd9, 0xb4, 0xfb, 0x4f, 0x21, 0x9e, 0xb4, 0x66, 0x15, 0x13, 0x95,
+0x0f, 0x50, 0xb4, 0x9f, 0x77, 0xe8, 0xad, 0x24, 0x0e, 0x00, 0xb3, 0x73, 0x29, 0xd0, 0xc4, 0x25,
+0xf7, 0x91, 0xe6, 0xac, 0xf4, 0x5f, 0x7f, 0xac, 0xd7, 0x68, 0x6b, 0x94, 0xd8, 0x7a, 0xcb, 0xb8,
+0xd8, 0xcb, 0x24, 0x06, 0x88, 0x2e, 0x8e, 0x91, 0xaf, 0xce, 0x6f, 0x36, 0x2f, 0x2d, 0x1a, 0xac,
+0xcc, 0x06, 0xb4, 0x0e, 0x66, 0x6e, 0x79, 0x15, 0xe5, 0xaa, 0x33, 0xeb, 0xb1, 0xe5, 0xa3, 0x62,
+0x7a, 0x76, 0xfc, 0x4a, 0xbd, 0xa2, 0xbe, 0x85, 0x44, 0x6c, 0x31, 0xae, 0x5b, 0xd9, 0x85, 0x5e,
+0xb7, 0x88, 0xdb, 0x29, 0xa1, 0x1e, 0x78, 0x98, 0x56, 0xbf, 0xfb, 0x4c, 0x63, 0xac, 0x96, 0xfb,
+0xa1, 0x18, 0x91, 0xc2, 0x21, 0x90, 0x7c, 0xfa, 0x9d, 0x6d, 0x09, 0xb9, 0xae, 0x9e, 0x90, 0xf3,
+0x33, 0x31, 0x95, 0xa3, 0xf4, 0xc1, 0xfa, 0x89, 0xad, 0x6d, 0x30, 0x1c, 0x42, 0x5b, 0x56, 0x6f,
+0x85, 0x26, 0x6a, 0xf6, 0x95, 0xf6, 0x3c, 0xbc, 0x9b, 0xb1, 0x70, 0x50, 0xeb, 0x9e, 0x40, 0xa2,
+0x97, 0x50, 0x2b, 0x90, 0x7b, 0x38, 0x64, 0xf1, 0xae, 0xa1, 0x23, 0xeb, 0x34, 0x22, 0x1a, 0x97,
+0x9d, 0xdb, 0x48, 0x44, 0x7d, 0x1a, 0x56, 0xfa, 0xdd, 0x18, 0xc9, 0xac, 0xe9, 0x2a, 0x98, 0x97,
+0x48, 0xff, 0x79, 0x66, 0x44, 0xfd, 0x2e, 0xa6, 0x15, 0x0b, 0x51, 0x3e, 0x0a, 0xaf, 0x62, 0x16,
+0x1a, 0x37, 0xab, 0x72, 0xa5, 0xf1, 0x0b, 0xa7, 0x8c, 0x00, 0xf2, 0xaa, 0xd3, 0x34, 0x01, 0xb1,
+0xd0, 0x2c, 0x88, 0xb8, 0x25, 0xd6, 0x62, 0x02, 0x52, 0xa4, 0x4a, 0xa2, 0xb1, 0xe3, 0x07, 0x91,
+0x41, 0x30, 0x55, 0x2f, 0x14, 0x61, 0x29, 0xd0, 0x94, 0x1e, 0x4e, 0xe3, 0x02, 0x39, 0xc9, 0xb1,
+0xfc, 0x43, 0xec, 0x83, 0x28, 0xf1, 0x98, 0x0e, 0xe9, 0x26, 0x79, 0x1c, 0x48, 0xa9, 0x22, 0x21,
+0x4a, 0x82, 0xaf, 0x43, 0x35, 0xf4, 0x9c, 0x39, 0x08, 0x8b, 0x93, 0xb8, 0x42, 0x40, 0x7b, 0x99,
+0x4c, 0xfa, 0x63, 0x90, 0x4e, 0x31, 0x5f, 0x9f, 0x60, 0x60, 0xa7, 0x1b, 0xb8, 0x38, 0x83, 0x63,
+0xb3, 0xe7, 0x2e, 0xcc, 0x1a, 0x21, 0xdd, 0x4b, 0xfb, 0x62, 0x2c, 0x30, 0xae, 0x15, 0x6b, 0xe2,
+0x37, 0x63, 0xc8, 0xa1, 0x16, 0x57, 0x83, 0x14, 0xcc, 0xae, 0xe4, 0x31, 0x1b, 0x06, 0xf7, 0xbe,
+0xf8, 0x56, 0xef, 0xd4, 0x60, 0x9e, 0x68, 0x0c, 0xa0, 0x82, 0x7e, 0x71, 0x87, 0x9e, 0xd2, 0xa7,
+0x5d, 0x86, 0xc6, 0x3d, 0x88, 0x4a, 0xd9, 0x01, 0x1e, 0x44, 0xa1, 0xc0, 0x91, 0x42, 0xd2, 0xfc,
+0xab, 0xf2, 0x7a, 0x94, 0x16, 0xf1, 0x39, 0x50, 0x83, 0x1c, 0x65, 0x9d, 0xc3, 0x26, 0x93, 0xdf,
+0x65, 0x0c, 0xe3, 0x83, 0xb5, 0x7f, 0x72, 0x73, 0xef, 0xd7, 0x62, 0xe9, 0x7f, 0xe2, 0xd1, 0xcc,
+0x9e, 0x77, 0x9f, 0xab, 0x30, 0x26, 0x2a, 0x2c, 0x18, 0xb1, 0x3c, 0x64, 0xcf, 0x54, 0x49, 0x75,
+0xe1, 0xbe, 0x51, 0xdc, 0xaa, 0xdf, 0xeb, 0xc0, 0x41, 0xc7, 0x24, 0x4b, 0xe3, 0xe0, 0xe7, 0xbc,
+0xed, 0x32, 0x15, 0x9f, 0x4b, 0x2f, 0x17, 0xc1, 0xce, 0x39, 0x38, 0x83, 0xcb, 0x97, 0x30, 0x7b,
+0x82, 0x46, 0x65, 0x55, 0x2d, 0xd8, 0x16, 0xa7, 0xd3, 0x33, 0x73, 0x5a, 0xb2, 0xe0, 0xae, 0xfc,
+0x12, 0x8a, 0xf4, 0x56, 0xd9, 0x7b, 0xd2, 0x02, 0xcf, 0x99, 0x37, 0x04, 0x56, 0x90, 0xab, 0x10,
+0x82, 0x3e, 0xcc, 0x2c, 0x8d, 0x53, 0x67, 0x9b, 0x43, 0x59, 0xc0, 0x80, 0xec, 0x18, 0x5e, 0x03,
+0x04, 0x5d, 0x1d, 0x5f, 0xb4, 0x03, 0x8f, 0xc7, 0x38, 0x10, 0x6c, 0xd7, 0xfe, 0x8f, 0x2c, 0xd4,
+0x0a, 0x1e, 0x47, 0x5f, 0x2a, 0x26, 0xd3, 0x4b, 0x3e, 0x46, 0x87, 0xd4, 0x94, 0xba, 0xe8, 0x19,
+0x89, 0x90, 0x70, 0x90, 0xa0, 0xee, 0x8d, 0x74, 0x87, 0x1c, 0x35, 0x6b, 0x48, 0x94, 0x3d, 0x80,
+0x4c, 0x8c, 0x84, 0x35, 0x86, 0x97, 0xb4, 0xe2, 0xae, 0x4c, 0xae, 0x30, 0xcf, 0x6e, 0x34, 0xa5,
+0xbb, 0xa5, 0xf5, 0xdd, 0x7e, 0xe8, 0xea, 0x37, 0x54, 0xe2, 0xc3, 0x91, 0x03, 0xcb, 0x8c, 0x4b,
+0x23, 0x73, 0x63, 0x5b, 0x35, 0x63, 0x5b, 0x89, 0xbb, 0x01, 0xce, 0x8d, 0x73, 0xa3, 0x4f, 0x89,
+0x76, 0x15, 0x5d, 0x50, 0x26, 0x01, 0x8c, 0x7b, 0x23, 0x6b, 0x84, 0xa6, 0x60, 0x44, 0x2a, 0x0b,
+0x33, 0x8f, 0x00, 0xad, 0x0e, 0x05, 0x75, 0x41, 0xae, 0x96, 0x1b, 0x2d, 0x0b, 0xe9, 0xdb, 0xba,
+0xbe, 0xe0, 0xc5, 0x65, 0x35, 0x02, 0xf2, 0x04, 0x6c, 0x3f, 0x81, 0xe0, 0x0c, 0x2c, 0xd7, 0xde,
+0xc8, 0xb2, 0x6c, 0x5d, 0x1e, 0x9b, 0xe0, 0x65, 0x1e, 0x13, 0xd8, 0x6a, 0x92, 0xa7, 0x59, 0x14,
+0x78, 0x92, 0xb7, 0x11, 0x06, 0xea, 0xc2, 0x8d, 0x61, 0x82, 0x5d, 0xfe, 0x18, 0x66, 0x02, 0x8e,
+0x7a, 0x09, 0x7f, 0xdc, 0x7e, 0xca, 0xa7, 0x76, 0x99, 0x50, 0x25, 0xf6, 0x7e, 0x30, 0xaa, 0xf7,
+0x82, 0xae, 0xfa, 0xe3, 0xdf, 0x56, 0xa9, 0xab, 0xa4, 0xa3, 0x2c, 0x4d, 0x02, 0x4c, 0x38, 0x02,
+0x2d, 0x7f, 0x37, 0x54, 0xca, 0x3f, 0x6e, 0x7b, 0x0e, 0xb2, 0xa5, 0x68, 0x76, 0x98, 0x85, 0xd4,
+0x83, 0x5b, 0x26, 0xb3, 0xcd, 0xe9, 0x0c, 0xdf, 0xa5, 0x35, 0x4d, 0xd8, 0x5c, 0x59, 0x53, 0xe8,
+0x81, 0xf0, 0x33, 0xc9, 0xc9, 0xef, 0x84, 0xf6, 0x5c, 0xf8, 0x6e, 0x32, 0xe7, 0x20, 0x94, 0x79
 
 cipher_key =
 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
@@ -290,214 +290,213 @@ iv =
 ####################
 [sha1_hmac_buff_32]
 digest =
-0x8C, 0xD8, 0x0F, 0x6F, 0x32, 0xED, 0x11, 0xFF, 0x3B, 0xC3, 0x1C, 0xA7, 0x62, 0xE2, 0x2B, 0xCB,
-0x87, 0x65, 0x58, 0x92
+0xAD, 0x0F, 0xE8, 0xAD, 0x30, 0xD6, 0x0A, 0x2B, 0x6B, 0x3D, 0x24, 0x79, 0x6D, 0xB6, 0x80, 0x43,
+0x1D, 0xD1, 0x8A, 0xA8
 
 [sha224_hmac_buff_32]
 digest =
-0x2A, 0x97, 0xC8, 0xF8, 0x95, 0xAB, 0x35, 0x88, 0x88, 0x0F, 0x9B, 0x06, 0xEC ,0xE9, 0x27, 0xA3,
-0x17, 0x99, 0x28, 0xF8, 0xDF, 0xB4, 0xE1, 0x4E, 0x47, 0x0B, 0xDE, 0x8D
+0xB4, 0x1C, 0xF4, 0x73, 0x04, 0x62, 0x2D, 0xAF, 0x59, 0x05, 0xE8, 0x55, 0xE4, 0x8B, 0x24, 0xB4,
+0x0F, 0x4C, 0x3D, 0xBE, 0xFF, 0xFF, 0x8D, 0x19, 0x0D, 0x38, 0xA1, 0xFC
 
 [sha256_hmac_buff_32]
 digest =
-0x5C, 0x92, 0xD1, 0x03, 0x49, 0xA5, 0x20, 0x3E, 0x1B, 0x88, 0x6A, 0x30, 0xFB, 0x45, 0x1A, 0x4D,
-0xF7, 0xF2, 0xD0, 0x78, 0x20, 0x61, 0x7C, 0xD6, 0x4E, 0x0E, 0x7B, 0x3B, 0x35, 0xFE, 0xD8, 0x9A
+0x77, 0x54, 0x8D, 0x73, 0x7D, 0xB9, 0x78, 0x2F, 0x3D, 0xEE, 0xA2, 0xE7, 0xC9, 0x03, 0xF3, 0xB0,
+0x17, 0x8E, 0x71, 0x81, 0xB7, 0xA7, 0x5F, 0x9F, 0xF3, 0xED, 0x55, 0x1A, 0x69, 0x68, 0x52, 0xE5
 
 [sha384_hmac_buff_32]
 digest =
-0x8A, 0x39, 0x0D, 0x1C, 0x0C, 0x4A, 0x3C, 0x25, 0xA7, 0x43, 0x2C, 0x26, 0xF3, 0xCF, 0xB4, 0x92,
-0x41, 0x9C, 0x2C, 0xE2, 0x63, 0x40, 0x0B, 0x91, 0xD8, 0xB6, 0x30, 0xE4, 0x9F, 0x96, 0xDE, 0x3C,
-0xED, 0x66, 0x8B, 0x65, 0x5A, 0xA3, 0xB8, 0xD4, 0x01, 0xB3, 0xBC, 0xAA, 0x08, 0x92, 0x5C, 0x2F
+0x1A, 0x3D, 0x1A, 0xD8, 0x0C, 0x04, 0x4B, 0x14, 0x9F, 0xF6, 0x9B, 0x80, 0x5C, 0xA2, 0x78, 0xFC,
+0xE6, 0xA3, 0xBA, 0x32, 0x09, 0x04, 0x52, 0x24, 0x76, 0xC9, 0xFC, 0x70, 0xA6, 0x00, 0xB4, 0x41,
+0xA1, 0x48, 0x1D, 0xCC, 0x54, 0x59, 0xE6, 0x94, 0x35, 0x36, 0xCC, 0xAB, 0x4B, 0xF5, 0xE4, 0xCA
 
 [sha512_hmac_buff_32]
 digest =
-0x1E, 0x27, 0xE8, 0xBD, 0xDA, 0x56, 0xC0, 0x5D, 0x04, 0xA0, 0xFC, 0x21, 0xCF, 0x52, 0x07, 0x45,
-0x28, 0xAD, 0x33, 0xC4, 0x3C, 0x07, 0x0B, 0x6B, 0xC9, 0x90, 0x2B, 0xE5, 0xCA, 0x11, 0x7C, 0x86,
-0x95, 0xF4, 0xC4, 0x56, 0xAC, 0x86, 0x0D, 0xF0, 0x62, 0xB8, 0x6C, 0xFC, 0x88, 0xC6, 0xBA, 0xF7,
-0x35, 0xDD, 0xB6, 0x2E, 0x34, 0x09, 0x27, 0x93, 0xB0, 0xF3, 0x0B, 0x7D, 0x9F, 0x74, 0x2D, 0x4F
+0xED, 0xD7, 0x96, 0x0B, 0xC4, 0x8F, 0xBF, 0xF3, 0xEA, 0x7D, 0x5D, 0x57, 0x2A, 0x50, 0x50, 0xAC,
+0x33, 0xF2, 0xED, 0x56, 0x0A, 0xF7, 0x97, 0x4A, 0x36, 0x8D, 0x3B, 0xA5, 0x9F, 0x7A, 0x6D, 0x57,
+0xE0, 0x94, 0x10, 0xB9, 0x15, 0xC6, 0x1B, 0x7F, 0x17, 0xB3, 0x48, 0xB5, 0xF9, 0x93, 0xD8, 0xCA,
+0x74, 0x56, 0xED, 0xBD, 0x55, 0x14, 0xD2, 0xB6, 0x36, 0x07, 0x06, 0x73, 0x66, 0x41, 0x50, 0x84
 
 ####################
 # sha_hmac_buff_64 #
 ####################
 [sha1_hmac_buff_64]
 digest =
-0xAC, 0xD8, 0x84, 0x6B, 0x21, 0x20, 0xFE, 0x7D, 0x60, 0xA9, 0x6C, 0x0D, 0x64, 0xF9, 0x27, 0x5D,
-0x2F, 0xE9, 0xDF, 0x94
+0xC9, 0xC3, 0x65, 0x23, 0xCE, 0x9D, 0x6E, 0x35, 0xDC, 0x65, 0x3B, 0x21, 0x33, 0xFF, 0x1E, 0x74,
+0xAF, 0x48, 0x24, 0xD9
 
 [sha224_hmac_buff_64]
 digest =
-0xB2, 0x30, 0xEC, 0xC5, 0x3A, 0xA5, 0x77, 0x30, 0xDE, 0x64, 0xCE, 0x6D, 0x23, 0xF1, 0x07, 0xBF,
-0x96, 0x2A, 0xFE, 0x3A, 0xFD, 0xA1, 0x97, 0x3E, 0x73, 0x17, 0x42, 0x0B
+0x9F, 0xC3, 0x34, 0x0F, 0xB0, 0xA5, 0x4D, 0x89, 0xA4, 0x20, 0x01, 0xDF, 0x40, 0xAE, 0xA2, 0x41,
+0x4E, 0x97, 0x38, 0xBA, 0xA7, 0xF9, 0x94, 0x1F, 0x56, 0x4E, 0x00, 0x0A
 
 [sha256_hmac_buff_64]
 digest =
-0xB9, 0x48, 0x3B, 0x99, 0x56, 0x93, 0x0A, 0x4E, 0x11, 0xC8, 0x6D, 0x51, 0x56, 0xD6, 0xFB, 0xC4,
-0x2D, 0x36, 0x0C, 0x3B, 0x18, 0xF6, 0x3E, 0xF8, 0xD2, 0x5D, 0xA5, 0x9F, 0xFB, 0xE8, 0x58, 0x93
+0x66, 0x52, 0xF3, 0xEB, 0xC7, 0x06, 0xEF, 0x21, 0x82, 0x7C, 0xCF, 0x7F, 0x5B, 0x6B, 0x77, 0x2F,
+0x28, 0x61, 0x06, 0x2B, 0x67, 0x4B, 0x2D, 0x62, 0x71, 0x53, 0xBE, 0x12, 0xF9, 0x5B, 0xD8, 0x64
 
 [sha384_hmac_buff_64]
 digest =
-0x76, 0x45, 0x45, 0xB5, 0xE5, 0xDE, 0xC2, 0x7B, 0x01, 0xAA, 0x58, 0xB7, 0xD2, 0xCA, 0x0B, 0x6A,
-0xA1, 0x4E, 0x0D, 0xCC, 0xCF, 0x22, 0x9D, 0xBA, 0xA1, 0x6C, 0x54, 0x1A, 0x3B, 0x8B, 0xD9, 0x6F,
-0xB5, 0xA9, 0xC2, 0x80, 0xBF, 0x6C, 0xED, 0xED, 0xA1, 0xB0, 0x15, 0xA6, 0x91, 0x5A, 0xDD, 0x3F
+0x63, 0x50, 0x09, 0x45, 0x87, 0x02, 0x7F, 0x85, 0xD3, 0xC8, 0xF2, 0x26, 0x01, 0xE8, 0x2C, 0x28,
+0xB4, 0x86, 0x5A, 0x8E, 0x8E, 0x95, 0x27, 0x6A, 0x74, 0xF0, 0x29, 0xC2, 0x2D, 0x13, 0x91, 0xD5,
+0x38, 0xDB, 0x06, 0x7E, 0xB4, 0x8C, 0xD6, 0x30, 0x54, 0x86, 0xE7, 0xBB, 0x5C, 0xB6, 0xDD, 0x90
 
 [sha512_hmac_buff_64]
 digest =
-0xED, 0xD9, 0xCA, 0xFE, 0x44, 0x12, 0x8F, 0xF1, 0xCD, 0x91, 0x58, 0x2A, 0x4D, 0xC7, 0x77, 0x50,
-0xD1, 0xBD, 0x9D, 0x33, 0xE3, 0x3A, 0xEA, 0xE1, 0x64, 0x18, 0x48, 0xE9, 0xF0, 0xEC, 0xE0, 0x0F,
-0x13, 0xFD, 0xB9, 0xB2, 0xCF, 0xBC, 0x43, 0x07, 0x66, 0x6E, 0x76, 0x18, 0x27, 0x0D, 0x15, 0x50,
-0x8A, 0x1C, 0x88, 0x8C, 0xC9, 0xDA, 0xD8, 0x30, 0x09, 0xE7, 0xD5, 0x25, 0xB8, 0x09, 0xFF, 0x20
-
+0xBE, 0x52, 0xBF, 0x69, 0x2B, 0x7F, 0xD5, 0x37, 0x48, 0x76, 0xCF, 0xBD, 0x23, 0x18, 0x45, 0x90,
+0x74, 0x25, 0x07, 0x91, 0x13, 0x37, 0xF3, 0x26, 0xEE, 0x68, 0xEC, 0xFC, 0xCB, 0x60, 0x53, 0x96,
+0x54, 0xF6, 0xE8, 0xAC, 0xF7, 0xB1, 0x52, 0x31, 0x7E, 0x5D, 0x99, 0xF3, 0x86, 0xF2, 0x98, 0x7D,
+0xD4, 0x38, 0xD9, 0xF1, 0x4C, 0x08, 0x87, 0x7F, 0xB9, 0x17, 0x97, 0x39, 0xDB, 0x68, 0x39, 0x19
 #####################
 # sha_hmac_buff_128 #
 #####################
 [sha1_hmac_buff_128]
 digest =
-0x09, 0x94, 0x8F, 0xD2, 0xE9, 0x08, 0x5B, 0x76, 0xAC, 0xCB, 0x07, 0x60, 0xE7, 0x41, 0xBD, 0x6C,
-0x91, 0x9E, 0xF4, 0x87
+0xB0, 0x6F, 0x7D, 0xB3, 0x29, 0xC3, 0x2B, 0x5D, 0xB7, 0xF1, 0x13, 0xFB, 0x9E, 0x90, 0x5D, 0xF1,
+0x48, 0xBC, 0x71, 0xA4
 
 [sha224_hmac_buff_128]
 digest =
-0x3A, 0x85, 0x01, 0x4C, 0xF7, 0xA8, 0xB0, 0xF7, 0x74, 0xAB, 0xB0, 0x89, 0x83, 0x2C, 0x3A, 0xA1,
-0x28, 0x87, 0xD7, 0xAB, 0xCF, 0x14, 0xE0, 0x73, 0xFB, 0x19, 0x85, 0xEF
+0xFC, 0x59, 0xAF, 0xF2, 0x83, 0x2E, 0x07, 0x08, 0xBF, 0xB4, 0x3C, 0x24, 0xA8, 0x52, 0x7B, 0x9E,
+0x92, 0x83, 0xCE, 0x96, 0xEE, 0x8B, 0x65, 0x72, 0x00, 0x12, 0xC6, 0x98
 
 [sha256_hmac_buff_128]
 digest =
-0x7F, 0x79, 0xE4, 0x17, 0x6E, 0xE5, 0x78, 0xA0, 0x26, 0x65, 0x62, 0x7D, 0xB5, 0x69, 0x62, 0xC0,
-0x7B, 0x5C, 0xBA, 0x55, 0x06, 0xAD, 0x3D, 0xDE, 0xAA, 0xA7, 0xED, 0x82, 0x3A, 0xBD, 0xBA, 0xFB
+0x7E, 0xCA, 0x95, 0xD5, 0x63, 0xA8, 0xCA, 0xA6, 0xC5, 0x41, 0x75, 0x12, 0x60, 0xDF, 0xFE, 0x16,
+0x70, 0xEB, 0xCC, 0x4E, 0xEB, 0x00, 0x86, 0xF0, 0xEC, 0x45, 0x44, 0x76, 0x62, 0x55, 0x48, 0x56
 
 [sha384_hmac_buff_128]
 digest =
-0xEC, 0x68, 0xCB, 0x8E, 0x90, 0xCF, 0x8D, 0x04, 0xAF, 0x1F, 0x4C, 0x0B, 0xE9, 0x9B, 0x03, 0x05,
-0x19, 0x54, 0x4D, 0x28, 0x02, 0x8B, 0x19, 0x39, 0x1D, 0x59, 0xEF, 0x9C, 0xA1, 0xA5, 0x06, 0x89,
-0x7B, 0x81, 0xDB, 0xD2, 0xAC, 0x21, 0x79, 0xFF, 0xE9, 0x5A, 0x8A, 0xEE, 0x28, 0x12, 0x8D, 0xB1
+0x1B, 0x2A, 0xAA, 0x7F, 0x2E, 0x58, 0x1F, 0x64, 0xB4, 0xE6, 0x29, 0xE4, 0x74, 0x78, 0x09, 0xD7,
+0xBA, 0xDD, 0x18, 0xB6, 0xE4, 0x21, 0xF5, 0x8F, 0x40, 0x45, 0x65, 0xD1, 0xBE, 0x4F, 0x7B, 0x27,
+0xF4, 0x64, 0x72, 0x55, 0x53, 0xAB, 0x39, 0x05, 0x7A, 0x6D, 0xAA, 0x12, 0x75, 0x03, 0x67, 0x4E
 
 [sha512_hmac_buff_128]
 digest =
-0x98, 0xED, 0x87, 0x00, 0x0B, 0x2E, 0x5C, 0xFA, 0x56, 0x94, 0x86, 0x96, 0x6A, 0x45, 0x99, 0xC4,
-0xD8, 0x7E, 0x69, 0x6E, 0xD0, 0x47, 0x01, 0xA9, 0x03, 0xBE, 0x8A, 0x77, 0xDB, 0x19, 0x29, 0xFA,
-0xB8, 0xBF, 0x7E, 0x3B, 0xB1, 0x0F, 0xF8, 0xED, 0x63, 0xD4, 0x9B, 0x6F, 0xE5, 0xD6, 0xE3, 0xED,
-0x2B, 0x89, 0xB2, 0xBD, 0xF7, 0x36, 0x9C, 0xE8, 0x02, 0x88, 0x42, 0x4A, 0x15, 0x24, 0xBB, 0xAB
+0x5F, 0x8F, 0xA8, 0xFA, 0xEA, 0x05, 0x29, 0xBD, 0x3B, 0xBA, 0xF6, 0xA7, 0x93, 0x9E, 0x16, 0xF1,
+0x8B, 0x10, 0x2F, 0x6D, 0x08, 0x18, 0x54, 0xD2, 0x39, 0xEB, 0xF9, 0x70, 0xCC, 0x55, 0xA0, 0xC3,
+0x08, 0x9B, 0x8E, 0x55, 0x81, 0x1A, 0xCE, 0x0D, 0x09, 0x97, 0x4E, 0x34, 0xD1, 0xE6, 0x25, 0x05,
+0x94, 0xC7, 0x05, 0x30, 0xAF, 0x2F, 0x7F, 0x54, 0xAA, 0xB8, 0xC5, 0x8E, 0x3D, 0xBB, 0xF2, 0x12
 
 #####################
 # sha_hmac_buff_256 #
 #####################
 [sha1_hmac_buff_256]
 digest =
-0x1E, 0x7E, 0x38, 0x4E, 0x76, 0x38, 0x75, 0xFE, 0x02, 0xAB, 0x1C, 0xA2, 0xAE, 0xBC, 0x4B, 0x57,
-0x16, 0xB2, 0xB2, 0x4D
+0xF9, 0xCA, 0x12, 0x7D, 0x60, 0x68, 0xB7, 0xAF, 0xDC, 0xAC, 0x41, 0x13, 0x1C, 0xA8, 0xC1, 0x85,
+0x65, 0x11, 0x31, 0x4C
 
 [sha224_hmac_buff_256]
 digest =
-0x49, 0xDA, 0x8E, 0xFB, 0xCD, 0xDF, 0xB8, 0x17, 0x3E, 0xF7, 0xF2, 0x73, 0x03, 0x23, 0x1F, 0x57,
-0x7C, 0x50, 0x89, 0x24, 0x56, 0xF0, 0x54, 0x5D, 0x6A, 0x30, 0xE1, 0x44
+0x49, 0xED, 0xA4, 0x27, 0x51, 0x6A, 0x46, 0xE4, 0x31, 0x12, 0x72, 0x92, 0xB8, 0x81, 0x16, 0x97,
+0x19, 0x4F, 0x3B, 0xAC, 0xD1, 0xCE, 0x06, 0x40, 0xD4, 0xEA, 0x8E, 0xC3
 
 [sha256_hmac_buff_256]
 digest =
-0xAB, 0x6D, 0xBF, 0x17, 0x2B, 0xE0, 0xD5, 0xF1, 0xB3, 0xC3, 0x25, 0xFA, 0x99, 0xEF, 0x38, 0x91,
-0x12, 0x3B, 0xDE, 0xD7, 0x48, 0xA3, 0x69, 0x2E, 0xAD, 0xA8, 0xAD, 0x08, 0x42, 0xBC, 0x78, 0xE3
+0xB9, 0xFB, 0x21, 0x16, 0x0C, 0x08, 0xD1, 0xE0, 0x49, 0xB8, 0xC8, 0x7E, 0xCC, 0xF0, 0xBA, 0x29,
+0x32, 0xCE, 0x53, 0x03, 0xE8, 0xFB, 0xD2, 0x44, 0xB7, 0xB9, 0xFE, 0xE8, 0x03, 0x86, 0xE2, 0x68
 
 [sha384_hmac_buff_256]
 digest =
-0x4C, 0xF8, 0x22, 0x1B, 0x10, 0xBE, 0xD2, 0xEA, 0xBF, 0x27, 0x7C, 0x11, 0xBC, 0x53, 0x8B, 0xC1,
-0x3B, 0x13, 0xC9, 0xE0, 0xAA, 0x7E, 0x41, 0x17, 0xD0, 0x2C, 0x15, 0x6D, 0x23, 0x2E, 0x4E, 0xA0,
-0x44, 0x45, 0xBC, 0x7E, 0xD3, 0x6D, 0x68, 0xA1, 0xDD, 0xD5, 0xA7, 0x0B, 0x0E, 0x5A, 0x21, 0x41
+0x47, 0xEA, 0x51, 0xA7, 0xAD, 0xA2, 0x34, 0x3D, 0x4A, 0x3A, 0x86, 0x89, 0x78, 0x56, 0xCF, 0x21,
+0x94, 0xBF, 0x80, 0x33, 0x6B, 0x42, 0x73, 0x01, 0xAD, 0x6B, 0xE0, 0xEC, 0x10, 0xEE, 0x6E, 0xEC,
+0xED, 0x54, 0x50, 0x5E, 0x96, 0x3B, 0xE8, 0x2A, 0x8C, 0x33, 0x67, 0x9B, 0x17, 0x6C, 0xBB, 0xF8
 
 [sha512_hmac_buff_256]
 digest =
-0x25, 0x03, 0x50, 0xD1, 0x7C, 0x35, 0x33, 0x5C, 0xB5, 0x08, 0xBA, 0xFA, 0x9A, 0x86, 0x8E, 0x95,
-0x67, 0x62, 0xCB, 0x02, 0xEE, 0x3A, 0x1A, 0xD0, 0x0D, 0xD0, 0x3A, 0x79, 0xC9, 0x01, 0x1B, 0x78,
-0xF2, 0xCA, 0x57, 0xA5, 0x3C, 0x1B, 0x44, 0xFA, 0xC0, 0xEF, 0xF7, 0x68, 0xF3, 0xE3, 0x75, 0xFB,
-0x85, 0xFF, 0xD0, 0x8A, 0xE3, 0x43, 0xBE, 0x98, 0x1C, 0xCF, 0xBA, 0x01, 0x84, 0x30, 0xC3, 0xE9
+0x01, 0xAE, 0xE7, 0x74, 0xCD, 0x86, 0x43, 0xBC, 0x8A, 0xF6, 0xAF, 0x6C, 0xDE, 0x9E, 0x9A, 0xB7,
+0x6B, 0xCF, 0x98, 0x95, 0x31, 0xE8, 0x37, 0x3B, 0x3F, 0xF3, 0xC1, 0x00, 0xA0, 0xA6, 0xE5, 0x15,
+0x60, 0x36, 0x7E, 0x7C, 0x96, 0xAB, 0x17, 0xB9, 0x79, 0x3D, 0x3E, 0x43, 0xBC, 0xA0, 0xA0, 0x8B,
+0x14, 0x14, 0x22, 0x86, 0xE9, 0xF6, 0x96, 0x38, 0x9F, 0x24, 0x45, 0x9C, 0xE8, 0x63, 0x2A, 0x22
 
 #####################
 # sha_hmac_buff_512 #
 #####################
 [sha1_hmac_buff_512]
 digest =
-0x55, 0x80, 0xC9, 0x15, 0xF4, 0x5D, 0x67, 0xF1, 0xDE, 0x07, 0xF2, 0x91, 0x88, 0x59, 0x95, 0x34,
-0x3A, 0xF5, 0x01, 0x61
+0x45, 0x8D, 0x5B, 0x40, 0x0D, 0x34, 0x3A, 0x7B, 0xB2, 0xB1, 0xE7, 0x62, 0xDE, 0x2B, 0xD0, 0x46,
+0xCD, 0x4B, 0x55, 0x95
 
 [sha224_hmac_buff_512]
 digest =
-0x98, 0x3D, 0x26, 0x3C, 0x62, 0x20, 0x69, 0x12, 0x0A, 0x01, 0x9B, 0x83, 0xC4, 0xD3, 0xE7, 0xAE,
-0xAD, 0xF3, 0x80, 0x35, 0xC7, 0x2A, 0xD7, 0x9B, 0xA9, 0x59, 0x6F, 0x23
+0xE1, 0x82, 0x07, 0x4F, 0x6B, 0x24, 0x4A, 0x57, 0xE9, 0x04, 0x14, 0xB1, 0x7F, 0xD2, 0x4C, 0xA0,
+0x89, 0x8B, 0xB2, 0xA2, 0x28, 0x9F, 0xFE, 0x7C, 0xD1, 0x7F, 0x35, 0x07
 
 [sha256_hmac_buff_512]
 digest =
-0x3B, 0xD9, 0x0C, 0x74, 0x2F, 0x3B, 0xBA, 0xCA, 0x05, 0xA9, 0x17, 0x87, 0xB5, 0x38, 0x68, 0x63,
-0xC6, 0x0D, 0x3B, 0xFA, 0x32, 0x10, 0x29, 0x60, 0xDB, 0x2E, 0xBA, 0x73, 0x5D, 0xF3, 0x8F, 0x9F
+0xB9, 0x75, 0x4F, 0x70, 0xC7, 0x8C, 0xF2, 0x62, 0x89, 0x3C, 0x41, 0x4D, 0x1D, 0x15, 0x81, 0x2A,
+0x5A, 0xCB, 0x56, 0x62, 0xF8, 0xE9, 0x38, 0x13, 0xC9, 0x4D, 0xC3, 0x9D, 0xF0, 0x82, 0xAC, 0xD2
 
 [sha384_hmac_buff_512]
 digest =
-0xE9, 0xA4, 0x1A, 0x3B, 0xE1, 0xDD, 0xD8, 0x47, 0x21, 0xDC, 0xEB, 0xB9, 0x22, 0xAA, 0x45, 0xD2,
-0x61, 0x47, 0x63, 0x88, 0x13, 0x6E, 0x1E, 0x8A, 0x7D, 0x37, 0xE0, 0x21, 0xC0, 0x08, 0x66, 0xE7,
-0x84, 0xCA, 0x7A, 0x09, 0x87, 0x84, 0x07, 0xCF, 0x8A, 0x22, 0x41, 0x68, 0x0E, 0x48, 0x11, 0x2A
+0x9C, 0xAE, 0x77, 0x8D, 0x7E, 0x26, 0x01, 0xA6, 0x46, 0x47, 0xDF, 0xB7, 0x23, 0x6F, 0x17, 0x6B,
+0x9F, 0x4D, 0x94, 0xBB, 0x78, 0xD8, 0x2D, 0x90, 0xB1, 0xC1, 0x65, 0x6D, 0x92, 0x4E, 0x54, 0x7A,
+0xA5, 0xF6, 0x80, 0x29, 0x82, 0x77, 0xAC, 0xC3, 0x58, 0xE5, 0x14, 0x75, 0x64, 0x9D, 0x02, 0x6E
 
 [sha512_hmac_buff_512]
 digest =
-0xD5, 0x41, 0x0A, 0x48, 0x68, 0x9B, 0xC1, 0x86, 0x16, 0x1A, 0x5D, 0x9E, 0x0E, 0x62, 0x0F, 0xB1,
-0xEE, 0x03, 0xE1, 0x23, 0xFE, 0xF0, 0x0F, 0x3F, 0xB0, 0xE1, 0x9C, 0xBC, 0x3E, 0x6D, 0x28, 0xD6,
-0x59, 0xB6, 0xC6, 0x17, 0x75, 0xD0, 0x2E, 0x7C, 0x1E, 0xCA, 0x40, 0x23, 0x16, 0x93, 0x94, 0xAC,
-0xD2, 0xDD, 0x5B, 0xB5, 0xAB, 0x69, 0x70, 0x84, 0xAB, 0xCF, 0x71, 0x53, 0x45, 0xFC, 0x01, 0x23
+0x33, 0xB6, 0xD1, 0xC4, 0x5F, 0xDB, 0xEF, 0xF4, 0x14, 0xE8, 0xDA, 0x07, 0x30, 0xB6, 0xC6, 0xC9,
+0x4F, 0xCF, 0x64, 0x48, 0x08, 0xA2, 0xC1, 0x9D, 0x03, 0xAD, 0x93, 0x62, 0x41, 0xB6, 0xB9, 0xEC,
+0x1B, 0xD1, 0xAC, 0xA1, 0xC5, 0x94, 0x67, 0x19, 0xA3, 0x4B, 0x53, 0xCE, 0x0C, 0x8A, 0x27, 0x07,
+0x37, 0x75, 0x93, 0xC3, 0xC6, 0x60, 0x19, 0x39, 0x9E, 0x02, 0x23, 0x9A, 0xE6, 0xA9, 0x34, 0x1A
 
 ######################
 # sha_hmac_buff_1024 #
 ######################
 [sha1_hmac_buff_1024]
 digest =
-0x77, 0x5E, 0xFB, 0x4C, 0x35, 0x03, 0x85, 0x7D, 0xBA, 0xBE, 0x9D, 0xD5, 0xD7, 0xC3, 0x62, 0xFB,
-0xC0, 0x11, 0x54, 0xF9
+0x0B, 0x26, 0x34, 0xAD, 0x56, 0x44, 0x39, 0x4A, 0x0D, 0x2F, 0x14, 0xFB, 0x60, 0x77, 0xDD, 0xFC,
+0x0B, 0x5F, 0x9F, 0x99
 
 [sha224_hmac_buff_1024]
 digest =
-0x1D, 0xC5, 0xAB, 0xE5, 0xEA, 0xAD, 0x5C, 0x72, 0xB3, 0x3D, 0xF4, 0x21, 0x69, 0x1E, 0x9C, 0xBC,
-0xE1, 0x86, 0x91, 0x80, 0x7D, 0x52, 0x6E, 0x31, 0x14, 0xAE, 0x8A, 0xB7
+0x56, 0x41, 0xC2, 0xF0, 0x73, 0x5C, 0x21, 0x13, 0x7E, 0x47, 0xCC, 0xAB, 0x21, 0x3D, 0x5E, 0xA7,
+0xC6, 0x1E, 0xFF, 0x26, 0x59, 0x0C, 0x71, 0x95, 0x72, 0x76, 0x0D, 0x00
 
 [sha256_hmac_buff_1024]
 digest =
-0x74, 0xC9, 0x7C, 0x21, 0xF8, 0xCC, 0x4C, 0xCB, 0xD6, 0xC3, 0xED, 0xA5, 0xF4, 0xAE, 0x75, 0x5F,
-0xE7, 0xAA, 0x49, 0x2E, 0x63, 0x7D, 0xF3, 0xD6, 0x9E, 0x46, 0x6F, 0x8A, 0x5C, 0x4B, 0xDF, 0x51
+0x08, 0x91, 0x23, 0x89, 0x0F, 0xB0, 0xE4, 0x25, 0x9F, 0xC7, 0x46, 0x6B, 0xC3, 0x39, 0xE0, 0x9C,
+0xE2, 0xAE, 0xA3, 0xCF, 0xB8, 0xA0, 0x0A, 0xCF, 0x29, 0xEE, 0x0D, 0x83, 0x8A, 0xE5, 0xE4, 0x85
 
 [sha384_hmac_buff_1024]
 digest =
-0x6A, 0xCB, 0xD7, 0x77, 0xC1, 0xC8, 0xF5, 0xF3, 0x4C, 0x6A, 0xF5, 0xFC, 0xD0, 0xC2, 0x68, 0xF1,
-0x45, 0x3C, 0xBA, 0xFF, 0x83, 0x98, 0xB4, 0x0A, 0x29, 0x97, 0x27, 0xE8, 0x74, 0x2B, 0x66, 0xC0,
-0x5B, 0x45, 0x70, 0xA0, 0x8E, 0xD5, 0x16, 0x88, 0x0D, 0xB9, 0xBA, 0x3A, 0x70, 0x3F, 0x4B, 0xD0
+0x38, 0xC7, 0x19, 0xA4, 0x46, 0x14, 0x79, 0xA4, 0xAB, 0x40, 0x61, 0xBC, 0xFB, 0x87, 0x16, 0xE2,
+0x08, 0x90, 0xAD, 0x33, 0x5D, 0x37, 0xB6, 0xCA, 0x80, 0xEE, 0x59, 0x9C, 0xBF, 0xA8, 0xEB, 0x78,
+0xC2, 0xE2, 0x2D, 0x6E, 0x2E, 0x98, 0x98, 0x6F, 0x07, 0x6A, 0x39, 0x57, 0x8F, 0xCE, 0xEE, 0x64
 
 [sha512_hmac_buff_1024]
 digest =
-0x6A, 0x8D, 0x3F, 0x10, 0x56, 0xAF, 0xF0, 0xD4, 0x00, 0xE7, 0x4D, 0xBB, 0xCD, 0x3E, 0xD0, 0x39,
-0x21, 0xC4, 0xFD, 0x04, 0xC1, 0x91, 0xB7, 0xE5, 0xDF, 0x52, 0xED, 0xE5, 0xA0, 0x87, 0x76, 0x0E,
-0x44, 0x63, 0xED, 0xDD, 0xEA, 0xBF, 0x2E, 0xBF, 0x6B, 0x87, 0x9E, 0x5C, 0xD7, 0x55, 0x73, 0xD0,
-0xB2, 0xAC, 0x12, 0x87, 0xE1, 0x96, 0xD4, 0x1E, 0xD0, 0x5D, 0x83, 0x88, 0xC2, 0x00, 0xD0, 0xBE
+0x17, 0x60, 0x08, 0x57, 0x43, 0x20, 0xF6, 0xB5, 0x6D, 0x0D, 0x7F, 0x7C, 0xB9, 0x09, 0x3F, 0x6D,
+0x3E, 0x75, 0x2F, 0x17, 0xDA, 0x19, 0x58, 0xF0, 0xEC, 0xED, 0x96, 0xA9, 0x57, 0x05, 0xCD, 0x23,
+0x0F, 0x1E, 0x38, 0x55, 0x2D, 0x8E, 0x36, 0x14, 0xF4, 0x99, 0x5E, 0x3C, 0x33, 0xBB, 0x99, 0xC9,
+0xCD, 0x7A, 0xF4, 0x87, 0x10, 0xB8, 0x6C, 0xB1, 0x14, 0x2D, 0xA8, 0xCE, 0xFE, 0xF8, 0x6F, 0xD9
 
 ######################
 # sha_hmac_buff_2048 #
 ######################
 [sha1_hmac_buff_2048]
 digest =
-0x02, 0xD4, 0x67, 0xF9, 0x41, 0x5C, 0x91, 0x62, 0x7E, 0x39, 0x4B, 0x3C, 0x2D, 0x77, 0x7A, 0x2C,
-0x2D, 0x47, 0x3E, 0x48
+0x58, 0xE4, 0xBB, 0x8D, 0x63, 0x5D, 0x23, 0xF1, 0xAB, 0xB5, 0xBD, 0xD8, 0x71, 0xC9, 0x05, 0x0A,
+0x65, 0x5D, 0x2D, 0x2D
 
 [sha224_hmac_buff_2048]
 digest =
-0xF0, 0x8D, 0x1C, 0xF8, 0x7A, 0x5E, 0xA5, 0x48, 0x36, 0x7F, 0x96, 0x4A, 0x66, 0x66, 0x36, 0x32,
-0x5D, 0x68, 0xB8, 0x21, 0x5A, 0xE1, 0x95, 0x4F, 0x22, 0xF4, 0x44, 0x38
+0xA3, 0x9A, 0x47, 0x68, 0x32, 0x3A, 0xA8, 0xE4, 0xBE, 0x23, 0xEA, 0xEE, 0x2D, 0x5E, 0x3C, 0x2E,
+0xD3, 0x99, 0xBE, 0x87, 0x19, 0x17, 0xC5, 0x13, 0x6D, 0xB7, 0x05, 0x97
 
 [sha256_hmac_buff_2048]
 digest =
-0x82, 0xC2, 0x7C, 0x08, 0xE2, 0x94, 0xD8, 0xA9, 0x3C, 0xBB, 0x54, 0x20, 0xC2, 0x01, 0xBC, 0xF4,
-0xA2, 0xEE, 0x76, 0x06, 0x78, 0xE9, 0x51, 0x2F, 0x4D, 0x7D, 0x20, 0x20, 0x75, 0x1E, 0xB2, 0x8A
+0x5B, 0x36, 0x1A, 0xF0, 0x55, 0xAC, 0xC3, 0xEA, 0x1B, 0x01, 0xCF, 0xCE, 0x89, 0x0D, 0x6A, 0xC3,
+0x5F, 0x9A, 0xD3, 0x49, 0xCC, 0xA4, 0xDF, 0xDD, 0x44, 0x1F, 0x9D, 0x6C, 0xB1, 0x92, 0xDF, 0xB9
 
 [sha384_hmac_buff_2048]
 digest =
-0x59, 0xA5, 0xAA, 0xEE, 0xD8, 0x13, 0xB1, 0xBF, 0x28, 0x83, 0xB8, 0xB2, 0xBC, 0x91, 0x0F, 0x2E,
-0xCB, 0xC4, 0xCD, 0x8F, 0xE4, 0xB1, 0x28, 0xBE, 0xC4, 0x1A, 0xC4, 0x45, 0xF9, 0xCC, 0x6C, 0x6F,
-0x71, 0x59, 0x2C, 0xC4, 0x47, 0x61, 0xFE, 0xBB, 0xDD, 0x2B, 0x99, 0xDD, 0x6A, 0x49, 0x61, 0x33
+0x24, 0x17, 0xA2, 0x61, 0xFF, 0x46, 0xA2, 0x2E, 0xE5, 0xC3, 0xB4, 0x47, 0x10, 0x8C, 0x54, 0xD2,
+0xC2, 0x4D, 0x15, 0xA2, 0x8D, 0xEF, 0x98, 0x6E, 0xE0, 0xB1, 0x31, 0x3B, 0x7D, 0xDE, 0x41, 0x8E,
+0x98, 0xB9, 0xE9, 0xD2, 0xD8, 0xE5, 0x75, 0x6D, 0xC5, 0xF0, 0x1A, 0xC4, 0x1B, 0x8B, 0xC1, 0xA4
 
 [sha512_hmac_buff_2048]
 digest =
-0x90, 0xAD, 0xA3, 0xFB, 0xC3, 0x88, 0x1F, 0xD9, 0x53, 0xE4, 0x9C, 0x71, 0x38, 0x3B, 0xFA, 0x99,
-0x82, 0x32, 0xC4, 0xFC, 0x61, 0x36, 0x65, 0x9E, 0xDF, 0x9C, 0xDB, 0xD5, 0xD2, 0xD0, 0xAE, 0x78,
-0x74, 0x08, 0xF0, 0x97, 0x7E, 0x1A, 0x0C, 0xC3, 0xDD, 0x8F, 0xB3, 0x1C, 0x55, 0xAC, 0xA7, 0xC9,
-0x49, 0x1C, 0xA7, 0xF7, 0xBA, 0xC0, 0x93, 0x54, 0xA3, 0x6B, 0xBF, 0xA7, 0x03, 0x40, 0xE0, 0x28
+0xD8, 0x77, 0x7A, 0x0F, 0x63, 0x1E, 0x92, 0x7B, 0x87, 0xCE, 0x07, 0x24, 0x7E, 0xE4, 0x36, 0x30,
+0x16, 0x76, 0x0D, 0xEC, 0xEF, 0x01, 0xF5, 0xD5, 0x44, 0xB7, 0xF3, 0x51, 0x31, 0x6A, 0xC2, 0x80,
+0xCD, 0x4C, 0x7F, 0xD4, 0xA6, 0x90, 0x85, 0xAE, 0x49, 0xB1, 0xF1, 0xB0, 0xC4, 0x16, 0x79, 0xC3,
+0xE3, 0x8B, 0x67, 0xC3, 0xAA, 0xC1, 0x9C, 0x8D, 0xE0, 0x22, 0xB3, 0xFD, 0x09, 0xD5, 0x40, 0xAC
-- 
2.7.4

[PATCH v2 4/9] app/crypto-perf: move verify as single test type

[Pablo de Lara]

From: Sergio Gonzalez Monroy <sergio.gonzalez.monroy@intel.com>

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 <sergio.gonzalez.monroy@intel.com>
---
 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 276ba68..d04cc08 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
 
 # this application needs libraries first
diff --git a/app/test-crypto-perf/cperf_ops.h b/app/test-crypto-perf/cperf_ops.h
index 11e2117..1b748da 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 c0d919f..573f6ea 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 f93e0c1..4c94bde 100644
--- a/app/test-crypto-perf/cperf_options_parsing.c
+++ b/app/test-crypto-perf/cperf_options_parsing.c
@@ -67,6 +67,10 @@ parse_cperf_test_type(struct cperf_options *opts, const char *arg)
 			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
 		}
@@ -262,15 +266,6 @@ parse_out_of_place(struct cperf_options *opts,
 }
 
 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 239a8e5..c5273b1 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 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id,
 	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 6c04697..92176d7 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 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id,
 	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 0000000..27fbd6c
--- /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 <rte_malloc.h>
+#include <rte_cycles.h>
+#include <rte_crypto.h>
+#include <rte_cryptodev.h>
+
+#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 0000000..3fa78ee
--- /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 <stdint.h>
+
+#include <rte_mbuf.h>
+
+#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 063ee47..3a80350 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 478d256..dbf5672 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 <name>``
 
         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.7.4

[PATCH v2 5/9] app/crypto-perf: do not append digest if not used

[Pablo de Lara]

When testing cipher only operations, there is no need to append digest
at the end of the buffer.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_test_latency.c    |  8 +++++---
 app/test-crypto-perf/cperf_test_throughput.c | 10 ++++++----
 app/test-crypto-perf/cperf_test_verify.c     | 10 ++++++----
 3 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c
index c5273b1..657d077 100644
--- a/app/test-crypto-perf/cperf_test_latency.c
+++ b/app/test-crypto-perf/cperf_test_latency.c
@@ -182,10 +182,12 @@ cperf_mbuf_create(struct rte_mempool *mempool,
 		memcpy(mbuf_data, test_data, last_sz);
 	}
 
-	mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf,
+	if (options->op_type != CPERF_CIPHER_ONLY) {
+		mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf,
 			options->auth_digest_sz);
-	if (mbuf_data == NULL)
-		goto error;
+		if (mbuf_data == NULL)
+			goto error;
+	}
 
 	if (options->op_type == CPERF_AEAD) {
 		uint8_t *aead = (uint8_t *)rte_pktmbuf_prepend(mbuf,
diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c
index 92176d7..7108075 100644
--- a/app/test-crypto-perf/cperf_test_throughput.c
+++ b/app/test-crypto-perf/cperf_test_throughput.c
@@ -163,10 +163,12 @@ cperf_mbuf_create(struct rte_mempool *mempool,
 		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_CIPHER_ONLY) {
+		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,
diff --git a/app/test-crypto-perf/cperf_test_verify.c b/app/test-crypto-perf/cperf_test_verify.c
index 27fbd6c..be157e6 100644
--- a/app/test-crypto-perf/cperf_test_verify.c
+++ b/app/test-crypto-perf/cperf_test_verify.c
@@ -165,10 +165,12 @@ cperf_mbuf_create(struct rte_mempool *mempool,
 		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_CIPHER_ONLY) {
+		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,
-- 
2.7.4

[PATCH v2 6/9] app/crypto-perf: display results in test runner

[Pablo de Lara]

Instead of printing the test results in the destructor
function, print them just after each run.
This will be useful for after the commit that allows
a range of buffer and burst sizes.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_test_latency.c    | 150 ++++++++++-----------------
 app/test-crypto-perf/cperf_test_throughput.c | 132 ++++++++++-------------
 app/test-crypto-perf/cperf_test_verify.c     | 102 ++++++++----------
 3 files changed, 151 insertions(+), 233 deletions(-)

diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c
index 657d077..20d7069 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)
@@ -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);
@@ -325,18 +301,14 @@ cperf_latency_test_runner(void *arg)
 	struct cperf_latency_ctx *ctx = arg;
 	struct cperf_op_result *pres;
 
+	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;
-	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;
+	uint64_t i;
 
 	uint32_t lcore = rte_lcore_id();
 
@@ -359,8 +331,15 @@ 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) {
+	uint64_t ops_enqd = 0, ops_deqd = 0;
+	uint64_t m_idx = 0, b_idx = 0;
+
+	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 + ctx->options->burst_sz)
 				<= ctx->options->total_ops) ?
 						ctx->options->burst_sz :
@@ -478,69 +457,30 @@ cperf_latency_test_runner(void *arg)
 		tsc_tot += tsc_val;
 	}
 
-	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;
-}
-
-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;
+	double time_tot, time_avg, time_max, time_min;
 
 	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;
+	uint64_t enqd_avg = enqd_tot / b_idx;
+	uint64_t deqd_avg = deqd_tot / b_idx;
+	uint64_t tsc_avg = tsc_tot / tsc_idx;
 
-	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;
+	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;
 
 	if (ctx->options->csv) {
 		if (!only_once)
-			printf("\n# lcore, Pakt Seq #, Packet Size, cycles,"
-					" time (us)");
+			printf("\n# lcore, Buffer Size, Burst Size, 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,
+			printf("\n%u;%u;%u;%"PRIu64";%"PRIu64";%.3f",
+				ctx->lcore_id, ctx->options->buffer_sz,
+				ctx->options->burst_sz, i + 1,
 				ctx->res[i].tsc_end - ctx->res[i].tsc_start,
 				tunit * (double) (ctx->res[i].tsc_end
 						- ctx->res[i].tsc_start)
@@ -552,22 +492,40 @@ 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#     burst number: %"PRIu64,
-				ctx->results.burst_num);
+		printf("\n# Buffer size: %u", ctx->options->buffer_sz);
+		printf("\n# Burst size: %u", ctx->options->burst_sz);
+		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, 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#          \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");
 
 	}
+
+	return 0;
+}
+
+void
+cperf_latency_test_destructor(void *arg)
+{
+	struct cperf_latency_ctx *ctx = arg;
+
+	if (ctx == NULL)
+		return;
+
 	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..32c5bad 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
@@ -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);
 
@@ -297,15 +280,11 @@ cperf_throughput_test_runner(void *test_ctx)
 {
 	struct cperf_throughput_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, 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];
+	uint64_t i;
 
 	uint32_t lcore = rte_lcore_id();
 
@@ -324,18 +303,19 @@ 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();
+	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 m_idx = 0, tsc_start, tsc_end, tsc_duration;
 
+	tsc_start = rte_rdtsc_precise();
 	while (ops_enqd_total < ctx->options->total_ops) {
 
+		uint16_t ops_unused = 0;
+
 		uint16_t burst_size = ((ops_enqd_total + ctx->options->burst_sz)
 				<= ctx->options->total_ops) ?
 						ctx->options->burst_sz :
@@ -433,22 +413,59 @@ cperf_throughput_test_runner(void *test_ctx)
 	tsc_duration = (tsc_end - tsc_start);
 
 	/* Calculate average operations processed per second */
-	ctx->results.ops_per_second = ((double)ctx->options->total_ops /
+	double 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 *
+	double throughput_gbps = ((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;
+	/* Calculate average cycles per packet */
+	double cycles_per_packet = ((double)tsc_duration /
+			ctx->options->total_ops);
 
-	ctx->results.ops_enqueued = ops_enqd_total;
-	ctx->results.ops_dequeued = ops_deqd_total;
+	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->buffer_sz,
+				ctx->options->burst_sz,
+				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;
 
-	ctx->results.ops_enqueued_failed = ops_enqd_failed;
-	ctx->results.ops_dequeued_failed = ops_deqd_failed;
+		printf("%10u;%10u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";"
+				"%.f3;%.f3;%.f3\n",
+				ctx->lcore_id,
+				ctx->options->buffer_sz,
+				ctx->options->burst_sz,
+				ops_enqd_total,
+				ops_deqd_total,
+				ops_enqd_failed,
+				ops_deqd_failed,
+				ops_per_second/1000000,
+				throughput_gbps,
+				cycles_per_packet);
+	}
 
 	return 0;
 }
@@ -458,50 +475,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_verify.c b/app/test-crypto-perf/cperf_test_verify.c
index be157e6..b58b86c 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 {
@@ -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);
 
@@ -388,7 +373,7 @@ cperf_verify_op(struct rte_crypto_op *op,
 		if (options->auth_op == RTE_CRYPTO_AUTH_OP_GENERATE)
 			res += memcmp(data + auth_offset,
 					vector->digest.data,
-					vector->digest.length);
+					options->auth_digest_sz);
 	}
 
 	return !!res;
@@ -401,6 +386,9 @@ 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;
@@ -498,15 +486,15 @@ 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
 			 * failures.
 			 */
 			rte_crypto_op_free(ops_processed[i]);
-			ops_deqd_total += ops_deqd;
 		}
+		ops_deqd_total += ops_deqd;
 	}
 
 	/* Dequeue any operations still in the crypto device */
@@ -526,22 +514,53 @@ 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
 			 * failures.
 			 */
 			rte_crypto_op_free(ops_processed[i]);
-			ops_deqd_total += ops_deqd;
 		}
+		ops_deqd_total += ops_deqd;
 	}
 
-	ctx->results.ops_enqueued = ops_enqd_total;
-	ctx->results.ops_dequeued = ops_deqd_total;
+	if (!ctx->options->csv) {
+		if (!only_once)
+			printf("%12s%12s%12s%12s%12s%12s%12s%12s\n\n",
+				"lcore id", "Buf Size", "Burst size",
+				"Enqueued", "Dequeued", "Failed Enq",
+				"Failed Deq", "Failed Ops");
+		only_once = 1;
+
+		printf("%12u%12u%12u%12"PRIu64"%12"PRIu64"%12"PRIu64
+				"%12"PRIu64"%12"PRIu64"\n",
+				ctx->lcore_id,
+				ctx->options->buffer_sz,
+				ctx->options->burst_sz,
+				ops_enqd_total,
+				ops_deqd_total,
+				ops_enqd_failed,
+				ops_deqd_failed,
+				ops_failed);
+	} else {
+		if (!only_once)
+			printf("\n# lcore id, Buffer Size(B), "
+				"Burst Size,Enqueued,Dequeued,Failed Enq,"
+				"Failed Deq,Failed Ops\n");
+		only_once = 1;
 
-	ctx->results.ops_enqueued_failed = ops_enqd_failed;
-	ctx->results.ops_dequeued_failed = ops_deqd_failed;
+		printf("%10u;%10u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";"
+				"%"PRIu64"\n",
+				ctx->lcore_id,
+				ctx->options->buffer_sz,
+				ctx->options->burst_sz,
+				ops_enqd_total,
+				ops_deqd_total,
+				ops_enqd_failed,
+				ops_deqd_failed,
+				ops_failed);
+	}
 
 	return 0;
 }
@@ -552,44 +571,9 @@ 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);
 }
-- 
2.7.4

[PATCH v2 7/9] app/crypto-perf: add range/list of sizes

[Pablo de Lara]

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 <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_ops.c                 |  20 +-
 app/test-crypto-perf/cperf_options.h             |  17 +-
 app/test-crypto-perf/cperf_options_parsing.c     | 234 ++++++++++++++--
 app/test-crypto-perf/cperf_test_latency.c        | 327 ++++++++++++-----------
 app/test-crypto-perf/cperf_test_throughput.c     | 308 +++++++++++----------
 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         |  44 +--
 app/test-crypto-perf/main.c                      |  60 +++--
 doc/guides/tools/cryptoperf.rst                  |  15 ++
 10 files changed, 662 insertions(+), 383 deletions(-)

diff --git a/app/test-crypto-perf/cperf_ops.c b/app/test-crypto-perf/cperf_ops.c
index 1795a37..0387354 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 573f6ea..24699ed 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,
@@ -57,8 +58,7 @@ struct cperf_options {
 
 	uint32_t pool_sz;
 	uint32_t total_ops;
-	uint32_t burst_sz;
-	uint32_t buffer_sz;
+	uint32_t test_buffer_size;
 	uint32_t segments_nb;
 
 	char device_type[RTE_CRYPTODEV_NAME_LEN];
@@ -84,6 +84,19 @@ struct cperf_options {
 	uint16_t auth_key_sz;
 	uint16_t auth_digest_sz;
 	uint16_t auth_aad_sz;
+
+	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 4c94bde..e458f6d 100644
--- a/app/test-crypto-perf/cperf_options_parsing.c
+++ b/app/test-crypto-perf/cperf_options_parsing.c
@@ -124,6 +124,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 +279,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 +611,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 +717,7 @@ 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) {
+	if (options->segments_nb > options->min_buffer_size) {
 		RTE_LOG(ERR, USER1,
 				"Segments number greater than buffer size.\n");
 		return -EINVAL;
@@ -602,6 +750,22 @@ cperf_options_check(struct cperf_options *options)
 		return -EINVAL;
 	}
 
+	if (options->test == CPERF_TEST_TYPE_VERIFY &&
+			(options->inc_buffer_size != 0 ||
+			options->buffer_size_count > 1)) {
+		RTE_LOG(ERR, USER1, "Only one buffer size is allowed when "
+				"using the verify test.\n");
+		return -EINVAL;
+	}
+
+	if (options->test == CPERF_TEST_TYPE_VERIFY &&
+			(options->inc_burst_size != 0 ||
+			options->burst_size_count > 1)) {
+		RTE_LOG(ERR, USER1, "Only one burst size is allowed when "
+				"using the verify test.\n");
+		return -EINVAL;
+	}
+
 	if (options->op_type == CPERF_CIPHER_THEN_AUTH) {
 		if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
 				options->auth_op !=
@@ -649,15 +813,37 @@ cperf_options_check(struct cperf_options *options)
 void
 cperf_options_dump(struct cperf_options *opts)
 {
+	uint8_t size_idx;
+
 	printf("# Crypto Performance Application Options:\n");
 	printf("#\n");
 	printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]);
 	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);
+	if (opts->inc_buffer_size != 0) {
+		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);
+	} else {
+		printf("# buffer sizes: ");
+		for (size_idx = 0; size_idx < opts->buffer_size_count; size_idx++)
+			printf("%u ", opts->buffer_size_list[size_idx]);
+		printf("\n");
+	}
+	if (opts->inc_burst_size != 0) {
+		printf("# burst size:\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);
+	} else {
+		printf("# burst sizes: ");
+		for (size_idx = 0; size_idx < opts->burst_size_count; size_idx++)
+			printf("%u ", opts->burst_size_list[size_idx]);
+		printf("\n");
+	}
+	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 20d7069..3275b4b 100644
--- a/app/test-crypto-perf/cperf_test_latency.c
+++ b/app/test-crypto-perf/cperf_test_latency.c
@@ -115,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) ?
@@ -218,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());
 
@@ -249,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());
 
@@ -300,14 +300,16 @@ cperf_latency_test_runner(void *arg)
 {
 	struct cperf_latency_ctx *ctx = arg;
 	struct cperf_op_result *pres;
+	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];
+	struct rte_crypto_op *ops[ctx->options->max_burst_size];
+	struct rte_crypto_op *ops_processed[ctx->options->max_burst_size];
 	uint64_t i;
 
 	uint32_t lcore = rte_lcore_id();
@@ -331,188 +333,207 @@ 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);
 
-	uint64_t ops_enqd = 0, ops_deqd = 0;
-	uint64_t m_idx = 0, b_idx = 0;
+	/* 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];
 
-	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 (test_burst_size <= ctx->options->max_burst_size) {
+		uint64_t ops_enqd = 0, ops_deqd = 0;
+		uint64_t m_idx = 0, b_idx = 0;
 
-	while (enqd_tot < ctx->options->total_ops) {
-		uint16_t burst_size = ((enqd_tot + ctx->options->burst_sz)
-				<= ctx->options->total_ops) ?
-						ctx->options->burst_sz :
-						ctx->options->total_ops -
-						enqd_tot;
+		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;
 
-		/* Allocate crypto ops from pool */
-		if (burst_size != rte_crypto_op_bulk_alloc(
-				ctx->crypto_op_pool,
-				RTE_CRYPTO_OP_TYPE_SYMMETRIC,
-				ops, burst_size))
-			return -1;
+		while (enqd_tot < ctx->options->total_ops) {
 
-		/* Setup crypto op, attach mbuf etc */
-		(ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx],
-				&ctx->mbufs_out[m_idx],
-				burst_size, ctx->sess, ctx->options,
-				ctx->test_vector);
+			uint16_t burst_size = ((enqd_tot + test_burst_size)
+					<= ctx->options->total_ops) ?
+							test_burst_size :
+							ctx->options->total_ops -
+							enqd_tot;
 
-		tsc_start = rte_rdtsc_precise();
+			/* Allocate crypto ops from pool */
+			if (burst_size != rte_crypto_op_bulk_alloc(
+					ctx->crypto_op_pool,
+					RTE_CRYPTO_OP_TYPE_SYMMETRIC,
+					ops, burst_size))
+				return -1;
+
+			/* Setup crypto op, attach mbuf etc */
+			(ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx],
+					&ctx->mbufs_out[m_idx],
+					burst_size, ctx->sess, ctx->options,
+					ctx->test_vector);
+
+			tsc_start = 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 < 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);
+			/* Enqueue burst of ops on crypto device */
+			ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id,
+					ops, burst_size);
 
-		/* 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);
+			/* 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_end = rte_rdtsc_precise();
+			tsc_end = rte_rdtsc_precise();
 
-		for (i = 0; i < ops_enqd; i++) {
-			ctx->res[tsc_idx].tsc_start = tsc_start;
-			ops[i]->opaque_data = (void *)&ctx->res[tsc_idx];
-			tsc_idx++;
-		}
+			/* Free memory for not enqueued operations */
+			for (i = ops_enqd; i < burst_size; i++)
+				rte_crypto_op_free(ops[i]);
 
-		/* Free memory for not enqueued operations */
-		for (i = ops_enqd; i < burst_size; i++)
-			rte_crypto_op_free(ops[i]);
-
-		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]);
+			for (i = 0; i < burst_size; i++) {
+				ctx->res[tsc_idx].tsc_start = tsc_start;
+				ops[i]->opaque_data = (void *)&ctx->res[tsc_idx];
+				tsc_idx++;
 			}
 
-			deqd_tot += ops_deqd;
-			deqd_max = max(ops_deqd, deqd_max);
-			deqd_min = min(ops_deqd, deqd_min);
-		}
+			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);
+			}
 
-		enqd_tot += ops_enqd;
-		enqd_max = max(ops_enqd, enqd_max);
-		enqd_min = min(ops_enqd, enqd_min);
+			enqd_tot += ops_enqd;
+			enqd_max = max(ops_enqd, enqd_max);
+			enqd_min = min(ops_enqd, enqd_min);
 
-		m_idx += ops_enqd;
-		m_idx = m_idx + ctx->options->burst_sz > ctx->options->pool_sz ?
-				0 : m_idx;
-		b_idx++;
-	}
+			m_idx += ops_enqd;
+			m_idx = m_idx + test_burst_size > ctx->options->pool_sz ?
+					0 : m_idx;
+			b_idx++;
+		}
 
-	/* 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);
+		/* 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);
+
+			/* dequeue burst */
+			ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
+					ops_processed, test_burst_size);
 
-		/* dequeue burst */
-		ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
-				ops_processed, ctx->options->burst_sz);
+			tsc_end = rte_rdtsc_precise();
 
-		tsc_end = rte_rdtsc_precise();
+			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;
 
-		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;
 		}
-	}
 
-	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;
-	}
+		double time_tot, time_avg, time_max, time_min;
 
-	double time_tot, time_avg, time_max, time_min;
+		const uint64_t tunit = 1000000; /* us */
+		const uint64_t tsc_hz = rte_get_tsc_hz();
 
-	const uint64_t tunit = 1000000; /* us */
-	const uint64_t tsc_hz = rte_get_tsc_hz();
+		uint64_t enqd_avg = enqd_tot / b_idx;
+		uint64_t deqd_avg = deqd_tot / b_idx;
+		uint64_t tsc_avg = tsc_tot / tsc_idx;
 
-	uint64_t enqd_avg = enqd_tot / b_idx;
-	uint64_t deqd_avg = deqd_tot / b_idx;
-	uint64_t tsc_avg = tsc_tot / tsc_idx;
+		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;
 
-	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;
+		if (ctx->options->csv) {
+			if (!only_once)
+				printf("\n# lcore, Buffer Size, Burst Size, Pakt Seq #, "
+						"Packet Size, cycles, time (us)");
 
-	if (ctx->options->csv) {
-		if (!only_once)
-			printf("\n# lcore, Buffer Size, Burst Size, Pakt Seq #, "
-					"Packet Size, cycles, time (us)");
+			for (i = 0; i < ctx->options->total_ops; i++) {
 
-		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);
 
-			printf("\n%u;%u;%u;%"PRIu64";%"PRIu64";%.3f",
-				ctx->lcore_id, ctx->options->buffer_sz,
-				ctx->options->burst_sz, 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# 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");
 
 		}
-		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->buffer_sz);
-		printf("\n# Burst size: %u", ctx->options->burst_sz);
-		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");
 
+		/* 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];
+		}
 	}
 
 	return 0;
diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c
index 32c5bad..70ec4ff 100644
--- a/app/test-crypto-perf/cperf_test_throughput.c
+++ b/app/test-crypto-perf/cperf_test_throughput.c
@@ -103,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) ?
@@ -206,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());
 
@@ -235,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());
 
@@ -279,11 +279,13 @@ int
 cperf_throughput_test_runner(void *test_ctx)
 {
 	struct cperf_throughput_ctx *ctx = test_ctx;
+	uint16_t test_burst_size;
+	uint8_t burst_size_idx = 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];
 	uint64_t i;
 
 	uint32_t lcore = rte_lcore_id();
@@ -307,164 +309,184 @@ cperf_throughput_test_runner(void *test_ctx)
 	for (i = 0; i < ctx->options->total_ops; i++)
 		rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 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 m_idx = 0, tsc_start, tsc_end, tsc_duration;
+	/* 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];
 
-	tsc_start = rte_rdtsc_precise();
-	while (ops_enqd_total < ctx->options->total_ops) {
+	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 m_idx = 0, tsc_start, tsc_end, tsc_duration;
 
 		uint16_t ops_unused = 0;
 
-		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;
+		tsc_start = rte_rdtsc_precise();
+
+		while (ops_enqd_total < ctx->options->total_ops) {
+
+			uint16_t burst_size = ((ops_enqd_total + test_burst_size)
+					<= ctx->options->total_ops) ?
+							test_burst_size :
+							ctx->options->total_ops -
+							ops_enqd_total;
 
-		uint16_t ops_needed = burst_size - ops_unused;
+			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;
+			/* 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);
+			/* 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 + test_burst_size > ctx->options->pool_sz ?
+					0 : m_idx;
 		}
 
-		m_idx += ops_needed;
-		m_idx = m_idx + ctx->options->burst_sz > 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, 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]);
 
-		/* 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]);
+				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 */
+		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);
+
+		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);
+		}
+
+		/* 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];
 		}
-	}
 
-	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->buffer_sz * 8) / 1000000000);
-
-	/* Calculate average cycles per packet */
-	double cycles_per_packet = ((double)tsc_duration /
-			ctx->options->total_ops);
-
-	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->buffer_sz,
-				ctx->options->burst_sz,
-				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->buffer_sz,
-				ctx->options->burst_sz,
-				ops_enqd_total,
-				ops_deqd_total,
-				ops_enqd_failed,
-				ops_deqd_failed,
-				ops_per_second/1000000,
-				throughput_gbps,
-				cycles_per_packet);
 	}
 
 	return 0;
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 f7b3aa9..f87bb8e 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 b58b86c..454221e 100644
--- a/app/test-crypto-perf/cperf_test_verify.c
+++ b/app/test-crypto-perf/cperf_test_verify.c
@@ -107,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) ?
@@ -210,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());
 
@@ -239,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());
 
@@ -336,25 +336,25 @@ cperf_verify_op(struct rte_crypto_op *op,
 		cipher = 1;
 		cipher_offset = 0;
 		auth = 1;
-		auth_offset = vector->plaintext.length;
+		auth_offset = options->test_buffer_size;
 		break;
 	case CPERF_AUTH_ONLY:
 		cipher = 0;
 		cipher_offset = 0;
 		auth = 1;
-		auth_offset = vector->plaintext.length;
+		auth_offset = options->test_buffer_size;
 		break;
 	case CPERF_AUTH_THEN_CIPHER:
 		cipher = 1;
 		cipher_offset = 0;
 		auth = 1;
-		auth_offset = vector->plaintext.length;
+		auth_offset = options->test_buffer_size;
 		break;
 	case CPERF_AEAD:
 		cipher = 1;
 		cipher_offset = vector->aad.length;
 		auth = 1;
-		auth_offset = vector->aad.length + vector->plaintext.length;
+		auth_offset = vector->aad.length + options->test_buffer_size;
 		break;
 	}
 
@@ -362,11 +362,11 @@ cperf_verify_op(struct rte_crypto_op *op,
 		if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
 			res += memcmp(data + cipher_offset,
 					vector->ciphertext.data,
-					vector->ciphertext.length);
+					options->test_buffer_size);
 		else
 			res += memcmp(data + cipher_offset,
 					vector->plaintext.data,
-					vector->plaintext.length);
+					options->test_buffer_size);
 	}
 
 	if (auth == 1) {
@@ -393,8 +393,8 @@ cperf_verify_test_runner(void *test_ctx)
 	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();
 
@@ -419,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;
 
@@ -467,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) {
@@ -505,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;
@@ -536,8 +536,8 @@ cperf_verify_test_runner(void *test_ctx)
 		printf("%12u%12u%12u%12"PRIu64"%12"PRIu64"%12"PRIu64
 				"%12"PRIu64"%12"PRIu64"\n",
 				ctx->lcore_id,
-				ctx->options->buffer_sz,
-				ctx->options->burst_sz,
+				ctx->options->max_buffer_size,
+				ctx->options->max_burst_size,
 				ops_enqd_total,
 				ops_deqd_total,
 				ops_enqd_failed,
@@ -553,8 +553,8 @@ cperf_verify_test_runner(void *test_ctx)
 		printf("%10u;%10u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";"
 				"%"PRIu64"\n",
 				ctx->lcore_id,
-				ctx->options->buffer_sz,
-				ctx->options->burst_sz,
+				ctx->options->max_buffer_size,
+				ctx->options->max_burst_size,
 				ops_enqd_total,
 				ops_deqd_total,
 				ops_enqd_failed,
diff --git a/app/test-crypto-perf/main.c b/app/test-crypto-perf/main.c
index 3a80350..9ec2a4b 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;
@@ -206,7 +206,7 @@ cperf_check_test_vector(struct cperf_options *opts,
 				return -1;
 			if (test_vec->digest.data == NULL)
 				return -1;
-			if (test_vec->digest.length != opts->auth_digest_sz)
+			if (test_vec->digest.length < opts->auth_digest_sz)
 				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;
@@ -242,13 +242,17 @@ cperf_check_test_vector(struct cperf_options *opts,
 				return -1;
 			if (test_vec->digest.data == NULL)
 				return -1;
-			if (test_vec->digest.length != opts->auth_digest_sz)
+			if (test_vec->digest.length < opts->auth_digest_sz)
 				return -1;
 		}
 	} 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->ciphertext.data == NULL)
+			return -1;
+		if (test_vec->ciphertext.length < opts->max_buffer_size)
 			return -1;
 		if (test_vec->aad.data == NULL)
 			return -1;
@@ -256,7 +260,7 @@ cperf_check_test_vector(struct cperf_options *opts,
 			return -1;
 		if (test_vec->digest.data == NULL)
 			return -1;
-		if (test_vec->digest.length != opts->auth_digest_sz)
+		if (test_vec->digest.length < opts->auth_digest_sz)
 			return -1;
 	}
 	return 0;
@@ -275,6 +279,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 +376,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;
+
+			cdev_id = enabled_cdevs[i];
 
-		rte_eal_remote_launch(cperf_testmap[opts.test].runner,
+			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 dbf5672..2d225d5 100644
--- a/doc/guides/tools/cryptoperf.rst
+++ b/doc/guides/tools/cryptoperf.rst
@@ -151,10 +151,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 <n>``
 
         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 <n>``
 
         Set the number of segments per packet.
-- 
2.7.4

[PATCH v2 8/9] app/crypto-perf: add extra option checks

[Pablo de Lara]

When using the verify test, test name is necessary
to be passed when digest is needed.

Also, when using an block cipher algorithm (CBC, ECB),
the buffer size has to be aligned to the block size.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_options_parsing.c | 52 ++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/app/test-crypto-perf/cperf_options_parsing.c b/app/test-crypto-perf/cperf_options_parsing.c
index e458f6d..d172671 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;
@@ -717,6 +720,8 @@ cperf_options_parse(struct cperf_options *options, int argc, char **argv)
 int
 cperf_options_check(struct cperf_options *options)
 {
+	uint32_t buffer_size, buffer_size_idx = 0;
+
 	if (options->segments_nb > options->min_buffer_size) {
 		RTE_LOG(ERR, USER1,
 				"Segments number greater than buffer size.\n");
@@ -730,6 +735,14 @@ cperf_options_check(struct cperf_options *options)
 		return -EINVAL;
 	}
 
+	if (options->test == CPERF_TEST_TYPE_VERIFY &&
+			options->op_type != CPERF_CIPHER_ONLY &&
+			options->test_name == NULL) {
+		RTE_LOG(ERR, USER1, "Define test name to get the correct digest"
+				" from the test vectors.\n");
+		return -EINVAL;
+	}
+
 	if (options->test_name != NULL && options->test_file == NULL) {
 		RTE_LOG(ERR, USER1, "Define path to the file with test"
 				" vectors.\n");
@@ -807,6 +820,45 @@ cperf_options_check(struct cperf_options *options)
 		}
 	}
 
+	if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CBC ||
+			options->cipher_algo == RTE_CRYPTO_CIPHER_AES_ECB) {
+		if (options->inc_buffer_size != 0)
+			buffer_size = options->min_buffer_size;
+		else
+			buffer_size = options->buffer_size_list[0];
+
+		while (buffer_size <= options->max_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->inc_buffer_size != 0)
+				buffer_size += options->inc_buffer_size;
+			else {
+				if (++buffer_size_idx == options->buffer_size_count)
+					break;
+				buffer_size = options->buffer_size_list[buffer_size_idx];
+			}
+
+		}
+	}
+
+	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;
 }
 
-- 
2.7.4

[PATCH v2 9/9] app/crypto-perf: reorg options structure

[Pablo de Lara]

Reorganize options structure, to have all the parameters
used in a single run in the first bytes of the structure,
so all fit in a single cache line.

Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
---
 app/test-crypto-perf/cperf_options.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/app/test-crypto-perf/cperf_options.h b/app/test-crypto-perf/cperf_options.h
index 24699ed..b928c58 100644
--- a/app/test-crypto-perf/cperf_options.h
+++ b/app/test-crypto-perf/cperf_options.h
@@ -58,20 +58,14 @@ struct cperf_options {
 
 	uint32_t pool_sz;
 	uint32_t total_ops;
-	uint32_t test_buffer_size;
 	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,12 @@ struct cperf_options {
 	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;
-- 
2.7.4

Re: [PATCH v2 0/9] Crypto performance app improvements

[De Lara Guarch, Pablo]

> -----Original Message-----
> From: De Lara Guarch, Pablo
> Sent: Monday, March 27, 2017 12:26 PM
> To: Doherty, Declan
> Cc: dev@dpdk.org; De Lara Guarch, Pablo
> Subject: [PATCH v2 0/9] Crypto performance app improvements
> 
> This patchset makes the following changes in the crypto-perf app:
> 
> - Adds the option to run performance tests on different
>   buffer and burst sizes, in a single run, instead of having to
>   run the application several times.
> 
> - Cleans up the application, by removing unused functions and
>   separating the verify option in a new test type
> 
> - Fixes several issues in the application (such as wrong test vectors)
> 
> 
> Pablo de Lara (8):
>   app/crypto-perf: remove cyclecount test type
>   app/crypto-perf: remove unused file
>   app/crypto-perf: fix AES CBC 128 test vectors
>   app/crypto-perf: do not append digest if not used
>   app/crypto-perf: display results in test runner
>   app/crypto-perf: add range/list of sizes
>   app/crypto-perf: add extra option checks
>   app/crypto-perf: reorg options structure
> 
> Sergio Gonzalez Monroy (1):
>   app/crypto-perf: move verify as single test type
> 
>  app/test-crypto-perf/Makefile                    |   1 +
>  app/test-crypto-perf/cperf_ops.c                 |  20 +-
>  app/test-crypto-perf/cperf_ops.h                 |   5 -
>  app/test-crypto-perf/cperf_options.h             |  35 +-
>  app/test-crypto-perf/cperf_options_parsing.c     | 308 ++++++++++--
>  app/test-crypto-perf/cperf_test_latency.c        | 508 ++++++++------------
>  app/test-crypto-perf/cperf_test_throughput.c     | 502 +++++++-------------
>  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         | 579
> +++++++++++++++++++++++
>  app/test-crypto-perf/cperf_test_verify.h         |  58 +++
>  app/test-crypto-perf/cperf_verify_parser.c       | 314 ------------
>  app/test-crypto-perf/data/aes_cbc_128_sha.data   | 439 +++++++++--------
>  app/test-crypto-perf/main.c                      |  71 ++-
>  doc/guides/tools/cryptoperf.rst                  |  27 +-
>  15 files changed, 1592 insertions(+), 1295 deletions(-)
>  create mode 100644 app/test-crypto-perf/cperf_test_verify.c
>  create mode 100644 app/test-crypto-perf/cperf_test_verify.h
>  delete mode 100644 app/test-crypto-perf/cperf_verify_parser.c
> 
> --
> 2.7.4

Changes in v2:
- Split previous third patch into new four patches (6-9)
- Removed unused functions
- Fixed AES CBC 128 test vectors 

Re: [PATCH v2 0/9] Crypto performance app improvements

[Sergio Gonzalez Monroy]

On 27/03/2017 13:29, De Lara Guarch, Pablo wrote:
>
>> -----Original Message-----
>> From: De Lara Guarch, Pablo
>> Sent: Monday, March 27, 2017 12:26 PM
>> To: Doherty, Declan
>> Cc: dev@dpdk.org; De Lara Guarch, Pablo
>> Subject: [PATCH v2 0/9] Crypto performance app improvements
>>
>> This patchset makes the following changes in the crypto-perf app:
>>
>> - Adds the option to run performance tests on different
>>    buffer and burst sizes, in a single run, instead of having to
>>    run the application several times.
>>
>> - Cleans up the application, by removing unused functions and
>>    separating the verify option in a new test type
>>
>> - Fixes several issues in the application (such as wrong test vectors)
>>
>>
>> Pablo de Lara (8):
>>    app/crypto-perf: remove cyclecount test type
>>    app/crypto-perf: remove unused file
>>    app/crypto-perf: fix AES CBC 128 test vectors
>>    app/crypto-perf: do not append digest if not used
>>    app/crypto-perf: display results in test runner
>>    app/crypto-perf: add range/list of sizes
>>    app/crypto-perf: add extra option checks
>>    app/crypto-perf: reorg options structure
>>
>> Sergio Gonzalez Monroy (1):
>>    app/crypto-perf: move verify as single test type
>>
>>   app/test-crypto-perf/Makefile                    |   1 +
>>   app/test-crypto-perf/cperf_ops.c                 |  20 +-
>>   app/test-crypto-perf/cperf_ops.h                 |   5 -
>>   app/test-crypto-perf/cperf_options.h             |  35 +-
>>   app/test-crypto-perf/cperf_options_parsing.c     | 308 ++++++++++--
>>   app/test-crypto-perf/cperf_test_latency.c        | 508 ++++++++------------
>>   app/test-crypto-perf/cperf_test_throughput.c     | 502 +++++++-------------
>>   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         | 579
>> +++++++++++++++++++++++
>>   app/test-crypto-perf/cperf_test_verify.h         |  58 +++
>>   app/test-crypto-perf/cperf_verify_parser.c       | 314 ------------
>>   app/test-crypto-perf/data/aes_cbc_128_sha.data   | 439 +++++++++--------
>>   app/test-crypto-perf/main.c                      |  71 ++-
>>   doc/guides/tools/cryptoperf.rst                  |  27 +-
>>   15 files changed, 1592 insertions(+), 1295 deletions(-)
>>   create mode 100644 app/test-crypto-perf/cperf_test_verify.c
>>   create mode 100644 app/test-crypto-perf/cperf_test_verify.h
>>   delete mode 100644 app/test-crypto-perf/cperf_verify_parser.c
>>
>> --
>> 2.7.4
> Changes in v2:
> - Split previous third patch into new four patches (6-9)
> - Removed unused functions
> - Fixed AES CBC 128 test vectors
>
Acked-by: Sergio Gonzalez Monroy <sergio.gonzalez.monroy@intel.com>

Re: [PATCH v2 0/9] Crypto performance app improvements

[De Lara Guarch, Pablo]

> -----Original Message-----
> From: Gonzalez Monroy, Sergio
> Sent: Wednesday, March 29, 2017 4:25 PM
> To: De Lara Guarch, Pablo; Doherty, Declan
> Cc: dev@dpdk.org
> Subject: Re: [dpdk-dev] [PATCH v2 0/9] Crypto performance app
> improvements
> 
> On 27/03/2017 13:29, De Lara Guarch, Pablo wrote:
> >
> >> -----Original Message-----
> >> From: De Lara Guarch, Pablo
> >> Sent: Monday, March 27, 2017 12:26 PM
> >> To: Doherty, Declan
> >> Cc: dev@dpdk.org; De Lara Guarch, Pablo
> >> Subject: [PATCH v2 0/9] Crypto performance app improvements
> >>
> >> This patchset makes the following changes in the crypto-perf app:
> >>
> >> - Adds the option to run performance tests on different
> >>    buffer and burst sizes, in a single run, instead of having to
> >>    run the application several times.
> >>
> >> - Cleans up the application, by removing unused functions and
> >>    separating the verify option in a new test type
> >>
> >> - Fixes several issues in the application (such as wrong test vectors)
> >>
> >>
> >> Pablo de Lara (8):
> >>    app/crypto-perf: remove cyclecount test type
> >>    app/crypto-perf: remove unused file
> >>    app/crypto-perf: fix AES CBC 128 test vectors
> >>    app/crypto-perf: do not append digest if not used
> >>    app/crypto-perf: display results in test runner
> >>    app/crypto-perf: add range/list of sizes
> >>    app/crypto-perf: add extra option checks
> >>    app/crypto-perf: reorg options structure
> >>
> >> Sergio Gonzalez Monroy (1):
> >>    app/crypto-perf: move verify as single test type
> >>
> >>   app/test-crypto-perf/Makefile                    |   1 +
> >>   app/test-crypto-perf/cperf_ops.c                 |  20 +-
> >>   app/test-crypto-perf/cperf_ops.h                 |   5 -
> >>   app/test-crypto-perf/cperf_options.h             |  35 +-
> >>   app/test-crypto-perf/cperf_options_parsing.c     | 308 ++++++++++--
> >>   app/test-crypto-perf/cperf_test_latency.c        | 508 ++++++++------------
> >>   app/test-crypto-perf/cperf_test_throughput.c     | 502 +++++++----------
> ---
> >>   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         | 579
> >> +++++++++++++++++++++++
> >>   app/test-crypto-perf/cperf_test_verify.h         |  58 +++
> >>   app/test-crypto-perf/cperf_verify_parser.c       | 314 ------------
> >>   app/test-crypto-perf/data/aes_cbc_128_sha.data   | 439 +++++++++---
> -----
> >>   app/test-crypto-perf/main.c                      |  71 ++-
> >>   doc/guides/tools/cryptoperf.rst                  |  27 +-
> >>   15 files changed, 1592 insertions(+), 1295 deletions(-)
> >>   create mode 100644 app/test-crypto-perf/cperf_test_verify.c
> >>   create mode 100644 app/test-crypto-perf/cperf_test_verify.h
> >>   delete mode 100644 app/test-crypto-perf/cperf_verify_parser.c
> >>
> >> --
> >> 2.7.4
> > Changes in v2:
> > - Split previous third patch into new four patches (6-9)
> > - Removed unused functions
> > - Fixed AES CBC 128 test vectors
> >
> Acked-by: Sergio Gonzalez Monroy <sergio.gonzalez.monroy@intel.com>

Applied to dpdk-next-crypto.

Pablo