[dpdk-dev] [PATCH v2 4/4] app/crypto-perf: add support for multi-function processing

[David Coyle <david.coyle@intel.com>]

Support for multi-function operations, via a raw device, has been
added to the test-crypto-perf app.

A new optype has been added: multi-fn
A new parameter has been added for multi-fn mode:
--multi-fn-params <params>

The <params> field specify what type of multi-function processing
is required and the options associated with that. Currently the
following are supported:

docsis-cipher-crc,<cipher_offset>,<crc_offset>
pon-cipher-crc-bip,<buffer_padding_sz>

Signed-off-by: David Coyle <david.coyle@intel.com>
Signed-off-by: Mairtin o Loingsigh <mairtin.oloingsigh@intel.com>
---
 app/test-crypto-perf/Makefile                 |   5 +
 app/test-crypto-perf/cperf_ops.c              | 265 ++++++++++++
 app/test-crypto-perf/cperf_options.h          |  37 +-
 app/test-crypto-perf/cperf_options_parsing.c  | 396 ++++++++++++++++--
 app/test-crypto-perf/cperf_test_common.c      |  88 +++-
 app/test-crypto-perf/cperf_test_latency.c     | 176 ++++++--
 .../cperf_test_pmd_cyclecount.c               |  96 ++++-
 app/test-crypto-perf/cperf_test_throughput.c  | 164 ++++++--
 .../cperf_test_vector_parsing.c               |  35 +-
 app/test-crypto-perf/cperf_test_vectors.c     |  53 +++
 app/test-crypto-perf/cperf_test_vectors.h     |   9 +
 app/test-crypto-perf/cperf_test_verify.c      | 205 +++++++--
 app/test-crypto-perf/main.c                   | 255 +++++++++--
 app/test-crypto-perf/meson.build              |   6 +
 14 files changed, 1584 insertions(+), 206 deletions(-)

diff --git a/app/test-crypto-perf/Makefile b/app/test-crypto-perf/Makefile
index 78135f38c..baf706e4a 100644
--- a/app/test-crypto-perf/Makefile
+++ b/app/test-crypto-perf/Makefile
@@ -26,4 +26,9 @@ ifeq ($(CONFIG_RTE_LIBRTE_PMD_CRYPTO_SCHEDULER),y)
 LDLIBS += -lrte_pmd_crypto_scheduler
 endif
 
+ifeq ($(CONFIG_RTE_LIBRTE_MULTI_FN_COMMON)$(CONFIG_RTE_LIBRTE_RAWDEV),yy)
+CFLAGS += -DMULTI_FN_SUPPORTED
+LDLIBS += -lrte_multi_fn
+endif
+
 include $(RTE_SDK)/mk/rte.app.mk
diff --git a/app/test-crypto-perf/cperf_ops.c b/app/test-crypto-perf/cperf_ops.c
index 97584ceed..29f294ac5 100644
--- a/app/test-crypto-perf/cperf_ops.c
+++ b/app/test-crypto-perf/cperf_ops.c
@@ -3,6 +3,10 @@
  */
 
 #include <rte_cryptodev.h>
+#include <rte_ether.h>
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 
 #include "cperf_ops.h"
 #include "cperf_test_vectors.h"
@@ -505,6 +509,168 @@ cperf_set_ops_aead(struct rte_crypto_op **ops,
 	return 0;
 }
 
+#ifdef MULTI_FN_SUPPORTED
+static int
+cperf_set_ops_multi_fn_cipher_crc(struct rte_crypto_op **ops,
+		uint32_t src_buf_offset, uint32_t dst_buf_offset __rte_unused,
+		uint16_t nb_ops, struct rte_cryptodev_sym_session *sess,
+		const struct cperf_options *options,
+		const struct cperf_test_vector *test_vector,
+		uint16_t iv_offset, uint32_t *imix_idx)
+{
+	uint32_t buffer_sz, offset;
+	uint16_t i;
+
+	for (i = 0; i < nb_ops; i++) {
+		struct rte_multi_fn_op *mf_op =
+					(struct rte_multi_fn_op *)ops[i];
+		struct rte_crypto_sym_op *cipher_op;
+		struct rte_multi_fn_err_detect_op *crc_op;
+		struct rte_multi_fn_op *mf_cipher_op;
+
+		mf_op->sess = (struct rte_multi_fn_session *)sess;
+		mf_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] +
+							src_buf_offset);
+		mf_op->m_dst = NULL;
+
+		if (options->imix_distribution_count) {
+			buffer_sz =
+				options->imix_buffer_sizes[*imix_idx];
+			*imix_idx = (*imix_idx + 1) % options->pool_sz;
+		} else
+			buffer_sz = options->test_buffer_size;
+
+		if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+			/* CRC -> Cipher */
+			crc_op = &mf_op->err_detect;
+			cipher_op = &mf_op->next->crypto_sym;
+			mf_cipher_op = mf_op->next;
+		} else {
+			/* Cipher -> CRC */
+			cipher_op = &mf_op->crypto_sym;
+			crc_op = &mf_op->next->err_detect;
+			mf_cipher_op = mf_op;
+		}
+
+		crc_op->data.offset = test_vector->multi_fn_data.crc_offset;
+		crc_op->data.length = buffer_sz - crc_op->data.offset -
+					RTE_ETHER_CRC_LEN;
+		offset = crc_op->data.offset + crc_op->data.length;
+		crc_op->output.data = rte_pktmbuf_mtod_offset(mf_op->m_src,
+								uint8_t *,
+								offset);
+		crc_op->output.phys_addr = rte_pktmbuf_iova_offset(mf_op->m_src,
+								offset);
+
+		cipher_op->cipher.data.offset = test_vector->data.cipher_offset;
+		cipher_op->cipher.data.length = buffer_sz -
+						cipher_op->cipher.data.offset;
+
+		if (options->test == CPERF_TEST_TYPE_VERIFY) {
+			uint8_t *iv_ptr = (uint8_t *)mf_cipher_op + iv_offset;
+			memcpy(iv_ptr, test_vector->cipher_iv.data,
+					test_vector->cipher_iv.length);
+		}
+	}
+
+	return 0;
+}
+
+#define PLI_SHIFT_BITS 2
+
+static int
+cperf_set_ops_multi_fn_cipher_crc_bip(struct rte_crypto_op **ops,
+		uint32_t src_buf_offset, uint32_t dst_buf_offset __rte_unused,
+		uint16_t nb_ops, struct rte_cryptodev_sym_session *sess,
+		const struct cperf_options *options,
+		const struct cperf_test_vector *test_vector, uint16_t iv_offset,
+		uint32_t *imix_idx)
+{
+	uint32_t buffer_sz, offset;
+	uint16_t i;
+	int crc_len;
+
+	for (i = 0; i < nb_ops; i++) {
+		struct rte_multi_fn_op *mf_op =
+					(struct rte_multi_fn_op *)ops[i];
+		struct rte_crypto_sym_op *cipher_op;
+		struct rte_multi_fn_err_detect_op *crc_op;
+		struct rte_multi_fn_err_detect_op *bip_op;
+		struct rte_multi_fn_op *mf_cipher_op;
+
+		mf_op->sess = (struct rte_multi_fn_session *)sess;
+		mf_op->m_src = (struct rte_mbuf *)((uint8_t *)ops[i] +
+							src_buf_offset);
+		mf_op->m_dst = NULL;
+
+		if (options->imix_distribution_count) {
+			buffer_sz =
+				options->imix_buffer_sizes[*imix_idx];
+			*imix_idx = (*imix_idx + 1) % options->pool_sz;
+		} else
+			buffer_sz = options->test_buffer_size;
+
+		if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+			/* CRC -> Cipher -> BIP */
+			crc_op = &mf_op->err_detect;
+			cipher_op = &mf_op->next->crypto_sym;
+			bip_op = &mf_op->next->next->err_detect;
+		} else {
+			/* BIP-> Cipher -> CRC */
+			bip_op = &mf_op->err_detect;
+			cipher_op = &mf_op->next->crypto_sym;
+			crc_op = &mf_op->next->next->err_detect;
+		}
+		mf_cipher_op = mf_op->next;
+
+		crc_op->data.offset = test_vector->multi_fn_data.crc_offset;
+		crc_len = buffer_sz - crc_op->data.offset -
+				options->multi_fn_opts.buffer_padding -
+				RTE_ETHER_CRC_LEN;
+		crc_len = crc_len > 0 ? crc_len : 0;
+		crc_op->data.length = crc_len;
+		offset = crc_op->data.offset + crc_op->data.length;
+		crc_op->output.data = rte_pktmbuf_mtod_offset(mf_op->m_src,
+								uint8_t *,
+								offset);
+		crc_op->output.phys_addr = rte_pktmbuf_iova_offset(mf_op->m_src,
+								offset);
+
+		cipher_op->cipher.data.offset = test_vector->data.cipher_offset;
+		cipher_op->cipher.data.length = buffer_sz -
+						cipher_op->cipher.data.offset;
+
+		bip_op->data.offset = test_vector->multi_fn_data.bip_offset;
+		bip_op->data.length = buffer_sz - bip_op->data.offset;
+		offset = options->test_buffer_size;
+		bip_op->output.data = rte_pktmbuf_mtod_offset(mf_op->m_src,
+								uint8_t *,
+								offset);
+		bip_op->output.phys_addr = rte_pktmbuf_iova_offset(mf_op->m_src,
+								offset);
+
+		if (options->test == CPERF_TEST_TYPE_VERIFY) {
+			uint8_t *iv_ptr = (uint8_t *)mf_cipher_op + iv_offset;
+			memcpy(iv_ptr, test_vector->cipher_iv.data,
+					test_vector->cipher_iv.length);
+		}
+
+		/*
+		 * This is very protocol specific but IPSec MB uses the PLI
+		 * (Payload Length Indication) field of the PON frame header
+		 * to get the CRC length. So set the PLI here now
+		 */
+		uint16_t *pli_key_idx = rte_pktmbuf_mtod(mf_op->m_src,
+								uint16_t *);
+		uint16_t pli = cipher_op->cipher.data.length -
+				options->multi_fn_opts.buffer_padding;
+		*pli_key_idx = rte_bswap16(pli) << PLI_SHIFT_BITS;
+	}
+
+	return 0;
+}
+#endif /* MULTI_FN_SUPPORTED */
+
 static struct rte_cryptodev_sym_session *
 cperf_create_session(struct rte_mempool *sess_mp,
 	struct rte_mempool *priv_mp,
@@ -590,6 +756,90 @@ cperf_create_session(struct rte_mempool *sess_mp,
 					&sess_conf, sess_mp);
 	}
 #endif
+
+#ifdef MULTI_FN_SUPPORTED
+	/*
+	 * multi function
+	 */
+	if (options->op_type == CPERF_MULTI_FN) {
+		struct rte_multi_fn_xform mf_cipher_xform;
+		struct rte_multi_fn_xform mf_crc_xform;
+		struct rte_multi_fn_xform mf_bip_xform;
+		struct rte_multi_fn_xform *first_xform = NULL;
+		struct rte_crypto_cipher_xform *cipher_xform;
+
+		if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC ||
+			options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+
+			mf_cipher_xform.type =
+				RTE_MULTI_FN_XFORM_TYPE_CRYPTO_SYM;
+			mf_cipher_xform.crypto_sym.type =
+				RTE_CRYPTO_SYM_XFORM_CIPHER;
+			cipher_xform = &mf_cipher_xform.crypto_sym.cipher;
+			cipher_xform->algo = options->cipher_algo;
+			cipher_xform->op = options->cipher_op;
+			cipher_xform->iv.offset = iv_offset;
+			cipher_xform->key.data = test_vector->cipher_key.data;
+			cipher_xform->key.length =
+						test_vector->cipher_key.length;
+			cipher_xform->iv.length = test_vector->cipher_iv.length;
+
+			mf_crc_xform.type =
+				RTE_MULTI_FN_XFORM_TYPE_ERR_DETECT;
+			mf_crc_xform.err_detect.algo =
+				RTE_MULTI_FN_ERR_DETECT_CRC32_ETH;
+
+			if (cipher_xform->op ==
+					RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+				mf_crc_xform.err_detect.op =
+					RTE_MULTI_FN_ERR_DETECT_OP_GENERATE;
+			} else {
+				mf_crc_xform.err_detect.op =
+					RTE_MULTI_FN_ERR_DETECT_OP_VERIFY;
+			}
+
+			mf_bip_xform.type =
+				RTE_MULTI_FN_XFORM_TYPE_ERR_DETECT;
+			mf_bip_xform.err_detect.algo =
+				RTE_MULTI_FN_ERR_DETECT_BIP32;
+			mf_bip_xform.err_detect.op =
+				RTE_MULTI_FN_ERR_DETECT_OP_GENERATE;
+
+			if (options->multi_fn_opts.ops ==
+					CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC) {
+				if (cipher_xform->op ==
+						RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+					first_xform = &mf_crc_xform;
+					mf_crc_xform.next = &mf_cipher_xform;
+					mf_cipher_xform.next = NULL;
+				} else {
+					first_xform = &mf_cipher_xform;
+					mf_cipher_xform.next = &mf_crc_xform;
+					mf_crc_xform.next = NULL;
+				}
+			} else {
+				if (cipher_xform->op ==
+						RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+					first_xform = &mf_crc_xform;
+					mf_crc_xform.next = &mf_cipher_xform;
+					mf_cipher_xform.next = &mf_bip_xform;
+					mf_bip_xform.next = NULL;
+				} else {
+					first_xform = &mf_bip_xform;
+					mf_bip_xform.next = &mf_cipher_xform;
+					mf_cipher_xform.next = &mf_crc_xform;
+					mf_crc_xform.next = NULL;
+				}
+			}
+		}
+
+		return (void *)rte_multi_fn_session_create(dev_id,
+					first_xform, rte_socket_id());
+	}
+#endif /* MULTI_FN_SUPPORTED */
+
 	sess = rte_cryptodev_sym_session_create(sess_mp);
 	/*
 	 * cipher only
@@ -773,5 +1023,20 @@ cperf_get_op_functions(const struct cperf_options *options,
 		return 0;
 	}
 #endif
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC)
+			op_fns->populate_ops =
+				cperf_set_ops_multi_fn_cipher_crc;
+		else if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP)
+			op_fns->populate_ops =
+				cperf_set_ops_multi_fn_cipher_crc_bip;
+		else
+			return -1;
+		return 0;
+	}
+#endif /* MULTI_FN_SUPPORTED */
 	return -1;
 }
diff --git a/app/test-crypto-perf/cperf_options.h b/app/test-crypto-perf/cperf_options.h
index 1ed0a77e5..0ca542224 100644
--- a/app/test-crypto-perf/cperf_options.h
+++ b/app/test-crypto-perf/cperf_options.h
@@ -10,6 +10,9 @@
 #ifdef RTE_LIBRTE_SECURITY
 #include <rte_security.h>
 #endif
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 
 #define CPERF_PTEST_TYPE	("ptest")
 #define CPERF_SILENT		("silent")
@@ -52,6 +55,10 @@
 #define CPERF_PDCP_DOMAIN	("pdcp-domain")
 #endif
 
+#ifdef MULTI_FN_SUPPORTED
+#define CPERF_MULTI_FN_PARAMS	("multi-fn-params")
+#endif /* MULTI_FN_SUPPORTED */
+
 #define CPERF_CSV		("csv-friendly")
 
 /* benchmark-specific options */
@@ -75,11 +82,34 @@ enum cperf_op_type {
 	CPERF_CIPHER_THEN_AUTH,
 	CPERF_AUTH_THEN_CIPHER,
 	CPERF_AEAD,
-	CPERF_PDCP
+	CPERF_PDCP,
+#ifdef MULTI_FN_SUPPORTED
+	CPERF_MULTI_FN
+#endif /* MULTI_FN_SUPPORTED */
 };
 
 extern const char *cperf_op_type_strs[];
 
+#ifdef MULTI_FN_SUPPORTED
+enum cperf_multi_fn_ops {
+	CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC,
+	CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP
+};
+
+extern const char *cperf_multi_fn_ops_strs[];
+
+struct cperf_multi_fn_options {
+	enum cperf_multi_fn_ops ops;
+
+	/* DOCSIS_CIPHER_CRC */
+	uint32_t cipher_offset;
+	uint32_t crc_offset;
+
+	/* PON_CIPHER_CRC_BIP */
+	uint32_t buffer_padding;
+};
+#endif /* MULTI_FN_SUPPORTED */
+
 struct cperf_options {
 	enum cperf_perf_test_type test;
 
@@ -123,6 +153,11 @@ struct cperf_options {
 	uint16_t pdcp_sn_sz;
 	enum rte_security_pdcp_domain pdcp_domain;
 #endif
+
+#ifdef MULTI_FN_SUPPORTED
+	struct cperf_multi_fn_options multi_fn_opts;
+#endif /* MULTI_FN_SUPPORTED */
+
 	char device_type[RTE_CRYPTODEV_NAME_MAX_LEN];
 	enum cperf_op_type op_type;
 
diff --git a/app/test-crypto-perf/cperf_options_parsing.c b/app/test-crypto-perf/cperf_options_parsing.c
index f43c5bede..25da68105 100644
--- a/app/test-crypto-perf/cperf_options_parsing.c
+++ b/app/test-crypto-perf/cperf_options_parsing.c
@@ -7,6 +7,7 @@
 
 #include <rte_cryptodev.h>
 #include <rte_malloc.h>
+#include <rte_ether.h>
 
 #include "cperf_options.h"
 
@@ -34,7 +35,7 @@ usage(char *progname)
 		" --desc-nb N: set number of descriptors for each crypto device\n"
 		" --devtype TYPE: set crypto device type to use\n"
 		" --optype cipher-only / auth-only / cipher-then-auth /\n"
-		"           auth-then-cipher / aead : set operation type\n"
+		"           auth-then-cipher / aead%s : set operation type\n"
 		" --sessionless: enable session-less crypto operations\n"
 		" --out-of-place: enable out-of-place crypto operations\n"
 		" --test-file NAME: set the test vector file path\n"
@@ -53,11 +54,20 @@ usage(char *progname)
 		" --aead-iv-sz N: set the AEAD IV size\n"
 		" --aead-aad-sz N: set the AEAD AAD size\n"
 		" --digest-sz N: set the digest size\n"
+#ifdef MULTI_FN_SUPPORTED
+		" --multi-fn-params PARAMS: set multi function parameters\n"
+#endif /* MULTI_FN_SUPPORTED */
 		" --pmd-cyclecount-delay-ms N: set delay between enqueue\n"
 		"           and dequeue in pmd-cyclecount benchmarking mode\n"
 		" --csv-friendly: enable test result output CSV friendly\n"
 		" -h: prints this help\n",
-		progname);
+		progname,
+#ifdef MULTI_FN_SUPPORTED
+		" / multi-fn"
+#else
+		""
+#endif /* MULTI_FN_SUPPORTED */
+		);
 }
 
 static int
@@ -446,7 +456,13 @@ parse_op_type(struct cperf_options *opts, const char *arg)
 		{
 			cperf_op_type_strs[CPERF_PDCP],
 			CPERF_PDCP
+		},
+#ifdef MULTI_FN_SUPPORTED
+		{
+			cperf_op_type_strs[CPERF_MULTI_FN],
+			CPERF_MULTI_FN
 		}
+#endif /* MULTI_FN_SUPPORTED */
 	};
 
 	int id = get_str_key_id_mapping(optype_namemap,
@@ -744,6 +760,112 @@ parse_aead_aad_sz(struct cperf_options *opts, const char *arg)
 	return parse_uint16_t(&opts->aead_aad_sz, arg);
 }
 
+#ifdef MULTI_FN_SUPPORTED
+static int
+parse_multi_fn_ops(struct cperf_options *opts, const char *arg)
+{
+	struct name_id_map multi_fn_ops_namemap[] = {
+		{
+			cperf_multi_fn_ops_strs
+			[CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC],
+			CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC
+		},
+		{
+			cperf_multi_fn_ops_strs
+			[CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP],
+			CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP
+		}
+	};
+
+	int id = get_str_key_id_mapping(multi_fn_ops_namemap,
+			RTE_DIM(multi_fn_ops_namemap), arg);
+	if (id < 0) {
+		RTE_LOG(ERR, USER1, "invalid multi function operation specified\n");
+		return -1;
+	}
+
+	opts->multi_fn_opts.ops = (enum cperf_multi_fn_ops)id;
+
+	return 0;
+}
+
+static int
+parse_multi_fn_params(struct cperf_options *opts, const char *arg)
+{
+	char *token;
+	char *copy_arg = strdup(arg);
+
+	if (copy_arg == NULL)
+		return -1;
+
+	errno = 0;
+	token = strtok(copy_arg, ",");
+
+	/* Parse first value */
+	if (token == NULL || parse_multi_fn_ops(opts, token) < 0)
+		goto err_multi_fn_opts;
+
+	if (opts->multi_fn_opts.ops ==
+			CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC) {
+		/* Next params is cipher_offset */
+		token = strtok(NULL, ",");
+
+		if (token == NULL ||
+			parse_uint32_t(&opts->multi_fn_opts.cipher_offset,
+					token) < 0) {
+			RTE_LOG(ERR, USER1, "invalid %s multi function cipher "
+				"offset specified\n",
+				cperf_multi_fn_ops_strs[
+						opts->multi_fn_opts.ops]);
+			goto err_multi_fn_opts;
+		}
+
+		/* Next params is crc_offset */
+		token = strtok(NULL, ",");
+
+		if (token == NULL ||
+			parse_uint32_t(&opts->multi_fn_opts.crc_offset,
+					token) < 0) {
+			RTE_LOG(ERR, USER1, "invalid %s multi function crc "
+				"offset specified\n",
+				cperf_multi_fn_ops_strs[
+						opts->multi_fn_opts.ops]);
+			goto err_multi_fn_opts;
+		}
+
+	} else if (opts->multi_fn_opts.ops ==
+			CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+		/* Next param is buffer_padding */
+		token = strtok(NULL, ",");
+
+		if (token == NULL ||
+			parse_uint32_t(&opts->multi_fn_opts.buffer_padding,
+					token) < 0) {
+			RTE_LOG(ERR, USER1, "invalid %s multi function buffer "
+				"padding specified\n",
+				cperf_multi_fn_ops_strs[
+						opts->multi_fn_opts.ops]);
+			goto err_multi_fn_opts;
+		}
+	}
+
+	token = strtok(NULL, ",");
+
+	if (token != NULL) {
+		RTE_LOG(ERR, USER1, "unknown %s multi function parameter\n",
+			cperf_multi_fn_ops_strs[opts->multi_fn_opts.ops]);
+		goto err_multi_fn_opts;
+	}
+
+	free(copy_arg);
+	return 0;
+
+err_multi_fn_opts:
+	free(copy_arg);
+	return -1;
+}
+#endif /* MULTI_FN_SUPPORTED */
+
 static int
 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused)
 {
@@ -821,6 +943,11 @@ static struct option lgopts[] = {
 	{ CPERF_PDCP_SN_SZ, required_argument, 0, 0 },
 	{ CPERF_PDCP_DOMAIN, required_argument, 0, 0 },
 #endif
+
+#ifdef MULTI_FN_SUPPORTED
+	{ CPERF_MULTI_FN_PARAMS, required_argument, 0, 0 },
+#endif /* MULTI_FN_SUPPORTED */
+
 	{ CPERF_CSV, no_argument, 0, 0},
 
 	{ CPERF_PMDCC_DELAY_MS, required_argument, 0, 0 },
@@ -891,47 +1018,57 @@ cperf_options_default(struct cperf_options *opts)
 	opts->pdcp_sn_sz = 12;
 	opts->pdcp_domain = RTE_SECURITY_PDCP_MODE_CONTROL;
 #endif
+
+#ifdef MULTI_FN_SUPPORTED
+	opts->multi_fn_opts.ops = CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC;
+	opts->multi_fn_opts.cipher_offset = 0;
+	opts->multi_fn_opts.crc_offset = 0;
+	opts->multi_fn_opts.buffer_padding = 0;
+#endif /* MULTI_FN_SUPPORTED */
 }
 
 static int
 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts)
 {
 	struct long_opt_parser parsermap[] = {
-		{ CPERF_PTEST_TYPE,	parse_cperf_test_type },
-		{ CPERF_SILENT,		parse_silent },
-		{ CPERF_POOL_SIZE,	parse_pool_sz },
-		{ CPERF_TOTAL_OPS,	parse_total_ops },
-		{ CPERF_BURST_SIZE,	parse_burst_sz },
-		{ CPERF_BUFFER_SIZE,	parse_buffer_sz },
-		{ CPERF_SEGMENT_SIZE,	parse_segment_sz },
-		{ CPERF_DESC_NB,	parse_desc_nb },
-		{ CPERF_DEVTYPE,	parse_device_type },
-		{ CPERF_OPTYPE,		parse_op_type },
-		{ CPERF_SESSIONLESS,	parse_sessionless },
-		{ CPERF_OUT_OF_PLACE,	parse_out_of_place },
-		{ CPERF_IMIX,		parse_imix },
-		{ CPERF_TEST_FILE,	parse_test_file },
-		{ CPERF_TEST_NAME,	parse_test_name },
-		{ CPERF_CIPHER_ALGO,	parse_cipher_algo },
-		{ CPERF_CIPHER_OP,	parse_cipher_op },
-		{ CPERF_CIPHER_KEY_SZ,	parse_cipher_key_sz },
-		{ CPERF_CIPHER_IV_SZ,	parse_cipher_iv_sz },
-		{ CPERF_AUTH_ALGO,	parse_auth_algo },
-		{ CPERF_AUTH_OP,	parse_auth_op },
-		{ CPERF_AUTH_KEY_SZ,	parse_auth_key_sz },
-		{ CPERF_AUTH_IV_SZ,	parse_auth_iv_sz },
-		{ CPERF_AEAD_ALGO,	parse_aead_algo },
-		{ CPERF_AEAD_OP,	parse_aead_op },
-		{ CPERF_AEAD_KEY_SZ,	parse_aead_key_sz },
-		{ CPERF_AEAD_IV_SZ,	parse_aead_iv_sz },
-		{ CPERF_AEAD_AAD_SZ,	parse_aead_aad_sz },
-		{ CPERF_DIGEST_SZ,	parse_digest_sz },
+		{ CPERF_PTEST_TYPE,		parse_cperf_test_type },
+		{ CPERF_SILENT,			parse_silent },
+		{ CPERF_POOL_SIZE,		parse_pool_sz },
+		{ CPERF_TOTAL_OPS,		parse_total_ops },
+		{ CPERF_BURST_SIZE,		parse_burst_sz },
+		{ CPERF_BUFFER_SIZE,		parse_buffer_sz },
+		{ CPERF_SEGMENT_SIZE,		parse_segment_sz },
+		{ CPERF_DESC_NB,		parse_desc_nb },
+		{ CPERF_DEVTYPE,		parse_device_type },
+		{ CPERF_OPTYPE,			parse_op_type },
+		{ CPERF_SESSIONLESS,		parse_sessionless },
+		{ CPERF_OUT_OF_PLACE,		parse_out_of_place },
+		{ CPERF_IMIX,			parse_imix },
+		{ CPERF_TEST_FILE,		parse_test_file },
+		{ CPERF_TEST_NAME,		parse_test_name },
+		{ CPERF_CIPHER_ALGO,		parse_cipher_algo },
+		{ CPERF_CIPHER_OP,		parse_cipher_op },
+		{ CPERF_CIPHER_KEY_SZ,		parse_cipher_key_sz },
+		{ CPERF_CIPHER_IV_SZ,		parse_cipher_iv_sz },
+		{ CPERF_AUTH_ALGO,		parse_auth_algo },
+		{ CPERF_AUTH_OP,		parse_auth_op },
+		{ CPERF_AUTH_KEY_SZ,		parse_auth_key_sz },
+		{ CPERF_AUTH_IV_SZ,		parse_auth_iv_sz },
+		{ CPERF_AEAD_ALGO,		parse_aead_algo },
+		{ CPERF_AEAD_OP,		parse_aead_op },
+		{ CPERF_AEAD_KEY_SZ,		parse_aead_key_sz },
+		{ CPERF_AEAD_IV_SZ,		parse_aead_iv_sz },
+		{ CPERF_AEAD_AAD_SZ,		parse_aead_aad_sz },
+		{ CPERF_DIGEST_SZ,		parse_digest_sz },
 #ifdef RTE_LIBRTE_SECURITY
-		{ CPERF_PDCP_SN_SZ,	parse_pdcp_sn_sz },
-		{ CPERF_PDCP_DOMAIN,	parse_pdcp_domain },
+		{ CPERF_PDCP_SN_SZ,		parse_pdcp_sn_sz },
+		{ CPERF_PDCP_DOMAIN,		parse_pdcp_domain },
 #endif
-		{ CPERF_CSV,		parse_csv_friendly},
-		{ CPERF_PMDCC_DELAY_MS,	parse_pmd_cyclecount_delay_ms},
+#ifdef MULTI_FN_SUPPORTED
+		{ CPERF_MULTI_FN_PARAMS,	parse_multi_fn_params },
+#endif /* MULTI_FN_SUPPORTED */
+		{ CPERF_CSV,			parse_csv_friendly },
+		{ CPERF_PMDCC_DELAY_MS,		parse_pmd_cyclecount_delay_ms },
 	};
 	unsigned int i;
 
@@ -1031,6 +1168,155 @@ check_cipher_buffer_length(struct cperf_options *options)
 	return 0;
 }
 
+#ifdef MULTI_FN_SUPPORTED
+#define DOCSIS_CIPHER_CRC_OFFSET_DIFF (RTE_ETHER_HDR_LEN - RTE_ETHER_TYPE_LEN)
+#define DOCSIS_MIN_CIPHER_SIZE        (RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN)
+
+#define PON_FRAME_HDR_SIZE      (8U)
+#define PON_FRAME_MULTIPLE_SIZE (4)
+#define PON_FRAME_INVALID_SIZE  (12)
+
+static int
+check_multi_fn_options(struct cperf_options *options)
+{
+	uint32_t buffer_size, buffer_size_idx = 0;
+
+	options->digest_sz = 0;
+
+	if (options->multi_fn_opts.ops ==
+			CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC ||
+		options->multi_fn_opts.ops ==
+			CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+
+		/* Check the device type is a rawdev */
+		if (strcmp(options->device_type, "rawdev_aesni_mb") != 0) {
+			RTE_LOG(ERR, USER1, "Invalid device type %s for "
+				"multi-function\n",
+				options->device_type);
+			return -EINVAL;
+		}
+
+		/* Only single segment supported */
+		if (options->segment_sz < options->max_buffer_size) {
+			RTE_LOG(ERR, USER1, "Segmented buffers not supported "
+				"for multi-function\n");
+			return -EINVAL;
+		}
+
+		/* Out-of-place not supported */
+		if (options->out_of_place) {
+			RTE_LOG(ERR, USER1, "Out-of-place not supported for "
+				"multi-function\n");
+			return -EINVAL;
+		}
+	}
+
+	if (options->multi_fn_opts.ops ==
+			CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC) {
+		/*
+		 * Cipher offset must be at least 12 bytes (Ethernet SRC and
+		 * DEST MACs) greater than CRC offset
+		 */
+		if (options->multi_fn_opts.cipher_offset <
+				options->multi_fn_opts.crc_offset +
+					DOCSIS_CIPHER_CRC_OFFSET_DIFF) {
+			RTE_LOG(ERR, USER1, "Cipher and CRC offsets not valid "
+				"for %s multi-function operation - "
+				"cipher_offset must greater than or equal to "
+				"crc_offset + %u\n",
+				cperf_multi_fn_ops_strs[
+						options->multi_fn_opts.ops],
+				DOCSIS_CIPHER_CRC_OFFSET_DIFF);
+			return -EINVAL;
+		}
+	}
+
+	if (options->multi_fn_opts.ops ==
+			CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+		options->multi_fn_opts.cipher_offset = PON_FRAME_HDR_SIZE;
+		options->multi_fn_opts.crc_offset = PON_FRAME_HDR_SIZE;
+	}
+
+	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 (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC) {
+			/* Buffer must be large enough to accommodate offsets */
+			if (buffer_size <
+					(options->multi_fn_opts.cipher_offset +
+						DOCSIS_MIN_CIPHER_SIZE) ||
+				buffer_size <
+					(options->multi_fn_opts.crc_offset +
+							RTE_ETHER_CRC_LEN)) {
+				RTE_LOG(ERR, USER1, "Some of the buffer sizes "
+					"are not valid for %s multi-function "
+					"operation\n",
+					cperf_multi_fn_ops_strs[
+						options->multi_fn_opts.ops]);
+				return -EINVAL;
+			}
+		} else if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			/*
+			 * Buffer length must be:
+			 * - a multiple of 4
+			 * - large enough to accommodate PON frame header and
+			 *   any padding
+			 * - not 12
+			 */
+			if (((buffer_size % PON_FRAME_MULTIPLE_SIZE) != 0) ||
+				(buffer_size < (PON_FRAME_HDR_SIZE +
+				options->multi_fn_opts.buffer_padding)) ||
+				(buffer_size == PON_FRAME_INVALID_SIZE)) {
+
+				RTE_LOG(ERR, USER1, "Some of the buffer sizes "
+					"are not suitable for %s "
+					"multi-function operation\n",
+					cperf_multi_fn_ops_strs[
+						options->multi_fn_opts.ops]);
+				return -EINVAL;
+			}
+
+			/*
+			 * Padding length must be valid:
+			 * - 0, if buffer length == 8
+			 * - less than 8, if buffer length >= 16
+			 * - less than 4, if buffer length >= 20
+			 */
+			if ((buffer_size == 8 &&
+				options->multi_fn_opts.buffer_padding != 0) ||
+				(buffer_size >= 16 &&
+				options->multi_fn_opts.buffer_padding >= 8) ||
+				(buffer_size >= 20 &&
+				options->multi_fn_opts.buffer_padding >= 4)) {
+
+				RTE_LOG(ERR, USER1, "Padding length not valid "
+					"for some of the buffer sizes for %s "
+					"multi-function operation\n",
+					cperf_multi_fn_ops_strs[
+						options->multi_fn_opts.ops]);
+				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];
+		}
+	}
+
+	return 0;
+}
+#endif /* MULTI_FN_SUPPORTED */
+
 int
 cperf_options_check(struct cperf_options *options)
 {
@@ -1151,6 +1437,13 @@ cperf_options_check(struct cperf_options *options)
 			return -EINVAL;
 	}
 
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		if (check_multi_fn_options(options) < 0)
+			return -EINVAL;
+	}
+#endif /* MULTI_FN_SUPPORTED */
+
 	return 0;
 }
 
@@ -1236,4 +1529,37 @@ cperf_options_dump(struct cperf_options *opts)
 		printf("# aead aad size: %u\n", opts->aead_aad_sz);
 		printf("#\n");
 	}
+
+#ifdef MULTI_FN_SUPPORTED
+	if (opts->op_type == CPERF_MULTI_FN) {
+		if (opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC ||
+			opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			printf("# cipher algorithm: %s\n",
+				rte_crypto_cipher_algorithm_strings[
+							opts->cipher_algo]);
+			printf("# cipher operation: %s\n",
+				rte_crypto_cipher_operation_strings[
+							opts->cipher_op]);
+			printf("# cipher key size: %u\n", opts->cipher_key_sz);
+			printf("# cipher iv size: %u\n", opts->cipher_iv_sz);
+			printf("# multi fn operations: %s\n",
+				cperf_multi_fn_ops_strs[
+						opts->multi_fn_opts.ops]);
+		}
+		if (opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC) {
+			printf("# multi fn cipher offset: %u\n",
+				opts->multi_fn_opts.cipher_offset);
+			printf("# multi fn crc offset: %u\n",
+				opts->multi_fn_opts.crc_offset);
+		}
+		if (opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP)
+			printf("# multi fn buffer padding: %u\n",
+				opts->multi_fn_opts.buffer_padding);
+		printf("#\n");
+	}
+#endif /* MULTI_FN_SUPPORTED */
 }
diff --git a/app/test-crypto-perf/cperf_test_common.c b/app/test-crypto-perf/cperf_test_common.c
index 85603eed5..6a92c1ae6 100644
--- a/app/test-crypto-perf/cperf_test_common.c
+++ b/app/test-crypto-perf/cperf_test_common.c
@@ -14,6 +14,8 @@ struct obj_params {
 	uint16_t headroom_sz;
 	uint16_t data_len;
 	uint16_t segments_nb;
+	uint16_t ops_per_obj_nb;
+	uint8_t multi_fn;
 };
 
 static void
@@ -92,15 +94,39 @@ mempool_obj_init(struct rte_mempool *mp,
 	struct rte_crypto_op *op = obj;
 	struct rte_mbuf *m = (struct rte_mbuf *) ((uint8_t *) obj +
 					params->src_buf_offset);
-	/* Set crypto operation */
-	op->type = RTE_CRYPTO_OP_TYPE_SYMMETRIC;
-	op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
-	op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
-	op->phys_addr = rte_mem_virt2iova(obj);
-	op->mempool = mp;
+
+	if (!params->multi_fn) {
+		/* Set crypto operation */
+		op->type = RTE_CRYPTO_OP_TYPE_SYMMETRIC;
+		op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
+		op->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
+		op->phys_addr = rte_mem_virt2iova(obj);
+		op->mempool = mp;
+		op->sym->m_src = m;
+		op->sym->m_dst = NULL;
+	} else {
+#ifdef MULTI_FN_SUPPORTED
+		/* Set multi-function operation(s) */
+		struct rte_multi_fn_op *mf_op, *next_mf_op;
+		uint16_t remaining_ops, op_sz;
+		remaining_ops = params->ops_per_obj_nb;
+		mf_op = obj;
+		op_sz = params->src_buf_offset / params->ops_per_obj_nb;
+		do {
+			mf_op->mempool = mp;
+			mf_op->m_src = m;
+			mf_op->m_dst = NULL;
+			next_mf_op = (struct rte_multi_fn_op *)
+					((uint8_t *) mf_op + op_sz);
+			mf_op->next = next_mf_op;
+			mf_op = next_mf_op;
+
+			remaining_ops--;
+		} while (remaining_ops > 0);
+#endif /* MULTI_FN_SUPPORTED */
+	}
 
 	/* Set source buffer */
-	op->sym->m_src = m;
 	if (params->segments_nb == 1)
 		fill_single_seg_mbuf(m, mp, obj, params->src_buf_offset,
 				params->segment_sz, params->headroom_sz,
@@ -118,9 +144,15 @@ mempool_obj_init(struct rte_mempool *mp,
 		fill_single_seg_mbuf(m, mp, obj, params->dst_buf_offset,
 				params->segment_sz, params->headroom_sz,
 				params->data_len);
-		op->sym->m_dst = m;
-	} else
-		op->sym->m_dst = NULL;
+		if (!params->multi_fn) {
+			op->sym->m_dst = m;
+		} else {
+#ifdef MULTI_FN_SUPPORTED
+			struct rte_multi_fn_op *mf_op = obj;
+			mf_op->m_dst = m;
+#endif /* MULTI_FN_SUPPORTED */
+		}
+	}
 }
 
 int
@@ -134,12 +166,38 @@ cperf_alloc_common_memory(const struct cperf_options *options,
 {
 	const char *mp_ops_name;
 	char pool_name[32] = "";
+	uint8_t multi_fn = 0;
 	int ret;
 
 	/* Calculate the object size */
-	uint16_t crypto_op_size = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op);
+	uint16_t crypto_op_size;
 	uint16_t crypto_op_private_size;
+	uint16_t ops_per_obj_nb;
+
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		crypto_op_size = sizeof(struct rte_multi_fn_op);
+		if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC) {
+			ops_per_obj_nb = 2;
+		} else if  (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			ops_per_obj_nb = 3;
+		} else {
+			RTE_LOG(ERR, USER1,
+				"Invalid multi-function operations for pool "
+				"creation\n");
+			return -1;
+		}
+		multi_fn = 1;
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		crypto_op_size = sizeof(struct rte_crypto_op) +
+			sizeof(struct rte_crypto_sym_op);
+		ops_per_obj_nb = 1;
+	}
+
 	/*
 	 * If doing AES-CCM, IV field needs to be 16 bytes long,
 	 * and AAD field needs to be long enough to have 18 bytes,
@@ -162,7 +220,7 @@ cperf_alloc_common_memory(const struct cperf_options *options,
 
 	uint16_t crypto_op_total_size = crypto_op_size +
 				crypto_op_private_size;
-	uint16_t crypto_op_total_size_padded =
+	uint16_t crypto_op_total_size_padded = ops_per_obj_nb *
 				RTE_CACHE_LINE_ROUNDUP(crypto_op_total_size);
 	uint32_t mbuf_size = sizeof(struct rte_mbuf) + options->segment_sz;
 	uint32_t max_size = options->max_buffer_size + options->digest_sz;
@@ -186,7 +244,9 @@ cperf_alloc_common_memory(const struct cperf_options *options,
 			    options->tailroom_sz,
 		.segments_nb = segments_nb,
 		.src_buf_offset = crypto_op_total_size_padded,
-		.dst_buf_offset = 0
+		.dst_buf_offset = 0,
+		.ops_per_obj_nb = ops_per_obj_nb,
+		.multi_fn = multi_fn,
 	};
 
 	if (options->out_of_place) {
diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c
index 0e4d0e153..92df4fb74 100644
--- a/app/test-crypto-perf/cperf_test_latency.c
+++ b/app/test-crypto-perf/cperf_test_latency.c
@@ -6,6 +6,10 @@
 #include <rte_cycles.h>
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_rawdev.h>
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 
 #include "cperf_test_latency.h"
 #include "cperf_ops.h"
@@ -43,18 +47,27 @@ struct priv_op_data {
 static void
 cperf_latency_test_free(struct cperf_latency_ctx *ctx)
 {
-	if (ctx) {
-		if (ctx->sess) {
+	if (!ctx)
+		return;
+
+	if (ctx->sess) {
+#ifdef MULTI_FN_SUPPORTED
+		if (ctx->options->op_type == CPERF_MULTI_FN) {
+			rte_multi_fn_session_destroy(ctx->dev_id,
+				(struct rte_multi_fn_session *)ctx->sess);
+		} else
+#endif /* MULTI_FN_SUPPORTED */
+		{
 			rte_cryptodev_sym_session_clear(ctx->dev_id, ctx->sess);
 			rte_cryptodev_sym_session_free(ctx->sess);
 		}
+	}
 
-		if (ctx->pool)
-			rte_mempool_free(ctx->pool);
+	if (ctx->pool)
+		rte_mempool_free(ctx->pool);
 
-		rte_free(ctx->res);
-		rte_free(ctx);
-	}
+	rte_free(ctx->res);
+	rte_free(ctx);
 }
 
 void *
@@ -67,6 +80,7 @@ cperf_latency_test_constructor(struct rte_mempool *sess_mp,
 {
 	struct cperf_latency_ctx *ctx = NULL;
 	size_t extra_op_priv_size = sizeof(struct priv_op_data);
+	uint16_t iv_offset;
 
 	ctx = rte_malloc(NULL, sizeof(struct cperf_latency_ctx), 0);
 	if (ctx == NULL)
@@ -79,10 +93,19 @@ cperf_latency_test_constructor(struct rte_mempool *sess_mp,
 	ctx->options = options;
 	ctx->test_vector = test_vector;
 
-	/* IV goes at the end of the crypto operation */
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op) +
-		sizeof(struct cperf_op_result *);
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		/* IV goes at the end of the multi-function operation */
+		iv_offset = sizeof(struct rte_multi_fn_op) +
+			sizeof(struct cperf_op_result *);
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		/* IV goes at the end of the crypto operation */
+		iv_offset = sizeof(struct rte_crypto_op) +
+			sizeof(struct rte_crypto_sym_op) +
+			sizeof(struct cperf_op_result *);
+	}
 
 	ctx->sess = op_fns->sess_create(sess_mp, sess_priv_mp, dev_id, options,
 			test_vector, iv_offset);
@@ -138,34 +161,65 @@ cperf_latency_test_runner(void *arg)
 
 	uint32_t lcore = rte_lcore_id();
 
+	uint16_t iv_offset;
+
+	int multi_fn = 0;
+
+#ifdef MULTI_FN_SUPPORTED
+	if (ctx->options->op_type == CPERF_MULTI_FN)
+		multi_fn = 1;
+#else
+	RTE_SET_USED(multi_fn);
+#endif /* MULTI_FN_SUPPORTED */
+
 #ifdef CPERF_LINEARIZATION_ENABLE
-	struct rte_cryptodev_info dev_info;
 	int linearize = 0;
 
 	/* Check if source mbufs require coalescing */
 	if (ctx->options->segment_sz < ctx->options->max_buffer_size) {
-		rte_cryptodev_info_get(ctx->dev_id, &dev_info);
-		if ((dev_info.feature_flags &
-				RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) == 0)
+		if (!multi_fn) {
+			struct rte_cryptodev_info dev_info;
+			rte_cryptodev_info_get(ctx->dev_id, &dev_info);
+			if ((dev_info.feature_flags &
+					RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) ==
+									0)
+				linearize = 1;
+		} else
 			linearize = 1;
 	}
 #endif /* CPERF_LINEARIZATION_ENABLE */
 
 	ctx->lcore_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);
-
 	/* 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];
 
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op) +
-		sizeof(struct cperf_op_result *);
+#ifdef MULTI_FN_SUPPORTED
+	if (multi_fn) {
+		/* Warm up the host CPU before starting the test */
+		for (i = 0; i < ctx->options->total_ops; i++)
+			rte_rawdev_enqueue_buffers(ctx->dev_id, NULL, 0,
+						(rte_rawdev_obj_t)&ctx->qp_id);
+
+		iv_offset = sizeof(struct rte_multi_fn_op) +
+			sizeof(struct cperf_op_result *);
+
+		multi_fn = 1;
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		/* 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);
+
+		iv_offset = sizeof(struct rte_crypto_op) +
+			sizeof(struct rte_crypto_sym_op) +
+			sizeof(struct cperf_op_result *);
+	}
 
 	while (test_burst_size <= ctx->options->max_burst_size) {
 		uint64_t ops_enqd = 0, ops_deqd = 0;
@@ -215,13 +269,40 @@ cperf_latency_test_runner(void *arg)
 			}
 #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);
+#ifdef MULTI_FN_SUPPORTED
+			if (multi_fn) {
+				/* Enqueue burst of op on raw device */
+				ops_enqd = rte_rawdev_enqueue_buffers(
+					ctx->dev_id,
+					(struct rte_rawdev_buf **)ops,
+					burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+
+				/*
+				 * Dequeue processed burst of ops from raw
+				 * device
+				 */
+				ops_deqd = rte_rawdev_dequeue_buffers(
+					ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					test_burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+			} else
+#endif /* MULTI_FN_SUPPORTED */
+			{
+				/* 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, test_burst_size);
+				/*
+				 * 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();
 
@@ -262,14 +343,41 @@ cperf_latency_test_runner(void *arg)
 			b_idx++;
 		}
 
-		/* Dequeue any operations still in the crypto device */
+		/* Dequeue any operations still in the 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);
+#ifdef MULTI_FN_SUPPORTED
+			if (multi_fn) {
+				/*
+				 * Sending 0 length burst to flush sw raw
+				 * device
+				 */
+				rte_rawdev_enqueue_buffers(ctx->dev_id, NULL, 0,
+					(rte_rawdev_obj_t)&ctx->qp_id);
 
-			/* dequeue burst */
-			ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
-					ops_processed, test_burst_size);
+				/*
+				 * Dequeue processed burst of ops from raw
+				 * device
+				 */
+				ops_deqd = rte_rawdev_dequeue_buffers(
+					ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					test_burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+			} else
+#endif /* MULTI_FN_SUPPORTED */
+			{
+				/*
+				 * 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);
+			}
 
 			tsc_end = rte_rdtsc_precise();
 
diff --git a/app/test-crypto-perf/cperf_test_pmd_cyclecount.c b/app/test-crypto-perf/cperf_test_pmd_cyclecount.c
index 74371faa8..f0a7dbf7c 100644
--- a/app/test-crypto-perf/cperf_test_pmd_cyclecount.c
+++ b/app/test-crypto-perf/cperf_test_pmd_cyclecount.c
@@ -6,6 +6,10 @@
 
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_rawdev.h>
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 #include <rte_cycles.h>
 #include <rte_malloc.h>
 
@@ -44,6 +48,7 @@ struct pmd_cyclecount_state {
 	uint32_t lcore;
 	uint64_t delay;
 	int linearize;
+	int multi_fn;
 	uint32_t ops_enqd;
 	uint32_t ops_deqd;
 	uint32_t ops_enq_retries;
@@ -53,29 +58,37 @@ struct pmd_cyclecount_state {
 	double cycles_per_deq;
 };
 
-static const uint16_t iv_offset =
-		sizeof(struct rte_crypto_op) + sizeof(struct rte_crypto_sym_op);
+static uint16_t iv_offset;
 
 static void
 cperf_pmd_cyclecount_test_free(struct cperf_pmd_cyclecount_ctx *ctx)
 {
-	if (ctx) {
-		if (ctx->sess) {
+	if (!ctx)
+		return;
+
+	if (ctx->sess) {
+#ifdef MULTI_FN_SUPPORTED
+		if (ctx->options->op_type == CPERF_MULTI_FN) {
+			rte_multi_fn_session_destroy(ctx->dev_id,
+				(struct rte_multi_fn_session *)ctx->sess);
+		} else
+#endif /* MULTI_FN_SUPPORTED */
+		{
 			rte_cryptodev_sym_session_clear(ctx->dev_id, ctx->sess);
 			rte_cryptodev_sym_session_free(ctx->sess);
 		}
+	}
 
-		if (ctx->pool)
-			rte_mempool_free(ctx->pool);
+	if (ctx->pool)
+		rte_mempool_free(ctx->pool);
 
-		if (ctx->ops)
-			rte_free(ctx->ops);
+	if (ctx->ops)
+		rte_free(ctx->ops);
 
-		if (ctx->ops_processed)
-			rte_free(ctx->ops_processed);
+	if (ctx->ops_processed)
+		rte_free(ctx->ops_processed);
 
-		rte_free(ctx);
-	}
+	rte_free(ctx);
 }
 
 void *
@@ -103,9 +116,17 @@ cperf_pmd_cyclecount_test_constructor(struct rte_mempool *sess_mp,
 	ctx->options = options;
 	ctx->test_vector = test_vector;
 
-	/* IV goes at the end of the crypto operation */
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-			sizeof(struct rte_crypto_sym_op);
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		/* IV goes at the end of the multi-function operation */
+		iv_offset = sizeof(struct rte_multi_fn_op);
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		/* IV goes at the end of the crypto operation */
+		iv_offset = sizeof(struct rte_crypto_op) +
+				sizeof(struct rte_crypto_sym_op);
+	}
 
 	ctx->sess = op_fns->sess_create(sess_mp, sess_priv_mp, dev_id, options,
 			test_vector, iv_offset);
@@ -237,8 +258,18 @@ pmd_cyclecount_bench_enq(struct pmd_cyclecount_state *state,
 		struct rte_crypto_op **ops = &state->ctx->ops[cur_iter_op];
 		uint32_t burst_enqd;
 
-		burst_enqd = rte_cryptodev_enqueue_burst(state->ctx->dev_id,
-				state->ctx->qp_id, ops, burst_size);
+#ifdef MULTI_FN_SUPPORTED
+		if (state->multi_fn)
+			burst_enqd = rte_rawdev_enqueue_buffers(
+					state->ctx->dev_id,
+					(struct rte_rawdev_buf **)ops,
+					burst_size,
+					(rte_rawdev_obj_t)&state->ctx->qp_id);
+		else
+#endif /* MULTI_FN_SUPPORTED */
+			burst_enqd = rte_cryptodev_enqueue_burst(
+					state->ctx->dev_id, state->ctx->qp_id,
+					ops, burst_size);
 
 		/* if we couldn't enqueue anything, the queue is full */
 		if (!burst_enqd) {
@@ -268,8 +299,18 @@ pmd_cyclecount_bench_deq(struct pmd_cyclecount_state *state,
 				&state->ctx->ops[cur_iter_op];
 		uint32_t burst_deqd;
 
-		burst_deqd = rte_cryptodev_dequeue_burst(state->ctx->dev_id,
-				state->ctx->qp_id, ops_processed, burst_size);
+#ifdef MULTI_FN_SUPPORTED
+		if (state->multi_fn)
+			burst_deqd = rte_rawdev_dequeue_buffers(
+					state->ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					burst_size,
+					(rte_rawdev_obj_t)&state->ctx->qp_id);
+		else
+#endif /* MULTI_FN_SUPPORTED */
+			burst_deqd = rte_cryptodev_dequeue_burst(
+					state->ctx->dev_id, state->ctx->qp_id,
+					ops_processed, burst_size);
 
 		if (burst_deqd < burst_size)
 			state->ops_deq_retries++;
@@ -390,6 +431,12 @@ cperf_pmd_cyclecount_test_runner(void *test_ctx)
 	state.opts = opts;
 	state.lcore = rte_lcore_id();
 	state.linearize = 0;
+	state.multi_fn = 0;
+
+#ifdef MULTI_FN_SUPPORTED
+	if (opts->op_type == CPERF_MULTI_FN)
+		state.multi_fn = 1;
+#endif /* MULTI_FN_SUPPORTED */
 
 	static rte_atomic16_t display_once = RTE_ATOMIC16_INIT(0);
 	static bool warmup = true;
@@ -406,12 +453,15 @@ cperf_pmd_cyclecount_test_runner(void *test_ctx)
 
 	/* Check if source mbufs require coalescing */
 	if (opts->segments_sz < ctx->options->max_buffer_size) {
-		rte_cryptodev_info_get(state.ctx->dev_id, &dev_info);
-		if ((dev_info.feature_flags &
+		if (!state.multi_fn) {
+			rte_cryptodev_info_get(state.ctx->dev_id, &dev_info);
+			if ((dev_info.feature_flags &
 				    RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) ==
-				0) {
+								0) {
+				state.linearize = 1;
+			}
+		} else
 			state.linearize = 1;
-		}
 	}
 #endif /* CPERF_LINEARIZATION_ENABLE */
 
diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c
index 35c51026f..e569d820d 100644
--- a/app/test-crypto-perf/cperf_test_throughput.c
+++ b/app/test-crypto-perf/cperf_test_throughput.c
@@ -6,6 +6,10 @@
 #include <rte_cycles.h>
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_rawdev.h>
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 
 #include "cperf_test_throughput.h"
 #include "cperf_ops.h"
@@ -44,11 +48,20 @@ cperf_throughput_test_free(struct cperf_throughput_ctx *ctx)
 				(struct rte_security_session *)ctx->sess);
 		} else
 #endif
-		{
-			rte_cryptodev_sym_session_clear(ctx->dev_id, ctx->sess);
-			rte_cryptodev_sym_session_free(ctx->sess);
+#ifdef MULTI_FN_SUPPORTED
+			if (ctx->options->op_type == CPERF_MULTI_FN) {
+				rte_multi_fn_session_destroy(ctx->dev_id,
+					(struct rte_multi_fn_session *)
+						ctx->sess);
+			} else
+#endif /* MULTI_FN_SUPPORTED */
+			{
+				rte_cryptodev_sym_session_clear(ctx->dev_id,
+					ctx->sess);
+				rte_cryptodev_sym_session_free(ctx->sess);
+			}
 		}
-	}
+
 	if (ctx->pool)
 		rte_mempool_free(ctx->pool);
 
@@ -64,6 +77,7 @@ cperf_throughput_test_constructor(struct rte_mempool *sess_mp,
 		const struct cperf_op_fns *op_fns)
 {
 	struct cperf_throughput_ctx *ctx = NULL;
+	uint16_t iv_offset;
 
 	ctx = rte_malloc(NULL, sizeof(struct cperf_throughput_ctx), 0);
 	if (ctx == NULL)
@@ -76,9 +90,17 @@ cperf_throughput_test_constructor(struct rte_mempool *sess_mp,
 	ctx->options = options;
 	ctx->test_vector = test_vector;
 
-	/* IV goes at the end of the crypto operation */
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op);
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		/* IV goes at the end of the multi-function operation */
+		iv_offset = sizeof(struct rte_multi_fn_op);
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		/* IV goes at the end of the crypto operation */
+		iv_offset = sizeof(struct rte_crypto_op) +
+			sizeof(struct rte_crypto_sym_op);
+	}
 
 	ctx->sess = op_fns->sess_create(sess_mp, sess_priv_mp, dev_id, options,
 			test_vector, iv_offset);
@@ -113,24 +135,55 @@ cperf_throughput_test_runner(void *test_ctx)
 
 	uint32_t lcore = rte_lcore_id();
 
+	uint16_t iv_offset;
+
+	int multi_fn = 0;
+
+#ifdef MULTI_FN_SUPPORTED
+	if (ctx->options->op_type == CPERF_MULTI_FN)
+		multi_fn = 1;
+#else
+	RTE_SET_USED(multi_fn);
+#endif /* MULTI_FN_SUPPORTED */
+
 #ifdef CPERF_LINEARIZATION_ENABLE
-	struct rte_cryptodev_info dev_info;
 	int linearize = 0;
 
 	/* Check if source mbufs require coalescing */
 	if (ctx->options->segment_sz < ctx->options->max_buffer_size) {
-		rte_cryptodev_info_get(ctx->dev_id, &dev_info);
-		if ((dev_info.feature_flags &
-				RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) == 0)
+		if (!multi_fn) {
+			struct rte_cryptodev_info dev_info;
+			rte_cryptodev_info_get(ctx->dev_id, &dev_info);
+			if ((dev_info.feature_flags &
+					RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) ==
+									0)
+				linearize = 1;
+		} else
 			linearize = 1;
 	}
 #endif /* CPERF_LINEARIZATION_ENABLE */
 
 	ctx->lcore_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);
+#ifdef MULTI_FN_SUPPORTED
+	if (multi_fn) {
+		iv_offset = sizeof(struct rte_multi_fn_op);
+
+		/* Warm up the host CPU before starting the test */
+		for (i = 0; i < ctx->options->total_ops; i++)
+			rte_rawdev_enqueue_buffers(ctx->dev_id, NULL, 0,
+						(rte_rawdev_obj_t)&ctx->qp_id);
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		iv_offset = sizeof(struct rte_crypto_op) +
+				sizeof(struct rte_crypto_sym_op);
+
+		/* 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);
+	}
 
 	/* Get first size from range or list */
 	if (ctx->options->inc_burst_size != 0)
@@ -138,9 +191,6 @@ cperf_throughput_test_runner(void *test_ctx)
 	else
 		test_burst_size = ctx->options->burst_size_list[0];
 
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op);
-
 	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;
@@ -203,9 +253,41 @@ cperf_throughput_test_runner(void *test_ctx)
 			}
 #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);
+#ifdef MULTI_FN_SUPPORTED
+			if (multi_fn) {
+				/* Enqueue burst of op on raw device */
+				ops_enqd = rte_rawdev_enqueue_buffers(
+						ctx->dev_id,
+						(struct rte_rawdev_buf **)ops,
+						burst_size,
+						(rte_rawdev_obj_t)&ctx->qp_id);
+
+				/*
+				 * Dequeue processed burst of ops from raw
+				 * device
+				 */
+				ops_deqd = rte_rawdev_dequeue_buffers(
+					ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					test_burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+			} else
+#endif /* MULTI_FN_SUPPORTED */
+			{
+				/* 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, test_burst_size);
+			}
+
 			if (ops_enqd < burst_size)
 				ops_enqd_failed++;
 
@@ -216,11 +298,6 @@ cperf_throughput_test_runner(void *test_ctx)
 			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. */
 				rte_mempool_put_bulk(ctx->pool,
@@ -238,15 +315,38 @@ cperf_throughput_test_runner(void *test_ctx)
 
 		}
 
-		/* Dequeue any operations still in the crypto device */
-
+		/* Dequeue any operations still in the 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);
+#ifdef MULTI_FN_SUPPORTED
+			if (multi_fn) {
+				/*
+				 * Sending 0 length burst to flush sw raw
+				 * device
+				 */
+				rte_rawdev_enqueue_buffers(ctx->dev_id, NULL, 0,
+					(rte_rawdev_obj_t)&ctx->qp_id);
 
-			/* dequeue burst */
-			ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
-					ops_processed, test_burst_size);
+				/* dequeue burst */
+				ops_deqd = rte_rawdev_dequeue_buffers(
+					ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					test_burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+			} else
+#endif /* MULTI_FN_SUPPORTED */
+			{
+				/*
+				 * 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 {
diff --git a/app/test-crypto-perf/cperf_test_vector_parsing.c b/app/test-crypto-perf/cperf_test_vector_parsing.c
index 1e9dfcfff..1395d86f2 100644
--- a/app/test-crypto-perf/cperf_test_vector_parsing.c
+++ b/app/test-crypto-perf/cperf_test_vector_parsing.c
@@ -581,11 +581,38 @@ 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->max_buffer_size;
+#ifdef MULTI_FN_SUPPORTED
+	if (opts->op_type == CPERF_MULTI_FN) {
+		if (opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC ||
+			opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			test_vector->data.cipher_offset =
+					opts->multi_fn_opts.cipher_offset;
+			test_vector->data.cipher_length =
+					opts->max_buffer_size;
+
+			test_vector->multi_fn_data.crc_offset =
+					opts->multi_fn_opts.crc_offset;
+			test_vector->multi_fn_data.crc_length =
+					opts->max_buffer_size;
+		}
 
-	test_vector->data.auth_offset = 0;
-	test_vector->data.auth_length = opts->max_buffer_size;
+		if (opts->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			test_vector->multi_fn_data.bip_offset = 0;
+			test_vector->multi_fn_data.bip_length =
+					opts->max_buffer_size;
+		}
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		test_vector->data.cipher_offset = 0;
+		test_vector->data.cipher_length = opts->max_buffer_size;
+
+		test_vector->data.auth_offset = 0;
+		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 41641650c..5b6a048b1 100644
--- a/app/test-crypto-perf/cperf_test_vectors.c
+++ b/app/test-crypto-perf/cperf_test_vectors.c
@@ -587,5 +587,58 @@ cperf_test_vector_get_dummy(struct cperf_options *options)
 		memcpy(t_vec->aead_iv.data, iv, options->aead_iv_sz);
 		t_vec->aead_iv.length = options->aead_iv_sz;
 	}
+
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC ||
+			options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			if (options->cipher_algo == RTE_CRYPTO_CIPHER_NULL) {
+				t_vec->cipher_key.length = 0;
+				t_vec->ciphertext.data = plaintext;
+				t_vec->cipher_key.data = NULL;
+			} else {
+				t_vec->cipher_key.length =
+						options->cipher_key_sz;
+				t_vec->ciphertext.data = ciphertext;
+				t_vec->cipher_key.data = cipher_key;
+			}
+
+			/* Init IV data ptr */
+			t_vec->cipher_iv.data = NULL;
+
+			if (options->cipher_iv_sz != 0) {
+				/* Set IV parameters */
+				t_vec->cipher_iv.data = rte_malloc(NULL,
+						options->cipher_iv_sz, 16);
+				if (t_vec->cipher_iv.data == NULL) {
+					rte_free(t_vec);
+					return NULL;
+				}
+				memcpy(t_vec->cipher_iv.data, iv,
+					options->cipher_iv_sz);
+			}
+			t_vec->ciphertext.length = options->max_buffer_size;
+			t_vec->cipher_iv.length = options->cipher_iv_sz;
+			t_vec->data.cipher_offset =
+					options->multi_fn_opts.cipher_offset;
+			t_vec->data.cipher_length = options->max_buffer_size;
+
+			t_vec->multi_fn_data.crc_offset =
+					options->multi_fn_opts.crc_offset;
+			t_vec->multi_fn_data.crc_length =
+					options->max_buffer_size;
+		}
+
+		if (options->multi_fn_opts.ops ==
+				CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP) {
+			t_vec->multi_fn_data.bip_offset = 0;
+			t_vec->multi_fn_data.bip_length =
+					options->max_buffer_size;
+		}
+	}
+#endif /* MULTI_FN_SUPPORTED */
+
 	return t_vec;
 }
diff --git a/app/test-crypto-perf/cperf_test_vectors.h b/app/test-crypto-perf/cperf_test_vectors.h
index 6f10823ef..ad9ea89e6 100644
--- a/app/test-crypto-perf/cperf_test_vectors.h
+++ b/app/test-crypto-perf/cperf_test_vectors.h
@@ -68,6 +68,15 @@ struct cperf_test_vector {
 		uint32_t aead_offset;
 		uint32_t aead_length;
 	} data;
+
+#ifdef MULTI_FN_SUPPORTED
+	struct {
+		uint32_t crc_offset;
+		uint32_t crc_length;
+		uint32_t bip_offset;
+		uint32_t bip_length;
+	} multi_fn_data;
+#endif /* MULTI_FN_SUPPORTED */
 };
 
 struct cperf_test_vector*
diff --git a/app/test-crypto-perf/cperf_test_verify.c b/app/test-crypto-perf/cperf_test_verify.c
index 833bc9a55..30ef2f568 100644
--- a/app/test-crypto-perf/cperf_test_verify.c
+++ b/app/test-crypto-perf/cperf_test_verify.c
@@ -6,6 +6,10 @@
 #include <rte_cycles.h>
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_rawdev.h>
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 
 #include "cperf_test_verify.h"
 #include "cperf_ops.h"
@@ -36,17 +40,26 @@ struct cperf_op_result {
 static void
 cperf_verify_test_free(struct cperf_verify_ctx *ctx)
 {
-	if (ctx) {
-		if (ctx->sess) {
+	if (ctx)
+		return;
+
+	if (ctx->sess) {
+#ifdef MULTI_FN_SUPPORTED
+		if (ctx->options->op_type == CPERF_MULTI_FN) {
+			rte_multi_fn_session_destroy(ctx->dev_id,
+				(struct rte_multi_fn_session *)ctx->sess);
+		} else
+#endif /* MULTI_FN_SUPPORTED */
+		{
 			rte_cryptodev_sym_session_clear(ctx->dev_id, ctx->sess);
 			rte_cryptodev_sym_session_free(ctx->sess);
 		}
+	}
 
-		if (ctx->pool)
-			rte_mempool_free(ctx->pool);
+	if (ctx->pool)
+		rte_mempool_free(ctx->pool);
 
-		rte_free(ctx);
-	}
+	rte_free(ctx);
 }
 
 void *
@@ -58,6 +71,7 @@ cperf_verify_test_constructor(struct rte_mempool *sess_mp,
 		const struct cperf_op_fns *op_fns)
 {
 	struct cperf_verify_ctx *ctx = NULL;
+	uint16_t iv_offset;
 
 	ctx = rte_malloc(NULL, sizeof(struct cperf_verify_ctx), 0);
 	if (ctx == NULL)
@@ -70,9 +84,17 @@ cperf_verify_test_constructor(struct rte_mempool *sess_mp,
 	ctx->options = options;
 	ctx->test_vector = test_vector;
 
-	/* IV goes at the end of the crypto operation */
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op);
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN) {
+		/* IV goes at the end of the multi-function operation */
+		iv_offset = sizeof(struct rte_multi_fn_op);
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		/* IV goes at the end of the crypto operation */
+		iv_offset = sizeof(struct rte_crypto_op) +
+			sizeof(struct rte_crypto_sym_op);
+	}
 
 	ctx->sess = op_fns->sess_create(sess_mp, sess_priv_mp, dev_id, options,
 			test_vector, iv_offset);
@@ -91,6 +113,65 @@ cperf_verify_test_constructor(struct rte_mempool *sess_mp,
 	return NULL;
 }
 
+#ifdef MULTI_FN_SUPPORTED
+static int
+cperf_verify_mf_op(struct rte_multi_fn_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;
+	int res = 0;
+
+	if (op->overall_status != RTE_MULTI_FN_OP_STATUS_SUCCESS)
+		return 1;
+
+	if (op->m_dst)
+		m = op->m_dst;
+	else
+		m = op->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->m_dst)
+		m = op->m_dst;
+	else
+		m = op->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--;
+	}
+
+	if (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
+		res += memcmp(data,
+				vector->ciphertext.data,
+				options->test_buffer_size);
+	else
+		res += memcmp(data,
+				vector->plaintext.data,
+				options->test_buffer_size);
+
+	rte_free(data);
+	return !!res;
+}
+#endif /* MULTI_FN_SUPPORTED */
+
 static int
 cperf_verify_op(struct rte_crypto_op *op,
 		const struct cperf_options *options,
@@ -104,6 +185,12 @@ cperf_verify_op(struct rte_crypto_op *op,
 	uint8_t	cipher, auth;
 	int res = 0;
 
+#ifdef MULTI_FN_SUPPORTED
+	if (options->op_type == CPERF_MULTI_FN)
+		return cperf_verify_mf_op((struct rte_multi_fn_op *)op, options,
+						vector);
+#endif /* MULTI_FN_SUPPORTED */
+
 	if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
 		return 1;
 
@@ -252,15 +339,30 @@ cperf_verify_test_runner(void *test_ctx)
 
 	uint32_t lcore = rte_lcore_id();
 
+	uint16_t iv_offset;
+
+	int multi_fn = 0;
+
+#ifdef MULTI_FN_SUPPORTED
+	if (ctx->options->op_type == CPERF_MULTI_FN)
+		multi_fn = 1;
+#else
+	RTE_SET_USED(multi_fn);
+#endif /* MULTI_FN_SUPPORTED */
+
 #ifdef CPERF_LINEARIZATION_ENABLE
-	struct rte_cryptodev_info dev_info;
 	int linearize = 0;
 
 	/* Check if source mbufs require coalescing */
 	if (ctx->options->segment_sz < ctx->options->max_buffer_size) {
-		rte_cryptodev_info_get(ctx->dev_id, &dev_info);
-		if ((dev_info.feature_flags &
-				RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) == 0)
+		if (!multi_fn) {
+			struct rte_cryptodev_info dev_info;
+			rte_cryptodev_info_get(ctx->dev_id, &dev_info);
+			if ((dev_info.feature_flags &
+					RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) ==
+									0)
+				linearize = 1;
+		} else
 			linearize = 1;
 	}
 #endif /* CPERF_LINEARIZATION_ENABLE */
@@ -271,12 +373,18 @@ cperf_verify_test_runner(void *test_ctx)
 		printf("\n# Running verify test on device: %u, lcore: %u\n",
 			ctx->dev_id, lcore);
 
-	uint16_t iv_offset = sizeof(struct rte_crypto_op) +
-		sizeof(struct rte_crypto_sym_op);
+#ifdef MULTI_FN_SUPPORTED
+	if (multi_fn)
+		iv_offset = sizeof(struct rte_multi_fn_op);
+	else
+#endif /* MULTI_FN_SUPPORTED */
+		iv_offset = sizeof(struct rte_crypto_op) +
+			sizeof(struct rte_crypto_sym_op);
 
 	while (ops_enqd_total < ctx->options->total_ops) {
 
-		uint16_t burst_size = ((ops_enqd_total + ctx->options->max_burst_size)
+		uint16_t burst_size = ((ops_enqd_total +
+						ctx->options->max_burst_size)
 				<= ctx->options->total_ops) ?
 						ctx->options->max_burst_size :
 						ctx->options->total_ops -
@@ -319,9 +427,32 @@ cperf_verify_test_runner(void *test_ctx)
 		}
 #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);
+#ifdef MULTI_FN_SUPPORTED
+		if (multi_fn) {
+			/* Enqueue burst of op on raw device */
+			ops_enqd = rte_rawdev_enqueue_buffers(ctx->dev_id,
+					(struct rte_rawdev_buf **)ops,
+					burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+
+			/* Dequeue processed burst of ops from raw device */
+			ops_deqd = rte_rawdev_dequeue_buffers(ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					ctx->options->max_burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+		} else
+#endif /* MULTI_FN_SUPPORTED */
+		{
+			/* 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->max_burst_size);
+		}
+
 		if (ops_enqd < burst_size)
 			ops_enqd_failed++;
 
@@ -332,11 +463,6 @@ cperf_verify_test_runner(void *test_ctx)
 		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->max_burst_size);
-
 		if (ops_deqd == 0) {
 			/**
 			 * Count dequeue polls which didn't return any
@@ -358,15 +484,32 @@ cperf_verify_test_runner(void *test_ctx)
 		ops_deqd_total += ops_deqd;
 	}
 
-	/* Dequeue any operations still in the crypto device */
-
+	/* Dequeue any operations still in the 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);
+#ifdef MULTI_FN_SUPPORTED
+		if (multi_fn) {
+			/* Sending 0 length burst to flush sw raw device */
+			rte_rawdev_enqueue_buffers(ctx->dev_id, NULL, 0,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+
+			/* dequeue burst */
+			ops_deqd = rte_rawdev_dequeue_buffers(ctx->dev_id,
+					(struct rte_rawdev_buf **)ops_processed,
+					ctx->options->max_burst_size,
+					(rte_rawdev_obj_t)&ctx->qp_id);
+		} else
+#endif /* MULTI_FN_SUPPORTED */
+		{
+			/* 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->max_burst_size);
+		}
 
-		/* dequeue burst */
-		ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
-				ops_processed, ctx->options->max_burst_size);
 		if (ops_deqd == 0) {
 			ops_deqd_failed++;
 			continue;
diff --git a/app/test-crypto-perf/main.c b/app/test-crypto-perf/main.c
index 52a1860fb..c8334160e 100644
--- a/app/test-crypto-perf/main.c
+++ b/app/test-crypto-perf/main.c
@@ -12,6 +12,10 @@
 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 #include <rte_cryptodev_scheduler.h>
 #endif
+#ifdef MULTI_FN_SUPPORTED
+#include <rte_rawdev.h>
+#include <rte_multi_fn.h>
+#endif /* MULTI_FN_SUPPORTED */
 
 #include "cperf.h"
 #include "cperf_options.h"
@@ -39,9 +43,19 @@ const char *cperf_op_type_strs[] = {
 	[CPERF_CIPHER_THEN_AUTH] = "cipher-then-auth",
 	[CPERF_AUTH_THEN_CIPHER] = "auth-then-cipher",
 	[CPERF_AEAD] = "aead",
-	[CPERF_PDCP] = "pdcp"
+	[CPERF_PDCP] = "pdcp",
+#ifdef MULTI_FN_SUPPORTED
+	[CPERF_MULTI_FN] = "multi-fn"
+#endif /* MULTI_FN_SUPPORTED */
 };
 
+#ifdef MULTI_FN_SUPPORTED
+const char *cperf_multi_fn_ops_strs[] = {
+	[CPERF_MULTI_FN_OPS_DOCSIS_CIPHER_CRC] = "docsis-cipher-crc",
+	[CPERF_MULTI_FN_OPS_PON_CIPHER_CRC_BIP] = "pon-cipher-crc-bip"
+};
+#endif /* MULTI_FN_SUPPORTED */
+
 const struct cperf_test cperf_testmap[] = {
 		[CPERF_TEST_TYPE_THROUGHPUT] = {
 				cperf_throughput_test_constructor,
@@ -294,7 +308,7 @@ cperf_initialize_cryptodev(struct cperf_options *opts, uint8_t *enabled_cdevs)
 }
 
 static int
-cperf_verify_devices_capabilities(struct cperf_options *opts,
+cperf_verify_crypto_devices_capabilities(struct cperf_options *opts,
 		uint8_t *enabled_cdevs, uint8_t nb_cryptodevs)
 {
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -369,8 +383,136 @@ cperf_verify_devices_capabilities(struct cperf_options *opts,
 		}
 	}
 
+#ifdef MULTI_FN_SUPPORTED
+	if (opts->op_type == CPERF_MULTI_FN)
+		return -1;
+#endif /* MULTI_FN_SUPPORTED */
+
+	return 0;
+}
+
+#ifdef MULTI_FN_SUPPORTED
+static uint8_t
+cperf_get_rawdevs(const char *driver_name, uint8_t *devices,
+		uint8_t nb_devices)
+{
+	struct rte_rawdev_info rdev_info;
+	uint8_t i, count = 0;
+
+	for (i = 0; i < RTE_RAWDEV_MAX_DEVS && count < nb_devices; i++) {
+		memset(&rdev_info, 0, sizeof(struct rte_rawdev_info));
+		if (!rte_rawdev_info_get(i, &rdev_info) &&
+			!strncmp(rdev_info.driver_name,
+					driver_name,
+					strlen(driver_name) + 1))
+			devices[count++] = i;
+	}
+
+	return count;
+}
+
+static int
+cperf_initialize_rawdev(struct cperf_options *opts, uint8_t *enabled_rdevs)
+{
+	uint8_t enabled_rdev_count = 0, nb_lcores, rdev_id;
+	unsigned int i, j;
+	int ret;
+
+	enabled_rdev_count = cperf_get_rawdevs(opts->device_type,
+			enabled_rdevs, RTE_RAWDEV_MAX_DEVS);
+	if (enabled_rdev_count == 0) {
+		printf("No raw devices type %s available\n",
+				opts->device_type);
+		return -EINVAL;
+	}
+
+	nb_lcores = rte_lcore_count() - 1;
+
+	if (nb_lcores < 1) {
+		RTE_LOG(ERR, USER1,
+			"Number of enabled cores need to be higher than 1\n");
+		return -EINVAL;
+	}
+
+	/*
+	 * Calculate number of needed queue pairs, based on the amount
+	 * of available number of logical cores and crypto devices.
+	 * For instance, if there are 4 cores and 2 crypto devices,
+	 * 2 queue pairs will be set up per device.
+	 */
+	opts->nb_qps = (nb_lcores % enabled_rdev_count) ?
+				(nb_lcores / enabled_rdev_count) + 1 :
+				nb_lcores / enabled_rdev_count;
+
+	for (i = 0; i < enabled_rdev_count &&
+			i < RTE_RAWDEV_MAX_DEVS; i++) {
+		rdev_id = enabled_rdevs[i];
+
+		struct rte_rawdev_info rdev_info = {0};
+		struct rte_multi_fn_dev_info mf_info  = {0};
+		struct rte_multi_fn_dev_config mf_dev_conf = {0};
+		struct rte_multi_fn_qp_config qp_conf = {0};
+		uint8_t socket_id = rte_cryptodev_socket_id(rdev_id);
+
+		/*
+		 * Range check the socket_id - negative values become big
+		 * positive ones due to use of unsigned value
+		 */
+		if (socket_id >= RTE_MAX_NUMA_NODES)
+			socket_id = 0;
+
+		rdev_info.dev_private = &mf_info;
+		rte_rawdev_info_get(rdev_id, &rdev_info);
+		if (opts->nb_qps > mf_info.max_nb_queues) {
+			printf("Number of needed queue pairs is higher "
+				"than the maximum number of queue pairs "
+				"per device.\n");
+			printf("Lower the number of cores or increase "
+				"the number of raw devices\n");
+			return -EINVAL;
+		}
+
+		mf_dev_conf.nb_queues = opts->nb_qps;
+		rdev_info.dev_private = &mf_dev_conf;
+		qp_conf.nb_descriptors = opts->nb_descriptors;
+
+		ret = rte_rawdev_configure(rdev_id, &rdev_info);
+		if (ret < 0) {
+			printf("Failed to configure rawdev %u", rdev_id);
+			return -EINVAL;
+		}
+
+		for (j = 0; j < opts->nb_qps; j++) {
+			ret = rte_rawdev_queue_setup(rdev_id, j, &qp_conf);
+			if (ret < 0) {
+				printf("Failed to setup queue pair %u on "
+					"rawdev %u", j, rdev_id);
+				return -EINVAL;
+			}
+		}
+
+		ret = rte_rawdev_start(rdev_id);
+		if (ret < 0) {
+			printf("Failed to start raw device %u: error %d\n",
+				rdev_id, ret);
+			return -EPERM;
+		}
+	}
+
+	return enabled_rdev_count;
+}
+
+static int
+cperf_verify_raw_devices_capabilities(struct cperf_options *opts,
+		__rte_unused uint8_t *enabled_rdevs,
+		__rte_unused uint8_t nb_rawdevs)
+{
+	if (opts->op_type != CPERF_MULTI_FN)
+		return -1;
+
 	return 0;
 }
+#endif /* MULTI_FN_SUPPORTED */
 
 static int
 cperf_check_test_vector(struct cperf_options *opts,
@@ -499,10 +641,16 @@ main(int argc, char **argv)
 	struct cperf_test_vector *t_vec = NULL;
 	struct cperf_op_fns op_fns;
 	void *ctx[RTE_MAX_LCORE] = { };
-	int nb_cryptodevs = 0;
+	int nb_devs = 0;
 	uint16_t total_nb_qps = 0;
-	uint8_t cdev_id, i;
-	uint8_t enabled_cdevs[RTE_CRYPTO_MAX_DEVS] = { 0 };
+	uint8_t dev_id, i;
+#ifndef MULTI_FN_SUPPORTED
+	uint8_t enabled_devs[RTE_CRYPTO_MAX_DEVS] = { 0 };
+#else
+	uint8_t max_devs = RTE_MAX(RTE_CRYPTO_MAX_DEVS, RTE_RAWDEV_MAX_DEVS);
+	uint8_t enabled_devs[max_devs];
+	memset(enabled_devs, 0x0, max_devs);
+#endif /* MULTI_FN_SUPPORTED */
 
 	uint8_t buffer_size_idx = 0;
 
@@ -531,24 +679,49 @@ main(int argc, char **argv)
 		goto err;
 	}
 
-	nb_cryptodevs = cperf_initialize_cryptodev(&opts, enabled_cdevs);
+#ifdef MULTI_FN_SUPPORTED
+	if (opts.op_type == CPERF_MULTI_FN) {
+		nb_devs = cperf_initialize_rawdev(&opts, enabled_devs);
 
-	if (!opts.silent)
-		cperf_options_dump(&opts);
+		if (!opts.silent)
+			cperf_options_dump(&opts);
 
-	if (nb_cryptodevs < 1) {
-		RTE_LOG(ERR, USER1, "Failed to initialise requested crypto "
-				"device type\n");
-		nb_cryptodevs = 0;
-		goto err;
-	}
+		if (nb_devs < 1) {
+			RTE_LOG(ERR, USER1, "Failed to initialise requested "
+					"raw device type\n");
+			nb_devs = 0;
+			goto err;
+		}
 
-	ret = cperf_verify_devices_capabilities(&opts, enabled_cdevs,
-			nb_cryptodevs);
-	if (ret) {
-		RTE_LOG(ERR, USER1, "Crypto device type does not support "
-				"capabilities requested\n");
-		goto err;
+		ret = cperf_verify_raw_devices_capabilities(&opts,
+				enabled_devs, nb_devs);
+		if (ret) {
+			RTE_LOG(ERR, USER1, "Raw device type does not "
+					"support capabilities requested\n");
+			goto err;
+		}
+	} else
+#endif /* MULTI_FN_SUPPORTED */
+	{
+		nb_devs = cperf_initialize_cryptodev(&opts, enabled_devs);
+
+		if (!opts.silent)
+			cperf_options_dump(&opts);
+
+		if (nb_devs < 1) {
+			RTE_LOG(ERR, USER1, "Failed to initialise requested "
+					"crypto device type\n");
+			nb_devs = 0;
+			goto err;
+		}
+
+		ret = cperf_verify_crypto_devices_capabilities(&opts,
+				enabled_devs, nb_devs);
+		if (ret) {
+			RTE_LOG(ERR, USER1, "Crypto device type does not "
+					"support capabilities requested\n");
+			goto err;
+		}
 	}
 
 	if (opts.test_file != NULL) {
@@ -585,23 +758,29 @@ main(int argc, char **argv)
 	if (!opts.silent)
 		show_test_vector(t_vec);
 
-	total_nb_qps = nb_cryptodevs * opts.nb_qps;
+	total_nb_qps = nb_devs * opts.nb_qps;
 
 	i = 0;
-	uint8_t qp_id = 0, cdev_index = 0;
+	uint8_t qp_id = 0, dev_index = 0;
 	RTE_LCORE_FOREACH_SLAVE(lcore_id) {
 
 		if (i == total_nb_qps)
 			break;
 
-		cdev_id = enabled_cdevs[cdev_index];
+		dev_id = enabled_devs[dev_index];
 
-		uint8_t socket_id = rte_cryptodev_socket_id(cdev_id);
+		uint8_t socket_id;
+#ifdef MULTI_FN_SUPPORTED
+		if (opts.op_type == CPERF_MULTI_FN)
+			socket_id = rte_rawdev_socket_id(dev_id);
+		else
+#endif /* MULTI_FN_SUPPORTED */
+			socket_id = rte_cryptodev_socket_id(dev_id);
 
 		ctx[i] = cperf_testmap[opts.test].constructor(
 				session_pool_socket[socket_id].sess_mp,
 				session_pool_socket[socket_id].priv_mp,
-				cdev_id, qp_id,
+				dev_id, qp_id,
 				&opts, t_vec, &op_fns);
 		if (ctx[i] == NULL) {
 			RTE_LOG(ERR, USER1, "Test run constructor failed\n");
@@ -609,7 +788,7 @@ main(int argc, char **argv)
 		}
 		qp_id = (qp_id + 1) % opts.nb_qps;
 		if (qp_id == 0)
-			cdev_index++;
+			dev_index++;
 		i++;
 	}
 
@@ -726,9 +905,15 @@ main(int argc, char **argv)
 		i++;
 	}
 
-	for (i = 0; i < nb_cryptodevs &&
-			i < RTE_CRYPTO_MAX_DEVS; i++)
-		rte_cryptodev_stop(enabled_cdevs[i]);
+	for (i = 0; i < nb_devs &&
+			i < RTE_DIM(enabled_devs); i++) {
+#ifdef MULTI_FN_SUPPORTED
+		if (opts.op_type == CPERF_MULTI_FN)
+			rte_rawdev_stop(enabled_devs[i]);
+		else
+#endif /* MULTI_FN_SUPPORTED */
+			rte_cryptodev_stop(enabled_devs[i]);
+	}
 
 	free_test_vector(t_vec, &opts);
 
@@ -746,9 +931,15 @@ main(int argc, char **argv)
 		i++;
 	}
 
-	for (i = 0; i < nb_cryptodevs &&
-			i < RTE_CRYPTO_MAX_DEVS; i++)
-		rte_cryptodev_stop(enabled_cdevs[i]);
+	for (i = 0; i < nb_devs &&
+			i < RTE_DIM(enabled_devs); i++) {
+#ifdef MULTI_FN_SUPPORTED
+		if (opts.op_type == CPERF_MULTI_FN)
+			rte_rawdev_stop(enabled_devs[i]);
+		else
+#endif /* MULTI_FN_SUPPORTED */
+			rte_cryptodev_stop(enabled_devs[i]);
+	}
 	rte_free(opts.imix_buffer_sizes);
 	free_test_vector(t_vec, &opts);
 
diff --git a/app/test-crypto-perf/meson.build b/app/test-crypto-perf/meson.build
index 0674396da..28b54611f 100644
--- a/app/test-crypto-perf/meson.build
+++ b/app/test-crypto-perf/meson.build
@@ -13,3 +13,9 @@ sources = files('cperf_ops.c',
 		'cperf_test_verify.c',
 		'main.c')
 deps += ['cryptodev', 'security']
+#deps += ['cryptodev', 'security', 'rawdev', 'common_multi_fn']
+
+if dpdk_conf.has('RTE_LIBRTE_MULTI_FN_COMMON') and dpdk_conf.has('RTE_LIBRTE_PMD_AESNI_MB_RAWDEV')
+	deps += ['rawdev', 'common_multi_fn']
+	cflags += ['-DMULTI_FN_SUPPORTED']
+endif
-- 
2.17.1