[dpdk-dev] [PATCH v3 2/3] app/test: updating AES SHA performance test

["Jain, Deepak K" <deepak.k.jain@intel.com>]

From: Fiona Trahe <fiona.trahe@intel.com>

Updating the AES performance test in line with snow3g peformance test.
Output format has been updated so as to get better understanding of numbers.

Signed-off-by: Fiona Trahe <fiona.trahe@intel.com>
Signed-off-by: Jain, Deepak K <deepak.k.jain@intel.com>
---
 app/test/test_cryptodev.h      |   2 +
 app/test/test_cryptodev_perf.c | 551 +++++++++++++++++++++++++++--------------
 2 files changed, 370 insertions(+), 183 deletions(-)

diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h
index d549eca..382802c 100644
--- a/app/test/test_cryptodev.h
+++ b/app/test/test_cryptodev.h
@@ -64,7 +64,9 @@
 #define AES_XCBC_MAC_KEY_SZ			(16)
 
 #define TRUNCATED_DIGEST_BYTE_LENGTH_SHA1		(12)
+#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA224		(16)
 #define TRUNCATED_DIGEST_BYTE_LENGTH_SHA256		(16)
+#define TRUNCATED_DIGEST_BYTE_LENGTH_SHA384		(24)
 #define TRUNCATED_DIGEST_BYTE_LENGTH_SHA512		(32)
 
 #endif /* TEST_CRYPTODEV_H_ */
diff --git a/app/test/test_cryptodev_perf.c b/app/test/test_cryptodev_perf.c
index 52a2a72..e3778a9 100644
--- a/app/test/test_cryptodev_perf.c
+++ b/app/test/test_cryptodev_perf.c
@@ -492,12 +492,11 @@ const char plaintext_quote[] =
 #define CIPHER_KEY_LENGTH_AES_CBC	(16)
 #define CIPHER_IV_LENGTH_AES_CBC	(CIPHER_KEY_LENGTH_AES_CBC)
 
-
-static uint8_t aes_cbc_key[] = {
+static uint8_t aes_cbc_128_key[] = {
 		0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 		0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
 
-static uint8_t aes_cbc_iv[] = {
+static uint8_t aes_cbc_128_iv[] = {
 		0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
 		0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
 
@@ -1846,7 +1845,7 @@ test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
 
 	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
 	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
-	ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
+	ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
 	ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
 
 
@@ -1902,7 +1901,7 @@ test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
 		op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
 		op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
 
-		rte_memcpy(op->sym->cipher.iv.data, aes_cbc_iv,
+		rte_memcpy(op->sym->cipher.iv.data, aes_cbc_128_iv,
 				CIPHER_IV_LENGTH_AES_CBC);
 
 		op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
@@ -1985,169 +1984,6 @@ test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
 }
 
 static int
-test_perf_AES_CBC_HMAC_SHA256_encrypt_digest_vary_req_size(uint16_t dev_num)
-{
-	uint16_t index;
-	uint32_t burst_sent, burst_received;
-	uint32_t b, num_sent, num_received;
-	uint64_t failed_polls, retries, start_cycles, end_cycles;
-	const uint64_t mhz = rte_get_tsc_hz()/1000000;
-	double throughput, mmps;
-
-	struct rte_crypto_op *c_ops[DEFAULT_BURST_SIZE];
-	struct rte_crypto_op *proc_ops[DEFAULT_BURST_SIZE];
-
-	struct crypto_testsuite_params *ts_params = &testsuite_params;
-	struct crypto_unittest_params *ut_params = &unittest_params;
-	struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
-
-	if (rte_cryptodev_count() == 0) {
-		printf("\nNo crypto devices available. Is kernel driver loaded?\n");
-		return TEST_FAILED;
-	}
-
-	/* Setup Cipher Parameters */
-	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-	ut_params->cipher_xform.next = &ut_params->auth_xform;
-
-	ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
-	ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
-	ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
-	ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
-
-	/* Setup HMAC Parameters */
-	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-	ut_params->auth_xform.next = NULL;
-
-	ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
-	ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
-	ut_params->auth_xform.auth.key.data = hmac_sha256_key;
-	ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
-	ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
-
-	/* Create Crypto session*/
-	ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
-			&ut_params->cipher_xform);
-
-	TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
-
-	printf("\nThroughput test which will continually attempt to send "
-			"AES128_CBC_SHA256_HMAC requests with a constant burst "
-			"size of %u while varying payload sizes", DEFAULT_BURST_SIZE);
-	printf("\nDev No\tQP No\tReq Size(B)\tNum Sent\tNum Received\t"
-			"Mrps\tThoughput(Gbps)");
-	printf("\tRetries (Attempted a burst, but the device was busy)");
-	for (index = 0; index < MAX_PACKET_SIZE_INDEX; index++) {
-		num_sent = 0;
-		num_received = 0;
-		retries = 0;
-		failed_polls = 0;
-
-		/* Generate Crypto op data structure(s) */
-		for (b = 0; b < DEFAULT_BURST_SIZE ; b++) {
-			struct rte_mbuf *m = setup_test_string(
-					ts_params->mbuf_mp,
-					(const uint8_t *)
-					data_params[index].plaintext,
-					data_params[index].length,
-					0);
-
-			ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
-					DIGEST_BYTE_LENGTH_SHA256);
-			TEST_ASSERT_NOT_NULL(ut_params->digest
-					, "no room to append digest");
-
-			rte_memcpy(ut_params->digest,
-					data_params[index].expected.digest,
-					DIGEST_BYTE_LENGTH_SHA256);
-
-			struct rte_crypto_op *op = rte_crypto_op_alloc(
-					ts_params->op_mpool,
-					RTE_CRYPTO_OP_TYPE_SYMMETRIC);
-
-			rte_crypto_op_attach_sym_session(op, ut_params->sess);
-
-			op->sym->auth.digest.data = ut_params->digest;
-			op->sym->auth.digest.phys_addr =
-					rte_pktmbuf_mtophys_offset(m,
-						data_params[index].length);
-			op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
-
-			op->sym->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
-			op->sym->auth.data.length = data_params[index].length;
-
-			op->sym->cipher.iv.data = (uint8_t *)
-					rte_pktmbuf_prepend(m,
-						CIPHER_IV_LENGTH_AES_CBC);
-			op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
-			op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
-
-			rte_memcpy(op->sym->cipher.iv.data, aes_cbc_iv,
-					CIPHER_IV_LENGTH_AES_CBC);
-
-			op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
-			op->sym->cipher.data.length = data_params[index].length;
-
-
-			op->sym->m_src = m;
-
-			c_ops[b] = op;
-		}
-		start_cycles = rte_rdtsc_precise();
-		while (num_sent < DEFAULT_NUM_REQS_TO_SUBMIT) {
-			uint16_t burst_size = (DEFAULT_NUM_REQS_TO_SUBMIT -
-					num_sent) < DEFAULT_BURST_SIZE ?
-						DEFAULT_NUM_REQS_TO_SUBMIT -
-						num_sent : DEFAULT_BURST_SIZE;
-
-			burst_sent = rte_cryptodev_enqueue_burst(
-					dev_num, 0, c_ops, burst_size);
-			if (burst_sent == 0)
-				retries++;
-			else
-				num_sent += burst_sent;
-
-			burst_received = rte_cryptodev_dequeue_burst(dev_num,
-					0, proc_ops, DEFAULT_BURST_SIZE);
-			if (burst_received == 0)
-				failed_polls++;
-			else
-				num_received += burst_received;
-		}
-		while (num_received != DEFAULT_NUM_REQS_TO_SUBMIT) {
-			if (gbl_cryptodev_preftest_devtype ==
-					RTE_CRYPTODEV_AESNI_MB_PMD)
-				rte_cryptodev_enqueue_burst(dev_num, 0,
-						NULL, 0);
-
-			burst_received = rte_cryptodev_dequeue_burst(
-					dev_num, 0, proc_ops,
-					DEFAULT_BURST_SIZE);
-			if (burst_received == 0)
-				failed_polls++;
-			else
-				num_received += burst_received;
-		}
-		end_cycles = rte_rdtsc_precise();
-		mmps = ((double)num_received * mhz) /
-				(end_cycles - start_cycles);
-		throughput = (mmps * data_params[index].length * 8) / 1000;
-
-		printf("\n%u\t%u\t%u\t\t%u\t%u", dev_num, 0,
-				data_params[index].length,
-				num_sent, num_received);
-		printf("\t%.2f\t%.2f", mmps, throughput);
-		printf("\t\t%"PRIu64, retries);
-		for (b = 0; b < DEFAULT_BURST_SIZE ; b++) {
-			rte_pktmbuf_free(c_ops[b]->sym->m_src);
-			rte_crypto_op_free(c_ops[b]);
-		}
-	}
-
-	printf("\n");
-	return TEST_SUCCESS;
-}
-static int
 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
 {
 	uint32_t num_to_submit = pparams->total_operations;
@@ -2319,6 +2155,16 @@ static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
 	switch (algo) {
 	case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
 		return 16;
+	case RTE_CRYPTO_AUTH_SHA1_HMAC:
+		return 64;
+	case RTE_CRYPTO_AUTH_SHA224_HMAC:
+		return 64;
+	case RTE_CRYPTO_AUTH_SHA256_HMAC:
+		return 64;
+	case RTE_CRYPTO_AUTH_SHA384_HMAC:
+		return 128;
+	case RTE_CRYPTO_AUTH_SHA512_HMAC:
+		return 128;
 	default:
 		return 0;
 	}
@@ -2329,11 +2175,52 @@ static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
 	switch (algo) {
 	case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
 		return 4;
+	case RTE_CRYPTO_AUTH_SHA1_HMAC:
+		return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
+	case RTE_CRYPTO_AUTH_SHA224_HMAC:
+		return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
+	case RTE_CRYPTO_AUTH_SHA256_HMAC:
+		return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
+	case RTE_CRYPTO_AUTH_SHA384_HMAC:
+		return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
+	case RTE_CRYPTO_AUTH_SHA512_HMAC:
+		return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
 	default:
 		return 0;
 	}
 }
 
+static uint8_t aes_cbc_key[] = {
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static uint8_t aes_cbc_iv[] = {
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static uint8_t hmac_sha_key[] = {
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
 static uint8_t snow3g_cipher_key[] = {
 		0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
 		0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
@@ -2350,6 +2237,49 @@ static uint8_t snow3g_hash_key[] = {
 };
 
 static struct rte_cryptodev_sym_session *
+test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
+		enum rte_crypto_cipher_algorithm cipher_algo,
+		unsigned cipher_key_len,
+		enum rte_crypto_auth_algorithm auth_algo)
+{
+	struct rte_crypto_sym_xform cipher_xform = { 0 };
+	struct rte_crypto_sym_xform auth_xform = { 0 };
+
+
+	/* Setup Cipher Parameters */
+	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cipher_xform.cipher.algo = cipher_algo;
+	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+
+	cipher_xform.cipher.key.data = aes_cbc_key;
+	cipher_xform.cipher.key.length = cipher_key_len;
+
+	/* Setup HMAC Parameters */
+	auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+	auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
+	auth_xform.auth.algo = auth_algo;
+
+	auth_xform.auth.key.data = hmac_sha_key;
+	auth_xform.auth.key.length =  get_auth_key_max_length(auth_algo);
+	auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
+
+	switch (chain) {
+	case CIPHER_HASH:
+		cipher_xform.next = &auth_xform;
+		auth_xform.next = NULL;
+		/* Create Crypto session*/
+		return rte_cryptodev_sym_session_create(dev_id,	&cipher_xform);
+	case HASH_CIPHER:
+		auth_xform.next = &cipher_xform;
+		cipher_xform.next = NULL;
+		/* Create Crypto session*/
+		return rte_cryptodev_sym_session_create(dev_id,	&auth_xform);
+	default:
+		return NULL;
+	}
+}
+
+static struct rte_cryptodev_sym_session *
 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
 		enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
 		enum rte_crypto_auth_algorithm auth_algo)
@@ -2399,6 +2329,8 @@ test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
 	}
 }
 
+#define AES_CBC_BLOCK_SIZE 16
+#define AES_CBC_CIPHER_IV_LENGTH 16
 #define SNOW3G_CIPHER_IV_LENGTH 16
 
 static struct rte_mbuf *
@@ -2416,6 +2348,39 @@ test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
 	return m;
 }
 
+static inline struct rte_crypto_op *
+test_perf_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
+		struct rte_cryptodev_sym_session *sess, unsigned data_len,
+		unsigned digest_len)
+{
+	if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
+		rte_crypto_op_free(op);
+		return NULL;
+	}
+
+	/* Authentication Parameters */
+	op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
+					(m->data_off + data_len);
+	op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len);
+	op->sym->auth.digest.length = digest_len;
+	op->sym->auth.aad.data = aes_cbc_iv;
+	op->sym->auth.aad.length = AES_CBC_CIPHER_IV_LENGTH;
+
+	/* Cipher Parameters */
+	op->sym->cipher.iv.data = aes_cbc_iv;
+	op->sym->cipher.iv.length = AES_CBC_CIPHER_IV_LENGTH;
+
+	/* Data lengths/offsets Parameters */
+	op->sym->auth.data.offset = 0;
+	op->sym->auth.data.length = data_len;
+
+	op->sym->cipher.data.offset = AES_CBC_BLOCK_SIZE;
+	op->sym->cipher.data.length = data_len - AES_CBC_BLOCK_SIZE;
+
+	op->sym->m_src = m;
+
+	return op;
+}
 
 static inline struct rte_crypto_op *
 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
@@ -2459,6 +2424,135 @@ test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
 #define NUM_MBUF_SETS 8
 
 static int
+test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
+		struct perf_test_params *pparams)
+{
+	uint16_t i, k, l, m;
+	uint16_t j = 0;
+	uint16_t ops_unused = 0;
+
+	uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
+	uint64_t processed = 0, failed_polls = 0, retries = 0;
+	uint64_t tsc_start = 0, tsc_end = 0;
+
+	uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
+
+	struct rte_crypto_op *ops[pparams->burst_size];
+	struct rte_crypto_op *proc_ops[pparams->burst_size];
+
+	struct rte_mbuf *mbufs[pparams->burst_size * 8];
+
+	struct crypto_testsuite_params *ts_params = &testsuite_params;
+
+	static struct rte_cryptodev_sym_session *sess;
+
+	if (rte_cryptodev_count() == 0) {
+		printf("\nNo crypto devices available. Is kernel driver loaded?\n");
+		return TEST_FAILED;
+	}
+
+	/* Create Crypto session*/
+	sess = test_perf_create_aes_sha_session(ts_params->dev_id,
+			pparams->chain, pparams->cipher_algo,
+			pparams->cipher_key_length, pparams->auth_algo);
+	TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
+
+	/* Generate a burst of crypto operations */
+	for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
+		struct rte_mbuf *m = test_perf_create_pktmbuf(
+				ts_params->mbuf_mp,
+				pparams->buf_size);
+
+		if (m == NULL) {
+			printf("\nFailed to get mbuf - freeing the rest.\n");
+			for (k = 0; k < i; k++)
+				rte_pktmbuf_free(mbufs[k]);
+			return -1;
+		}
+
+		mbufs[i] = m;
+	}
+
+
+	tsc_start = rte_rdtsc_precise();
+
+	while (total_enqueued < pparams->total_operations) {
+		uint16_t burst_size =
+		total_enqueued+pparams->burst_size <= pparams->total_operations ?
+		pparams->burst_size : pparams->total_operations-total_enqueued;
+		uint16_t ops_needed = burst_size-ops_unused;
+
+		if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
+				RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
+			printf("\nFailed to alloc enough ops, finish dequeuing "
+				"and free ops below.");
+		} else {
+			for (i = 0; i < ops_needed; i++)
+				ops[i] = test_perf_set_crypto_op(ops[i],
+					mbufs[i + (pparams->burst_size *
+						(j % NUM_MBUF_SETS))],
+					sess, pparams->buf_size, digest_length);
+
+			/* enqueue burst */
+			burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
+					queue_id, ops, burst_size);
+
+			if (burst_enqueued < burst_size)
+				retries++;
+
+			ops_unused = burst_size-burst_enqueued;
+			total_enqueued += burst_enqueued;
+		}
+
+		/* dequeue burst */
+		burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
+				proc_ops, pparams->burst_size);
+		if (burst_dequeued == 0)
+			failed_polls++;
+		else {
+			processed += burst_dequeued;
+
+			for (l = 0; l < burst_dequeued; l++)
+				rte_crypto_op_free(proc_ops[l]);
+		}
+		j++;
+	}
+
+	/* Dequeue any operations still in the crypto device */
+	while (processed < pparams->total_operations) {
+		/* Sending 0 length burst to flush sw crypto device */
+		rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
+
+		/* dequeue burst */
+		burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
+				proc_ops, pparams->burst_size);
+		if (burst_dequeued == 0)
+			failed_polls++;
+		else {
+			processed += burst_dequeued;
+
+			for (m = 0; m < burst_dequeued; m++)
+				rte_crypto_op_free(proc_ops[m]);
+		}
+	}
+
+	tsc_end = rte_rdtsc_precise();
+
+	double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
+	double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
+
+	printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
+			throughput, retries, failed_polls);
+
+	for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
+		rte_pktmbuf_free(mbufs[i]);
+
+	printf("\n");
+	return TEST_SUCCESS;
+}
+
+
+static int
 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
 		struct perf_test_params *pparams)
 {
@@ -2606,6 +2700,95 @@ test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
 	return TEST_SUCCESS;
 }
 
+/*
+
+    perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
+    perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
+    perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
+
+    perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
+    perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
+    perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
+
+    perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
+    perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
+    perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
+ */
+static int
+test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
+{
+	unsigned total_operations = 1000000;
+	unsigned burst_size = 32;
+	unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
+	uint8_t i, j;
+
+	struct perf_test_params params_set[] = {
+		{
+			.chain = CIPHER_HASH,
+
+			.cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
+			.cipher_key_length = 16,
+			.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
+		},
+		{
+			.chain = CIPHER_HASH,
+
+			.cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
+			.cipher_key_length = 16,
+			.auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
+		},
+		{
+			.chain = CIPHER_HASH,
+
+			.cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
+			.cipher_key_length = 16,
+			.auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
+		},
+		{
+			.chain = CIPHER_HASH,
+
+			.cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
+			.cipher_key_length = 32,
+			.auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
+		},
+		{
+			.chain = CIPHER_HASH,
+
+			.cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
+			.cipher_key_length = 32,
+			.auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
+		},
+		{
+			.chain = CIPHER_HASH,
+
+			.cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
+			.cipher_key_length = 32,
+			.auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
+		},
+	};
+
+	for (i = 0; i < RTE_DIM(params_set); i++) {
+
+		params_set[i].total_operations = total_operations;
+		params_set[i].burst_size = burst_size;
+		printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
+				" burst_size: %d ops\n",
+				chain_mode_name(params_set[i].chain),
+				cipher_algo_name(params_set[i].cipher_algo),
+				auth_algo_name(params_set[i].auth_algo),
+				params_set[i].cipher_key_length,
+				burst_size);
+		printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
+			"Retries\tEmptyPolls\n");
+		for (j = 0; j < RTE_DIM(buf_lengths); j++) {
+			params_set[i].buf_size = buf_lengths[j];
+			test_perf_aes_sha(testsuite_params.dev_id, 0,
+					&params_set[i]);
+		}
+	}
+	return 0;
+}
+
 static int
 test_perf_snow3G_vary_pkt_size(void)
 {
@@ -2651,9 +2834,7 @@ test_perf_snow3G_vary_pkt_size(void)
 			params_set[i].burst_size = burst_sizes[k];
 			printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
 				"Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
-			for (j = 0;
-				j < RTE_DIM(buf_lengths);
-				j++) {
+			for (j = 0; j < RTE_DIM(buf_lengths); j++) {
 
 				params_set[i].buf_size = buf_lengths[j];
 
@@ -2666,28 +2847,32 @@ test_perf_snow3G_vary_pkt_size(void)
 }
 
 static int
-test_perf_encrypt_digest_vary_req_size(void)
-{
-	return test_perf_AES_CBC_HMAC_SHA256_encrypt_digest_vary_req_size(
-			testsuite_params.dev_id);
-}
-
-static int
-test_perf_vary_burst_size(void)
+test_perf_aes_cbc_vary_burst_size(void)
 {
 	return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
 }
 
-
+#if 1
 static struct unit_test_suite cryptodev_testsuite  = {
 	.suite_name = "Crypto Device Unit Test Suite",
 	.setup = testsuite_setup,
 	.teardown = testsuite_teardown,
 	.unit_test_cases = {
 		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_perf_encrypt_digest_vary_req_size),
+				test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+				test_perf_aes_cbc_vary_burst_size),
+		TEST_CASES_END() /**< NULL terminate unit test array */
+	}
+};
+#endif
+static struct unit_test_suite cryptodev_aes_testsuite  = {
+	.suite_name = "Crypto Device AESNI MB Unit Test Suite",
+	.setup = testsuite_setup,
+	.teardown = testsuite_teardown,
+	.unit_test_cases = {
 		TEST_CASE_ST(ut_setup, ut_teardown,
-				test_perf_vary_burst_size),
+				test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
@@ -2710,7 +2895,7 @@ perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
 {
 	gbl_cryptodev_preftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
 
-	return unit_test_suite_runner(&cryptodev_testsuite);
+	return unit_test_suite_runner(&cryptodev_aes_testsuite);
 }
 
 static int
-- 
2.5.5