diff mbox series

[v3] app/eventdev: add crypto producer mode

Message ID 736dc424a780b9547033f76f8911342ff06d3f87.1641292088.git.sthotton@marvell.com (mailing list archive)
State Superseded, archived
Delegated to: Jerin Jacob
Headers show
Series [v3] app/eventdev: add crypto producer mode | expand

Checks

Context Check Description
ci/intel-Testing success Testing PASS
ci/Intel-compilation success Compilation OK
ci/iol-abi-testing success Testing PASS
ci/iol-x86_64-compile-testing success Testing PASS
ci/iol-aarch64-compile-testing success Testing PASS
ci/iol-x86_64-unit-testing success Testing PASS
ci/iol-intel-Performance success Performance Testing PASS
ci/iol-aarch64-unit-testing success Testing PASS
ci/iol-broadcom-Performance success Performance Testing PASS
ci/iol-mellanox-Performance success Performance Testing PASS
ci/iol-broadcom-Functional success Functional Testing PASS
ci/iol-intel-Functional success Functional Testing PASS
ci/github-robot: build success github build: passed
ci/checkpatch success coding style OK

Commit Message

Shijith Thotton Jan. 4, 2022, 10:30 a.m. UTC
In crypto producer mode, producer core enqueues cryptodev with software
generated crypto ops and worker core dequeues crypto completion events
from the eventdev. Event crypto metadata used for above processing is
pre-populated in each crypto session.

Parameter --prod_type_cryptodev can be used to enable crypto producer
mode. Parameter --crypto_adptr_mode can be set to select the crypto
adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.

This mode can be used to measure the performance of crypto adapter.

Example:
  ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
  --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
  --stlist=a --wlcores 1 --plcores 2

Signed-off-by: Shijith Thotton <sthotton@marvell.com>
---
v3:
* Reduce dereference inside loop.

v2:
* Fix RHEL compilation warning.

 app/test-eventdev/evt_common.h       |   3 +
 app/test-eventdev/evt_main.c         |  13 +-
 app/test-eventdev/evt_options.c      |  27 ++
 app/test-eventdev/evt_options.h      |  12 +
 app/test-eventdev/evt_test.h         |   6 +
 app/test-eventdev/test_perf_atq.c    |  51 ++++
 app/test-eventdev/test_perf_common.c | 410 ++++++++++++++++++++++++++-
 app/test-eventdev/test_perf_common.h |  16 ++
 app/test-eventdev/test_perf_queue.c  |  52 ++++
 doc/guides/tools/testeventdev.rst    |  13 +
 10 files changed, 596 insertions(+), 7 deletions(-)

Comments

Jerin Jacob Jan. 21, 2022, 12:25 p.m. UTC | #1
On Tue, Jan 4, 2022 at 4:04 PM Shijith Thotton <sthotton@marvell.com> wrote:
>
> In crypto producer mode, producer core enqueues cryptodev with software
> generated crypto ops and worker core dequeues crypto completion events
> from the eventdev. Event crypto metadata used for above processing is
> pre-populated in each crypto session.
>
> Parameter --prod_type_cryptodev can be used to enable crypto producer
> mode. Parameter --crypto_adptr_mode can be set to select the crypto
> adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
>
> This mode can be used to measure the performance of crypto adapter.
>
> Example:
>   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
>   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
>   --stlist=a --wlcores 1 --plcores 2
>
> Signed-off-by: Shijith Thotton <sthotton@marvell.com>
> ---
> v3:
> * Reduce dereference inside loop.

Hi @Gujjar, Abhinandan S

Do you have any comments or objections to merging this change?


>
> v2:
> * Fix RHEL compilation warning.
>
>  app/test-eventdev/evt_common.h       |   3 +
>  app/test-eventdev/evt_main.c         |  13 +-
>  app/test-eventdev/evt_options.c      |  27 ++
>  app/test-eventdev/evt_options.h      |  12 +
>  app/test-eventdev/evt_test.h         |   6 +
>  app/test-eventdev/test_perf_atq.c    |  51 ++++
>  app/test-eventdev/test_perf_common.c | 410 ++++++++++++++++++++++++++-
>  app/test-eventdev/test_perf_common.h |  16 ++
>  app/test-eventdev/test_perf_queue.c  |  52 ++++
>  doc/guides/tools/testeventdev.rst    |  13 +
>  10 files changed, 596 insertions(+), 7 deletions(-)
>
> diff --git a/app/test-eventdev/evt_common.h b/app/test-eventdev/evt_common.h
> index f466434459..2f301a7e79 100644
> --- a/app/test-eventdev/evt_common.h
> +++ b/app/test-eventdev/evt_common.h
> @@ -7,6 +7,7 @@
>
>  #include <rte_common.h>
>  #include <rte_debug.h>
> +#include <rte_event_crypto_adapter.h>
>  #include <rte_eventdev.h>
>  #include <rte_service.h>
>
> @@ -39,6 +40,7 @@ enum evt_prod_type {
>         EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
>         EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter. */
>         EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer Adapter. */
> +       EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto Adapter. */
>         EVT_PROD_TYPE_MAX,
>  };
>
> @@ -77,6 +79,7 @@ struct evt_options {
>         uint64_t timer_tick_nsec;
>         uint64_t optm_timer_tick_nsec;
>         enum evt_prod_type prod_type;
> +       enum rte_event_crypto_adapter_mode crypto_adptr_mode;
>  };
>
>  static inline bool
> diff --git a/app/test-eventdev/evt_main.c b/app/test-eventdev/evt_main.c
> index 194c980c7a..cef0fb1382 100644
> --- a/app/test-eventdev/evt_main.c
> +++ b/app/test-eventdev/evt_main.c
> @@ -161,12 +161,19 @@ main(int argc, char **argv)
>                         goto mempool_destroy;
>                 }
>         }
> +       /* Test specific cryptodev setup */
> +       if (test->ops.cryptodev_setup) {
> +               if (test->ops.cryptodev_setup(test, &opt)) {
> +                       evt_err("%s: cryptodev setup failed", opt.test_name);
> +                       goto ethdev_destroy;
> +               }
> +       }
>
>         /* Test specific eventdev setup */
>         if (test->ops.eventdev_setup) {
>                 if (test->ops.eventdev_setup(test, &opt)) {
>                         evt_err("%s: eventdev setup failed", opt.test_name);
> -                       goto ethdev_destroy;
> +                       goto cryptodev_destroy;
>                 }
>         }
>
> @@ -197,6 +204,10 @@ main(int argc, char **argv)
>         if (test->ops.eventdev_destroy)
>                 test->ops.eventdev_destroy(test, &opt);
>
> +cryptodev_destroy:
> +       if (test->ops.cryptodev_destroy)
> +               test->ops.cryptodev_destroy(test, &opt);
> +
>  ethdev_destroy:
>         if (test->ops.ethdev_destroy)
>                 test->ops.ethdev_destroy(test, &opt);
> diff --git a/app/test-eventdev/evt_options.c b/app/test-eventdev/evt_options.c
> index 753a7dbd7d..5ad1491020 100644
> --- a/app/test-eventdev/evt_options.c
> +++ b/app/test-eventdev/evt_options.c
> @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct evt_options *opt,
>         return 0;
>  }
>
> +static int
> +evt_parse_crypto_prod_type(struct evt_options *opt,
> +                          const char *arg __rte_unused)
> +{
> +       opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
> +       return 0;
> +}
> +
> +static int
> +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg)
> +{
> +       uint8_t mode;
> +       int ret;
> +
> +       ret = parser_read_uint8(&mode, arg);
> +       opt->crypto_adptr_mode = mode ? RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
> +                                       RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
> +       return ret;
> +}
> +
>  static int
>  evt_parse_test_name(struct evt_options *opt, const char *arg)
>  {
> @@ -335,6 +355,7 @@ usage(char *program)
>                 "\t--queue_priority   : enable queue priority\n"
>                 "\t--deq_tmo_nsec     : global dequeue timeout\n"
>                 "\t--prod_type_ethdev : use ethernet device as producer.\n"
> +               "\t--prod_type_cryptodev : use crypto device as producer.\n"
>                 "\t--prod_type_timerdev : use event timer device as producer.\n"
>                 "\t                     expity_nsec would be the timeout\n"
>                 "\t                     in ns.\n"
> @@ -345,6 +366,8 @@ usage(char *program)
>                 "\t--timer_tick_nsec  : timer tick interval in ns.\n"
>                 "\t--max_tmo_nsec     : max timeout interval in ns.\n"
>                 "\t--expiry_nsec      : event timer expiry ns.\n"
> +               "\t--crypto_adptr_mode : 0 for OP_NEW mode (default) and\n"
> +               "\t                      1 for OP_FORWARD mode.\n"
>                 "\t--mbuf_sz          : packet mbuf size.\n"
>                 "\t--max_pkt_sz       : max packet size.\n"
>                 "\t--prod_enq_burst_sz : producer enqueue burst size.\n"
> @@ -415,8 +438,10 @@ static struct option lgopts[] = {
>         { EVT_QUEUE_PRIORITY,      0, 0, 0 },
>         { EVT_DEQ_TMO_NSEC,        1, 0, 0 },
>         { EVT_PROD_ETHDEV,         0, 0, 0 },
> +       { EVT_PROD_CRYPTODEV,      0, 0, 0 },
>         { EVT_PROD_TIMERDEV,       0, 0, 0 },
>         { EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
> +       { EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
>         { EVT_NB_TIMERS,           1, 0, 0 },
>         { EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
>         { EVT_TIMER_TICK_NSEC,     1, 0, 0 },
> @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct evt_options *opt)
>                 { EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
>                 { EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
>                 { EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
> +               { EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
>                 { EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
>                 { EVT_PROD_TIMERDEV_BURST, evt_parse_timer_prod_type_burst},
> +               { EVT_CRYPTO_ADPTR_MODE, evt_parse_crypto_adptr_mode},
>                 { EVT_NB_TIMERS, evt_parse_nb_timers},
>                 { EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
>                 { EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec},
> diff --git a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
> index 413d7092f0..2231c58801 100644
> --- a/app/test-eventdev/evt_options.h
> +++ b/app/test-eventdev/evt_options.h
> @@ -9,6 +9,7 @@
>  #include <stdbool.h>
>
>  #include <rte_common.h>
> +#include <rte_cryptodev.h>
>  #include <rte_ethdev.h>
>  #include <rte_eventdev.h>
>  #include <rte_lcore.h>
> @@ -33,8 +34,10 @@
>  #define EVT_QUEUE_PRIORITY       ("queue_priority")
>  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
>  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
> +#define EVT_PROD_CRYPTODEV      ("prod_type_cryptodev")
>  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
>  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
> +#define EVT_CRYPTO_ADPTR_MODE   ("crypto_adptr_mode")
>  #define EVT_NB_TIMERS            ("nb_timers")
>  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
>  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
> @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type prod_type)
>                 return "Ethdev Rx Adapter";
>         case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
>                 return "Event timer adapter";
> +       case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> +               return "Event crypto adapter";
>         }
>
>         return "";
> @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options *opt)
>                         evt_dump("timer_tick_nsec", "%"PRIu64"",
>                                         opt->timer_tick_nsec);
>                 break;
> +       case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> +               snprintf(name, EVT_PROD_MAX_NAME_LEN,
> +                        "Event crypto adapter producers");
> +               evt_dump("crypto adapter mode", "%s",
> +                        opt->crypto_adptr_mode ? "OP_FORWARD" : "OP_NEW");
> +               evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
> +               break;
>         }
>         evt_dump("prod_type", "%s", name);
>  }
> diff --git a/app/test-eventdev/evt_test.h b/app/test-eventdev/evt_test.h
> index f07d2c3336..50fa474ec2 100644
> --- a/app/test-eventdev/evt_test.h
> +++ b/app/test-eventdev/evt_test.h
> @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
>                 (struct evt_test *test, struct evt_options *opt);
>  typedef int (*evt_test_ethdev_setup_t)
>                 (struct evt_test *test, struct evt_options *opt);
> +typedef int (*evt_test_cryptodev_setup_t)
> +               (struct evt_test *test, struct evt_options *opt);
>  typedef int (*evt_test_eventdev_setup_t)
>                 (struct evt_test *test, struct evt_options *opt);
>  typedef int (*evt_test_launch_lcores_t)
> @@ -39,6 +41,8 @@ typedef void (*evt_test_eventdev_destroy_t)
>                 (struct evt_test *test, struct evt_options *opt);
>  typedef void (*evt_test_ethdev_destroy_t)
>                 (struct evt_test *test, struct evt_options *opt);
> +typedef void (*evt_test_cryptodev_destroy_t)
> +               (struct evt_test *test, struct evt_options *opt);
>  typedef void (*evt_test_mempool_destroy_t)
>                 (struct evt_test *test, struct evt_options *opt);
>  typedef void (*evt_test_destroy_t)
> @@ -52,10 +56,12 @@ struct evt_test_ops {
>         evt_test_mempool_setup_t mempool_setup;
>         evt_test_ethdev_setup_t ethdev_setup;
>         evt_test_eventdev_setup_t eventdev_setup;
> +       evt_test_cryptodev_setup_t cryptodev_setup;
>         evt_test_launch_lcores_t launch_lcores;
>         evt_test_result_t test_result;
>         evt_test_eventdev_destroy_t eventdev_destroy;
>         evt_test_ethdev_destroy_t ethdev_destroy;
> +       evt_test_cryptodev_destroy_t cryptodev_destroy;
>         evt_test_mempool_destroy_t mempool_destroy;
>         evt_test_destroy_t test_destroy;
>  };
> diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-eventdev/test_perf_atq.c
> index 8fd51004ee..dbb1dc8c0c 100644
> --- a/app/test-eventdev/test_perf_atq.c
> +++ b/app/test-eventdev/test_perf_atq.c
> @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int enable_fwd_latency)
>                         continue;
>                 }
>
> +               if (prod_crypto_type &&
> +                   (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> +                       struct rte_crypto_op *op = ev.event_ptr;
> +
> +                       if (op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +                               if (op->sym->m_dst == NULL)
> +                                       ev.event_ptr = op->sym->m_src;
> +                               else
> +                                       ev.event_ptr = op->sym->m_dst;
> +                               rte_crypto_op_free(op);
> +                       } else {
> +                               rte_crypto_op_free(op);
> +                               continue;
> +                       }
> +               }
> +
>                 if (enable_fwd_latency && !prod_timer_type)
>                 /* first stage in pipeline, mark ts to compute fwd latency */
>                         atq_mark_fwd_latency(&ev);
> @@ -87,6 +103,25 @@ perf_atq_worker_burst(void *arg, const int enable_fwd_latency)
>                 }
>
>                 for (i = 0; i < nb_rx; i++) {
> +                       if (prod_crypto_type &&
> +                           (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> +                               struct rte_crypto_op *op = ev[i].event_ptr;
> +
> +                               if (op->status ==
> +                                   RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +                                       if (op->sym->m_dst == NULL)
> +                                               ev[i].event_ptr =
> +                                                       op->sym->m_src;
> +                                       else
> +                                               ev[i].event_ptr =
> +                                                       op->sym->m_dst;
> +                                       rte_crypto_op_free(op);
> +                               } else {
> +                                       rte_crypto_op_free(op);
> +                                       continue;
> +                               }
> +                       }
> +
>                         if (enable_fwd_latency && !prod_timer_type) {
>                                 rte_prefetch0(ev[i+1].event_ptr);
>                                 /* first stage in pipeline.
> @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test, struct evt_options *opt)
>                                 return ret;
>                         }
>                 }
> +       } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> +               uint8_t cdev_id, cdev_count;
> +
> +               cdev_count = rte_cryptodev_count();
> +               for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +                       ret = rte_cryptodev_start(cdev_id);
> +                       if (ret) {
> +                               evt_err("Failed to start cryptodev %u",
> +                                       cdev_id);
> +                               return ret;
> +                       }
> +               }
> +
> +               rte_event_crypto_adapter_start(t->crypto_adptr.id);
>         }
>
>         return 0;
> @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
>         .opt_dump           = perf_atq_opt_dump,
>         .test_setup         = perf_test_setup,
>         .ethdev_setup       = perf_ethdev_setup,
> +       .cryptodev_setup    = perf_cryptodev_setup,
>         .mempool_setup      = perf_mempool_setup,
>         .eventdev_setup     = perf_atq_eventdev_setup,
>         .launch_lcores      = perf_atq_launch_lcores,
>         .eventdev_destroy   = perf_eventdev_destroy,
>         .mempool_destroy    = perf_mempool_destroy,
>         .ethdev_destroy     = perf_ethdev_destroy,
> +       .cryptodev_destroy  = perf_cryptodev_destroy,
>         .test_result        = perf_test_result,
>         .test_destroy       = perf_test_destroy,
>  };
> diff --git a/app/test-eventdev/test_perf_common.c b/app/test-eventdev/test_perf_common.c
> index 9b73874151..91cb6748ee 100644
> --- a/app/test-eventdev/test_perf_common.c
> +++ b/app/test-eventdev/test_perf_common.c
> @@ -6,6 +6,8 @@
>
>  #include "test_perf_common.h"
>
> +#define NB_CRYPTODEV_DESCRIPTORS 128
> +
>  int
>  perf_test_result(struct evt_test *test, struct evt_options *opt)
>  {
> @@ -272,6 +274,125 @@ perf_event_timer_producer_burst(void *arg)
>         return 0;
>  }
>
> +static inline void
> +crypto_adapter_enq_op_new(struct prod_data *p)
> +{
> +       struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> +       struct test_perf *t = p->t;
> +       const uint32_t nb_flows = t->nb_flows;
> +       const uint64_t nb_pkts = t->nb_pkts;
> +       struct rte_mempool *pool = t->pool;
> +       struct rte_crypto_sym_op *sym_op;
> +       struct evt_options *opt = t->opt;
> +       uint16_t qp_id = p->cdev_qp_id;
> +       uint8_t cdev_id = p->cdev_id;
> +       uint32_t flow_counter = 0;
> +       struct rte_crypto_op *op;
> +       struct rte_mbuf *m;
> +       uint64_t count = 0;
> +       uint16_t len;
> +
> +       if (opt->verbose_level > 1)
> +               printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id %u\n",
> +                      __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
> +                      p->cdev_qp_id);
> +
> +       len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> +
> +       while (count < nb_pkts && t->done == false) {
> +               m = rte_pktmbuf_alloc(pool);
> +               if (m == NULL)
> +                       continue;
> +
> +               rte_pktmbuf_append(m, len);
> +               op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> +                                        RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> +               sym_op = op->sym;
> +               sym_op->m_src = m;
> +               sym_op->cipher.data.offset = 0;
> +               sym_op->cipher.data.length = len;
> +               rte_crypto_op_attach_sym_session(
> +                       op, crypto_sess[flow_counter++ % nb_flows]);
> +               while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op, 1) !=
> +                      1) {
> +                       if (t->done)
> +                               break;
> +                       rte_pause();
> +               }
> +               count++;
> +       }
> +}
> +
> +static inline void
> +crypto_adapter_enq_op_fwd(struct prod_data *p)
> +{
> +       struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> +       const uint8_t dev_id = p->dev_id;
> +       const uint8_t port = p->port_id;
> +       struct test_perf *t = p->t;
> +       const uint32_t nb_flows = t->nb_flows;
> +       const uint64_t nb_pkts = t->nb_pkts;
> +       struct rte_mempool *pool = t->pool;
> +       struct evt_options *opt = t->opt;
> +       struct rte_crypto_sym_op *sym_op;
> +       uint32_t flow_counter = 0;
> +       struct rte_crypto_op *op;
> +       struct rte_event ev;
> +       struct rte_mbuf *m;
> +       uint64_t count = 0;
> +       uint16_t len;
> +
> +       if (opt->verbose_level > 1)
> +               printf("%s(): lcore %d port %d queue %d cdev_id %u cdev_qp_id %u\n",
> +                      __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
> +                      p->cdev_qp_id);
> +
> +       ev.event = 0;
> +       ev.op = RTE_EVENT_OP_NEW;
> +       ev.queue_id = p->queue_id;
> +       ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
> +       ev.event_type = RTE_EVENT_TYPE_CPU;
> +       len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> +
> +       while (count < nb_pkts && t->done == false) {
> +               m = rte_pktmbuf_alloc(pool);
> +               if (m == NULL)
> +                       continue;
> +
> +               rte_pktmbuf_append(m, len);
> +               op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> +                                        RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> +               sym_op = op->sym;
> +               sym_op->m_src = m;
> +               sym_op->cipher.data.offset = 0;
> +               sym_op->cipher.data.length = len;
> +               rte_crypto_op_attach_sym_session(
> +                       op, crypto_sess[flow_counter++ % nb_flows]);
> +               ev.event_ptr = op;
> +               while (rte_event_crypto_adapter_enqueue(dev_id, port, &ev, 1) !=
> +                      1) {
> +                       if (t->done)
> +                               break;
> +                       rte_pause();
> +               }
> +               count++;
> +       }
> +}
> +
> +static inline int
> +perf_event_crypto_producer(void *arg)
> +{
> +       struct prod_data *p = arg;
> +       struct evt_options *opt = p->t->opt;
> +
> +       if (opt->crypto_adptr_mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
> +               crypto_adapter_enq_op_new(p);
> +       else
> +               crypto_adapter_enq_op_fwd(p);
> +
> +       return 0;
> +}
> +
>  static int
>  perf_producer_wrapper(void *arg)
>  {
> @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
>         else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
>                         t->opt->timdev_use_burst)
>                 return perf_event_timer_producer_burst(arg);
> +       else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> +               return perf_event_crypto_producer(arg);
>         return 0;
>  }
>
> @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
>                         if (remaining <= 0) {
>                                 t->result = EVT_TEST_SUCCESS;
>                                 if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -                                       opt->prod_type ==
> -                                       EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> +                                   opt->prod_type ==
> +                                           EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> +                                   opt->prod_type ==
> +                                           EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>                                         t->done = true;
>                                         break;
>                                 }
> @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
>
>                 if (new_cycles - dead_lock_cycles > dead_lock_sample &&
>                     (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -                    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
> +                    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> +                    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
>                         remaining = t->outstand_pkts - processed_pkts(t);
>                         if (dead_lock_remaining == remaining) {
>                                 rte_event_dev_dump(opt->dev_id, stdout);
> @@ -537,6 +663,96 @@ perf_event_timer_adapter_setup(struct test_perf *t)
>         return 0;
>  }
>
> +static int
> +perf_event_crypto_adapter_setup(struct test_perf *t,
> +                               struct rte_event_port_conf port_conf)
> +{
> +       struct evt_options *opt = t->opt;
> +       uint8_t cdev_id, cdev_count;
> +       int ret;
> +
> +       t->crypto_adptr.id = 0;
> +       ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt->dev_id,
> +                                             &port_conf, 0);
> +       if (ret)
> +               return ret;
> +
> +       cdev_count = rte_cryptodev_count();
> +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +               uint32_t cap;
> +
> +               ret = rte_event_crypto_adapter_caps_get(opt->dev_id, cdev_id,
> +                                                       &cap);
> +               if (ret) {
> +                       evt_err("Failed to get crypto adapter capabilities");
> +                       return ret;
> +               }
> +
> +               if (((opt->crypto_adptr_mode ==
> +                     RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
> +                    !(cap &
> +                      RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
> +                   ((opt->crypto_adptr_mode ==
> +                     RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
> +                    !(cap &
> +                      RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
> +                       evt_err("crypto adapter %s mode unsupported\n",
> +                               opt->crypto_adptr_mode ? "OP_FORWARD" :
> +                                                        "OP_NEW");
> +                       return -EINVAL;
> +               }
> +
> +               if (!(cap &
> +                     RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
> +                       evt_err("Storing crypto session not supported");
> +                       return -EINVAL;
> +               }
> +
> +               if (cap &
> +                   RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
> +                       struct rte_event response_info;
> +
> +                       response_info.event = 0;
> +                       ret = rte_event_crypto_adapter_queue_pair_add(
> +                               t->crypto_adptr.id, cdev_id, -1,
> +                               &response_info);
> +               } else {
> +                       ret = rte_event_crypto_adapter_queue_pair_add(
> +                               t->crypto_adptr.id, cdev_id, -1, NULL);
> +               }
> +               if (ret)
> +                       return ret;
> +       }
> +
> +       return 0;
> +}
> +
> +static struct rte_cryptodev_sym_session *
> +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t)
> +{
> +       struct rte_crypto_sym_xform cipher_xform;
> +       struct rte_cryptodev_sym_session *sess;
> +
> +       cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
> +       cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
> +       cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
> +       cipher_xform.next = NULL;
> +
> +       sess = rte_cryptodev_sym_session_create(t->crypto_adptr.sess_pool);
> +       if (sess == NULL) {
> +               evt_err("Failed to create sym session");
> +               return NULL;
> +       }
> +
> +       if (rte_cryptodev_sym_session_init(p->cdev_id, sess, &cipher_xform,
> +                                          t->crypto_adptr.sess_priv_pool)) {
> +               evt_err("Failed to init session");
> +               return NULL;
> +       }
> +
> +       return sess;
> +}
> +
>  int
>  perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>                                 uint8_t stride, uint8_t nb_queues,
> @@ -598,6 +814,55 @@ perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>                 ret = perf_event_timer_adapter_setup(t);
>                 if (ret)
>                         return ret;
> +       } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> +               uint8_t cdev_id = 0;
> +               uint16_t qp_id = 0;
> +
> +               prod = 0;
> +               for (; port < perf_nb_event_ports(opt); port++) {
> +                       struct rte_cryptodev_sym_session *crypto_sess;
> +                       union rte_event_crypto_metadata m_data;
> +                       struct prod_data *p = &t->prod[port];
> +                       uint32_t flow_id;
> +
> +                       if (qp_id == rte_cryptodev_queue_pair_count(cdev_id)) {
> +                               cdev_id++;
> +                               qp_id = 0;
> +                       }
> +
> +                       p->dev_id = opt->dev_id;
> +                       p->port_id = port;
> +                       p->queue_id = prod * stride;
> +                       p->cdev_id = cdev_id;
> +                       p->cdev_qp_id = qp_id;
> +                       p->crypto_sess = rte_zmalloc_socket(
> +                               NULL, sizeof(crypto_sess) * t->nb_flows,
> +                               RTE_CACHE_LINE_SIZE, opt->socket_id);
> +
> +                       m_data.request_info.cdev_id = p->cdev_id;
> +                       m_data.request_info.queue_pair_id = p->cdev_qp_id;
> +                       m_data.response_info.op = RTE_EVENT_OP_NEW;
> +                       m_data.response_info.sched_type = RTE_SCHED_TYPE_ATOMIC;
> +                       m_data.response_info.event_type = RTE_EVENT_TYPE_CPU;
> +                       m_data.response_info.queue_id = p->queue_id;
> +                       for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
> +                               crypto_sess = cryptodev_sym_sess_create(p, t);
> +                               if (crypto_sess == NULL)
> +                                       return -ENOMEM;
> +
> +                               m_data.response_info.flow_id = flow_id;
> +                               rte_cryptodev_sym_session_set_user_data(
> +                                       crypto_sess, &m_data, sizeof(m_data));
> +                               p->crypto_sess[flow_id] = crypto_sess;
> +                       }
> +                       p->t = t;
> +                       qp_id++;
> +                       prod++;
> +               }
> +
> +               ret = perf_event_crypto_adapter_setup(t, *port_conf);
> +               if (ret)
> +                       return ret;
>         } else {
>                 prod = 0;
>                 for ( ; port < perf_nb_event_ports(opt); port++) {
> @@ -659,7 +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
>         }
>
>         if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -                       opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> +           opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> +           opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>                 /* Validate producer lcores */
>                 if (evt_lcores_has_overlap(opt->plcores,
>                                         rte_get_main_lcore())) {
> @@ -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct evt_options *opt)
>                 },
>         };
>
> -       if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -                       opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
> +       if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
>                 return 0;
>
>         if (!rte_eth_dev_count_avail()) {
> @@ -841,6 +1106,139 @@ void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt)
>         }
>  }
>
> +int
> +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt)
> +{
> +       uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
> +       struct test_perf *t = evt_test_priv(test);
> +       unsigned int max_session_size;
> +       uint32_t nb_sessions;
> +       int ret;
> +
> +       if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> +               return 0;
> +
> +       cdev_count = rte_cryptodev_count();
> +       if (cdev_count == 0) {
> +               evt_err("No crypto devices available\n");
> +               return -ENODEV;
> +       }
> +
> +       t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
> +               "crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt->pool_sz,
> +               128, 0, rte_socket_id());
> +       if (t->crypto_adptr.op_pool == NULL) {
> +               evt_err("Failed to create crypto op pool");
> +               return -ENOMEM;
> +       }
> +
> +       nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
> +       t->crypto_adptr.sess_pool = rte_cryptodev_sym_session_pool_create(
> +               "ca_sess_pool", nb_sessions, 0, 0,
> +               sizeof(union rte_event_crypto_metadata), SOCKET_ID_ANY);
> +       if (t->crypto_adptr.sess_pool == NULL) {
> +               evt_err("Failed to create sym session pool");
> +               ret = -ENOMEM;
> +               goto err;
> +       }
> +
> +       max_session_size = 0;
> +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +               unsigned int session_size;
> +
> +               session_size =
> +                       rte_cryptodev_sym_get_private_session_size(cdev_id);
> +               if (session_size > max_session_size)
> +                       max_session_size = session_size;
> +       }
> +       max_session_size += sizeof(union rte_event_crypto_metadata);
> +       t->crypto_adptr.sess_priv_pool = rte_mempool_create(
> +               "ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0, NULL,
> +               NULL, NULL, NULL, SOCKET_ID_ANY, 0);
> +       if (t->crypto_adptr.sess_priv_pool == NULL) {
> +               evt_err("failed to create sym session private pool");
> +               ret = -ENOMEM;
> +               goto err;
> +       }
> +
> +       nb_plcores = evt_nr_active_lcores(opt->plcores);
> +       nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) + 1 :
> +                                            nb_plcores / cdev_count;
> +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +               struct rte_cryptodev_qp_conf qp_conf;
> +               struct rte_cryptodev_config conf;
> +               struct rte_cryptodev_info info;
> +               int qp_id;
> +
> +               rte_cryptodev_info_get(cdev_id, &info);
> +               if (nb_qps > info.max_nb_queue_pairs) {
> +                       evt_err("Not enough queue pairs per cryptodev (%u)",
> +                               nb_qps);
> +                       ret = -EINVAL;
> +                       goto err;
> +               }
> +
> +               conf.nb_queue_pairs = nb_qps;
> +               conf.socket_id = SOCKET_ID_ANY;
> +               conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
> +
> +               ret = rte_cryptodev_configure(cdev_id, &conf);
> +               if (ret) {
> +                       evt_err("Failed to configure cryptodev (%u)", cdev_id);
> +                       goto err;
> +               }
> +
> +               qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
> +               qp_conf.mp_session = t->crypto_adptr.sess_pool;
> +               qp_conf.mp_session_private = t->crypto_adptr.sess_priv_pool;
> +
> +               for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
> +                       ret = rte_cryptodev_queue_pair_setup(
> +                               cdev_id, qp_id, &qp_conf,
> +                               rte_cryptodev_socket_id(cdev_id));
> +                       if (ret) {
> +                               evt_err("Failed to setup queue pairs on cryptodev %u\n",
> +                                       cdev_id);
> +                               goto err;
> +                       }
> +               }
> +       }
> +
> +       return 0;
> +err:
> +       rte_mempool_free(t->crypto_adptr.op_pool);
> +       rte_mempool_free(t->crypto_adptr.sess_pool);
> +       rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> +
> +       return ret;
> +}
> +
> +void
> +perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt)
> +{
> +       uint8_t cdev_id, cdev_count = rte_cryptodev_count();
> +       struct test_perf *t = evt_test_priv(test);
> +
> +       RTE_SET_USED(opt);
> +
> +       if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> +               return;
> +
> +       rte_event_crypto_adapter_stop(t->crypto_adptr.id);
> +
> +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +               rte_cryptodev_stop(cdev_id);
> +               rte_event_crypto_adapter_queue_pair_del(t->crypto_adptr.id,
> +                                                       cdev_id, -1);
> +       }
> +
> +       rte_event_crypto_adapter_free(t->crypto_adptr.id);
> +
> +       rte_mempool_free(t->crypto_adptr.op_pool);
> +       rte_mempool_free(t->crypto_adptr.sess_pool);
> +       rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> +}
> +
>  int
>  perf_mempool_setup(struct evt_test *test, struct evt_options *opt)
>  {
> diff --git a/app/test-eventdev/test_perf_common.h b/app/test-eventdev/test_perf_common.h
> index 14dcf80429..d9ad3a0b0d 100644
> --- a/app/test-eventdev/test_perf_common.h
> +++ b/app/test-eventdev/test_perf_common.h
> @@ -9,9 +9,11 @@
>  #include <stdbool.h>
>  #include <unistd.h>
>
> +#include <rte_cryptodev.h>
>  #include <rte_cycles.h>
>  #include <rte_ethdev.h>
>  #include <rte_eventdev.h>
> +#include <rte_event_crypto_adapter.h>
>  #include <rte_event_eth_rx_adapter.h>
>  #include <rte_event_timer_adapter.h>
>  #include <rte_lcore.h>
> @@ -37,9 +39,18 @@ struct prod_data {
>         uint8_t dev_id;
>         uint8_t port_id;
>         uint8_t queue_id;
> +       uint8_t cdev_id;
> +       uint16_t cdev_qp_id;
> +       struct rte_cryptodev_sym_session **crypto_sess;
>         struct test_perf *t;
>  } __rte_cache_aligned;
>
> +struct crypto_adptr_data {
> +       uint8_t id;
> +       struct rte_mempool *op_pool;
> +       struct rte_mempool *sess_pool;
> +       struct rte_mempool *sess_priv_pool;
> +};
>
>  struct test_perf {
>         /* Don't change the offset of "done". Signal handler use this memory
> @@ -58,6 +69,7 @@ struct test_perf {
>         uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
>         struct rte_event_timer_adapter *timer_adptr[
>                 RTE_EVENT_TIMER_ADAPTER_NUM_MAX] __rte_cache_aligned;
> +       struct crypto_adptr_data crypto_adptr;
>  } __rte_cache_aligned;
>
>  struct perf_elt {
> @@ -81,6 +93,8 @@ struct perf_elt {
>         const uint8_t port = w->port_id;\
>         const uint8_t prod_timer_type = \
>                 opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
> +       const uint8_t prod_crypto_type = \
> +               opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
>         uint8_t *const sched_type_list = &t->sched_type_list[0];\
>         struct rte_mempool *const pool = t->pool;\
>         const uint8_t nb_stages = t->opt->nb_stages;\
> @@ -154,6 +168,7 @@ int perf_test_result(struct evt_test *test, struct evt_options *opt);
>  int perf_opt_check(struct evt_options *opt, uint64_t nb_queues);
>  int perf_test_setup(struct evt_test *test, struct evt_options *opt);
>  int perf_ethdev_setup(struct evt_test *test, struct evt_options *opt);
> +int perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt);
>  int perf_mempool_setup(struct evt_test *test, struct evt_options *opt);
>  int perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>                                 uint8_t stride, uint8_t nb_queues,
> @@ -164,6 +179,7 @@ int perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
>  void perf_opt_dump(struct evt_options *opt, uint8_t nb_queues);
>  void perf_test_destroy(struct evt_test *test, struct evt_options *opt);
>  void perf_eventdev_destroy(struct evt_test *test, struct evt_options *opt);
> +void perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt);
>  void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt);
>  void perf_mempool_destroy(struct evt_test *test, struct evt_options *opt);
>
> diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-eventdev/test_perf_queue.c
> index f4ea3a795f..5657c8b3cd 100644
> --- a/app/test-eventdev/test_perf_queue.c
> +++ b/app/test-eventdev/test_perf_queue.c
> @@ -49,6 +49,23 @@ perf_queue_worker(void *arg, const int enable_fwd_latency)
>                         rte_pause();
>                         continue;
>                 }
> +
> +               if (prod_crypto_type &&
> +                   (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> +                       struct rte_crypto_op *op = ev.event_ptr;
> +
> +                       if (op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +                               if (op->sym->m_dst == NULL)
> +                                       ev.event_ptr = op->sym->m_src;
> +                               else
> +                                       ev.event_ptr = op->sym->m_dst;
> +                               rte_crypto_op_free(op);
> +                       } else {
> +                               rte_crypto_op_free(op);
> +                               continue;
> +                       }
> +               }
> +
>                 if (enable_fwd_latency && !prod_timer_type)
>                 /* first q in pipeline, mark timestamp to compute fwd latency */
>                         mark_fwd_latency(&ev, nb_stages);
> @@ -88,6 +105,25 @@ perf_queue_worker_burst(void *arg, const int enable_fwd_latency)
>                 }
>
>                 for (i = 0; i < nb_rx; i++) {
> +                       if (prod_crypto_type &&
> +                           (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> +                               struct rte_crypto_op *op = ev[i].event_ptr;
> +
> +                               if (op->status ==
> +                                   RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +                                       if (op->sym->m_dst == NULL)
> +                                               ev[i].event_ptr =
> +                                                       op->sym->m_src;
> +                                       else
> +                                               ev[i].event_ptr =
> +                                                       op->sym->m_dst;
> +                                       rte_crypto_op_free(op);
> +                               } else {
> +                                       rte_crypto_op_free(op);
> +                                       continue;
> +                               }
> +                       }
> +
>                         if (enable_fwd_latency && !prod_timer_type) {
>                                 rte_prefetch0(ev[i+1].event_ptr);
>                                 /* first queue in pipeline.
> @@ -269,6 +305,20 @@ perf_queue_eventdev_setup(struct evt_test *test, struct evt_options *opt)
>                                 return ret;
>                         }
>                 }
> +       } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> +               uint8_t cdev_id, cdev_count;
> +
> +               cdev_count = rte_cryptodev_count();
> +               for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +                       ret = rte_cryptodev_start(cdev_id);
> +                       if (ret) {
> +                               evt_err("Failed to start cryptodev %u",
> +                                       cdev_id);
> +                               return ret;
> +                       }
> +               }
> +
> +               rte_event_crypto_adapter_start(t->crypto_adptr.id);
>         }
>
>         return 0;
> @@ -311,11 +361,13 @@ static const struct evt_test_ops perf_queue =  {
>         .test_setup         = perf_test_setup,
>         .mempool_setup      = perf_mempool_setup,
>         .ethdev_setup       = perf_ethdev_setup,
> +       .cryptodev_setup    = perf_cryptodev_setup,
>         .eventdev_setup     = perf_queue_eventdev_setup,
>         .launch_lcores      = perf_queue_launch_lcores,
>         .eventdev_destroy   = perf_eventdev_destroy,
>         .mempool_destroy    = perf_mempool_destroy,
>         .ethdev_destroy     = perf_ethdev_destroy,
> +       .cryptodev_destroy  = perf_cryptodev_destroy,
>         .test_result        = perf_test_result,
>         .test_destroy       = perf_test_destroy,
>  };
> diff --git a/doc/guides/tools/testeventdev.rst b/doc/guides/tools/testeventdev.rst
> index 48efb9ea6e..f7d813226d 100644
> --- a/doc/guides/tools/testeventdev.rst
> +++ b/doc/guides/tools/testeventdev.rst
> @@ -120,6 +120,10 @@ The following are the application command-line options:
>
>         Use burst mode event timer adapter as producer.
>
> +* ``--prod_type_cryptodev``
> +
> +        Use crypto device as producer.
> +
>  * ``--timer_tick_nsec``
>
>         Used to dictate number of nano seconds between bucket traversal of the
> @@ -148,6 +152,11 @@ The following are the application command-line options:
>         timeout is out of the supported range of event device it will be
>         adjusted to the highest/lowest supported dequeue timeout supported.
>
> +* ``--crypto_adptr_mode``
> +
> +        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
> +        OP_FORWARD mode.
> +
>  * ``--mbuf_sz``
>
>         Set packet mbuf size. Can be used to configure Jumbo Frames. Only
> @@ -420,6 +429,7 @@ Supported application command line options are following::
>          --prod_type_ethdev
>          --prod_type_timerdev_burst
>          --prod_type_timerdev
> +        --prod_type_cryptodev
>          --prod_enq_burst_sz
>          --timer_tick_nsec
>          --max_tmo_nsec
> @@ -427,6 +437,7 @@ Supported application command line options are following::
>          --nb_timers
>          --nb_timer_adptrs
>          --deq_tmo_nsec
> +        --crypto_adptr_mode
>
>  Example
>  ^^^^^^^
> @@ -529,12 +540,14 @@ Supported application command line options are following::
>          --prod_type_ethdev
>          --prod_type_timerdev_burst
>          --prod_type_timerdev
> +        --prod_type_cryptodev
>          --timer_tick_nsec
>          --max_tmo_nsec
>          --expiry_nsec
>          --nb_timers
>          --nb_timer_adptrs
>          --deq_tmo_nsec
> +        --crypto_adptr_mode
>
>  Example
>  ^^^^^^^
> --
> 2.25.1
>
Gujjar, Abhinandan S Jan. 23, 2022, 4:56 p.m. UTC | #2
Hi Jerin,

> -----Original Message-----
> From: Jerin Jacob <jerinjacobk@gmail.com>
> Sent: Friday, January 21, 2022 5:55 PM
> To: Shijith Thotton <sthotton@marvell.com>
> Cc: dpdk-dev <dev@dpdk.org>; Jerin Jacob <jerinj@marvell.com>; Anoob
> Joseph <anoobj@marvell.com>; Pavan Nikhilesh
> <pbhagavatula@marvell.com>; Akhil Goyal <gakhil@marvell.com>; Gujjar,
> Abhinandan S <abhinandan.gujjar@intel.com>
> Subject: Re: [PATCH v3] app/eventdev: add crypto producer mode
> 
> On Tue, Jan 4, 2022 at 4:04 PM Shijith Thotton <sthotton@marvell.com>
> wrote:
> >
> > In crypto producer mode, producer core enqueues cryptodev with
> > software generated crypto ops and worker core dequeues crypto
> > completion events from the eventdev. Event crypto metadata used for
> > above processing is pre-populated in each crypto session.
> >
> > Parameter --prod_type_cryptodev can be used to enable crypto producer
> > mode. Parameter --crypto_adptr_mode can be set to select the crypto
> > adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
> >
> > This mode can be used to measure the performance of crypto adapter.
> >
> > Example:
> >   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
> >   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
> >   --stlist=a --wlcores 1 --plcores 2
> >
> > Signed-off-by: Shijith Thotton <sthotton@marvell.com>
> > ---
> > v3:
> > * Reduce dereference inside loop.
> 
> Hi @Gujjar, Abhinandan S
> 
> Do you have any comments or objections to merging this change?
I am trying to get the app working on my sandbox. I have few comments for Shijith.

@Shijith Thotton, After trying with openssl cryptodev, I tried with cryptodev_null pmd to get the app working.
It throws an error here too:

root@abhi-VirtualBox:/XDP/DPDK_GIT/dpdk-next-eventdev/abhi# ./app/dpdk-test-eventdev -l 0-2 --vdev=event_sw0  --vdev="crypto_null" -- --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_queue --stlist=a --wlcores 1 --plcores 2
EAL: Detected CPU lcores: 4
EAL: Detected NUMA nodes: 1
EAL: Detected static linkage of DPDK
EAL: Multi-process socket /var/run/dpdk/rte/mp_socket
EAL: Selected IOVA mode 'PA'
EAL: VFIO support initialized
CRYPTODEV: Creating cryptodev crypto_null

CRYPTODEV: Initialisation parameters - name: crypto_null,socket id: 0, max queue pairs: 8
TELEMETRY: No legacy callbacks, legacy socket not created
	driver               : event_sw
	test                 : perf_queue
	dev                  : 0
	verbose_level        : 1
	socket_id            : -1
	pool_sz              : 16384
	main lcore           : 0
	nb_pkts              : 67108864
	nb_timers            : 100000000
	available lcores     : {0 1 2}
	nb_flows             : 1024
	worker deq depth     : 16
	fwd_latency          : false
	nb_prod_lcores       : 1
	producer lcores      : {2}
	nb_worker_lcores     : 1
	worker lcores        : {1}
	nb_stages            : 1
	nb_evdev_ports       : 2
	nb_evdev_queues      : 1
	queue_priority       : false
	sched_type_list      : {A}
	crypto adapter mode  : OP_FORWARD
	nb_cryptodev         : 1
	prod_type            : Event crypto adapter producers
	prod_enq_burst_sz    : 1
CRYPTODEV: elt_size 0 is expanded to 288

error: perf_event_crypto_adapter_setup() crypto adapter OP_FORWARD mode unsupported

error: main() perf_queue: eventdev setup failed
CRYPTODEV: rte_cryptodev_stop() line 1116: Device with dev_id=0 already stopped


With --crypto_adptr_mode 0
error: perf_event_crypto_adapter_setup() crypto adapter OP_NEW mode unsupported


Could you please provide the right commands to get this running?
Meantime, I will go through the code. Thanks!

> 
> 
> >
> > v2:
> > * Fix RHEL compilation warning.
> >
> >  app/test-eventdev/evt_common.h       |   3 +
> >  app/test-eventdev/evt_main.c         |  13 +-
> >  app/test-eventdev/evt_options.c      |  27 ++
> >  app/test-eventdev/evt_options.h      |  12 +
> >  app/test-eventdev/evt_test.h         |   6 +
> >  app/test-eventdev/test_perf_atq.c    |  51 ++++
> >  app/test-eventdev/test_perf_common.c | 410
> > ++++++++++++++++++++++++++-  app/test-
> eventdev/test_perf_common.h |
> > 16 ++  app/test-eventdev/test_perf_queue.c  |  52 ++++
> >  doc/guides/tools/testeventdev.rst    |  13 +
> >  10 files changed, 596 insertions(+), 7 deletions(-)
> >
> > diff --git a/app/test-eventdev/evt_common.h
> > b/app/test-eventdev/evt_common.h index f466434459..2f301a7e79
> 100644
> > --- a/app/test-eventdev/evt_common.h
> > +++ b/app/test-eventdev/evt_common.h
> > @@ -7,6 +7,7 @@
> >
> >  #include <rte_common.h>
> >  #include <rte_debug.h>
> > +#include <rte_event_crypto_adapter.h>
> >  #include <rte_eventdev.h>
> >  #include <rte_service.h>
> >
> > @@ -39,6 +40,7 @@ enum evt_prod_type {
> >         EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
> >         EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter.
> */
> >         EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer
> > Adapter. */
> > +       EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto
> > + Adapter. */
> >         EVT_PROD_TYPE_MAX,
> >  };
> >
> > @@ -77,6 +79,7 @@ struct evt_options {
> >         uint64_t timer_tick_nsec;
> >         uint64_t optm_timer_tick_nsec;
> >         enum evt_prod_type prod_type;
> > +       enum rte_event_crypto_adapter_mode crypto_adptr_mode;
> >  };
> >
> >  static inline bool
> > diff --git a/app/test-eventdev/evt_main.c
> > b/app/test-eventdev/evt_main.c index 194c980c7a..cef0fb1382 100644
> > --- a/app/test-eventdev/evt_main.c
> > +++ b/app/test-eventdev/evt_main.c
> > @@ -161,12 +161,19 @@ main(int argc, char **argv)
> >                         goto mempool_destroy;
> >                 }
> >         }
> > +       /* Test specific cryptodev setup */
> > +       if (test->ops.cryptodev_setup) {
> > +               if (test->ops.cryptodev_setup(test, &opt)) {
> > +                       evt_err("%s: cryptodev setup failed", opt.test_name);
> > +                       goto ethdev_destroy;
> > +               }
> > +       }
> >
> >         /* Test specific eventdev setup */
> >         if (test->ops.eventdev_setup) {
> >                 if (test->ops.eventdev_setup(test, &opt)) {
> >                         evt_err("%s: eventdev setup failed", opt.test_name);
> > -                       goto ethdev_destroy;
> > +                       goto cryptodev_destroy;
> >                 }
> >         }
> >
> > @@ -197,6 +204,10 @@ main(int argc, char **argv)
> >         if (test->ops.eventdev_destroy)
> >                 test->ops.eventdev_destroy(test, &opt);
> >
> > +cryptodev_destroy:
> > +       if (test->ops.cryptodev_destroy)
> > +               test->ops.cryptodev_destroy(test, &opt);
> > +
> >  ethdev_destroy:
> >         if (test->ops.ethdev_destroy)
> >                 test->ops.ethdev_destroy(test, &opt); diff --git
> > a/app/test-eventdev/evt_options.c b/app/test-eventdev/evt_options.c
> > index 753a7dbd7d..5ad1491020 100644
> > --- a/app/test-eventdev/evt_options.c
> > +++ b/app/test-eventdev/evt_options.c
> > @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct
> evt_options *opt,
> >         return 0;
> >  }
> >
> > +static int
> > +evt_parse_crypto_prod_type(struct evt_options *opt,
> > +                          const char *arg __rte_unused) {
> > +       opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
> > +       return 0;
> > +}
> > +
> > +static int
> > +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg)
> > +{
> > +       uint8_t mode;
> > +       int ret;
> > +
> > +       ret = parser_read_uint8(&mode, arg);
> > +       opt->crypto_adptr_mode = mode ?
> RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
> > +                                       RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
> > +       return ret;
> > +}
> > +
> >  static int
> >  evt_parse_test_name(struct evt_options *opt, const char *arg)  { @@
> > -335,6 +355,7 @@ usage(char *program)
> >                 "\t--queue_priority   : enable queue priority\n"
> >                 "\t--deq_tmo_nsec     : global dequeue timeout\n"
> >                 "\t--prod_type_ethdev : use ethernet device as producer.\n"
> > +               "\t--prod_type_cryptodev : use crypto device as producer.\n"
> >                 "\t--prod_type_timerdev : use event timer device as producer.\n"
> >                 "\t                     expity_nsec would be the timeout\n"
> >                 "\t                     in ns.\n"
> > @@ -345,6 +366,8 @@ usage(char *program)
> >                 "\t--timer_tick_nsec  : timer tick interval in ns.\n"
> >                 "\t--max_tmo_nsec     : max timeout interval in ns.\n"
> >                 "\t--expiry_nsec      : event timer expiry ns.\n"
> > +               "\t--crypto_adptr_mode : 0 for OP_NEW mode (default) and\n"
> > +               "\t                      1 for OP_FORWARD mode.\n"
> >                 "\t--mbuf_sz          : packet mbuf size.\n"
> >                 "\t--max_pkt_sz       : max packet size.\n"
> >                 "\t--prod_enq_burst_sz : producer enqueue burst size.\n"
> > @@ -415,8 +438,10 @@ static struct option lgopts[] = {
> >         { EVT_QUEUE_PRIORITY,      0, 0, 0 },
> >         { EVT_DEQ_TMO_NSEC,        1, 0, 0 },
> >         { EVT_PROD_ETHDEV,         0, 0, 0 },
> > +       { EVT_PROD_CRYPTODEV,      0, 0, 0 },
> >         { EVT_PROD_TIMERDEV,       0, 0, 0 },
> >         { EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
> > +       { EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
> >         { EVT_NB_TIMERS,           1, 0, 0 },
> >         { EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
> >         { EVT_TIMER_TICK_NSEC,     1, 0, 0 },
> > @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct
> evt_options *opt)
> >                 { EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
> >                 { EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
> >                 { EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
> > +               { EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
> >                 { EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
> >                 { EVT_PROD_TIMERDEV_BURST,
> > evt_parse_timer_prod_type_burst},
> > +               { EVT_CRYPTO_ADPTR_MODE, evt_parse_crypto_adptr_mode},
> >                 { EVT_NB_TIMERS, evt_parse_nb_timers},
> >                 { EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
> >                 { EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec},
> > diff --git a/app/test-eventdev/evt_options.h
> > b/app/test-eventdev/evt_options.h index 413d7092f0..2231c58801 100644
> > --- a/app/test-eventdev/evt_options.h
> > +++ b/app/test-eventdev/evt_options.h
> > @@ -9,6 +9,7 @@
> >  #include <stdbool.h>
> >
> >  #include <rte_common.h>
> > +#include <rte_cryptodev.h>
> >  #include <rte_ethdev.h>
> >  #include <rte_eventdev.h>
> >  #include <rte_lcore.h>
> > @@ -33,8 +34,10 @@
> >  #define EVT_QUEUE_PRIORITY       ("queue_priority")
> >  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
> >  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
> > +#define EVT_PROD_CRYPTODEV      ("prod_type_cryptodev")
> >  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
> >  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
> > +#define EVT_CRYPTO_ADPTR_MODE   ("crypto_adptr_mode")
> >  #define EVT_NB_TIMERS            ("nb_timers")
> >  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
> >  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
> > @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type
> prod_type)
> >                 return "Ethdev Rx Adapter";
> >         case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
> >                 return "Event timer adapter";
> > +       case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> > +               return "Event crypto adapter";
> >         }
> >
> >         return "";
> > @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options
> *opt)
> >                         evt_dump("timer_tick_nsec", "%"PRIu64"",
> >                                         opt->timer_tick_nsec);
> >                 break;
> > +       case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> > +               snprintf(name, EVT_PROD_MAX_NAME_LEN,
> > +                        "Event crypto adapter producers");
> > +               evt_dump("crypto adapter mode", "%s",
> > +                        opt->crypto_adptr_mode ? "OP_FORWARD" : "OP_NEW");
> > +               evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
> > +               break;
> >         }
> >         evt_dump("prod_type", "%s", name);  } diff --git
> > a/app/test-eventdev/evt_test.h b/app/test-eventdev/evt_test.h index
> > f07d2c3336..50fa474ec2 100644
> > --- a/app/test-eventdev/evt_test.h
> > +++ b/app/test-eventdev/evt_test.h
> > @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
> >                 (struct evt_test *test, struct evt_options *opt);
> > typedef int (*evt_test_ethdev_setup_t)
> >                 (struct evt_test *test, struct evt_options *opt);
> > +typedef int (*evt_test_cryptodev_setup_t)
> > +               (struct evt_test *test, struct evt_options *opt);
> >  typedef int (*evt_test_eventdev_setup_t)
> >                 (struct evt_test *test, struct evt_options *opt);
> > typedef int (*evt_test_launch_lcores_t) @@ -39,6 +41,8 @@ typedef void
> > (*evt_test_eventdev_destroy_t)
> >                 (struct evt_test *test, struct evt_options *opt);
> > typedef void (*evt_test_ethdev_destroy_t)
> >                 (struct evt_test *test, struct evt_options *opt);
> > +typedef void (*evt_test_cryptodev_destroy_t)
> > +               (struct evt_test *test, struct evt_options *opt);
> >  typedef void (*evt_test_mempool_destroy_t)
> >                 (struct evt_test *test, struct evt_options *opt);
> > typedef void (*evt_test_destroy_t) @@ -52,10 +56,12 @@ struct
> > evt_test_ops {
> >         evt_test_mempool_setup_t mempool_setup;
> >         evt_test_ethdev_setup_t ethdev_setup;
> >         evt_test_eventdev_setup_t eventdev_setup;
> > +       evt_test_cryptodev_setup_t cryptodev_setup;
> >         evt_test_launch_lcores_t launch_lcores;
> >         evt_test_result_t test_result;
> >         evt_test_eventdev_destroy_t eventdev_destroy;
> >         evt_test_ethdev_destroy_t ethdev_destroy;
> > +       evt_test_cryptodev_destroy_t cryptodev_destroy;
> >         evt_test_mempool_destroy_t mempool_destroy;
> >         evt_test_destroy_t test_destroy;  }; diff --git
> > a/app/test-eventdev/test_perf_atq.c
> > b/app/test-eventdev/test_perf_atq.c
> > index 8fd51004ee..dbb1dc8c0c 100644
> > --- a/app/test-eventdev/test_perf_atq.c
> > +++ b/app/test-eventdev/test_perf_atq.c
> > @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int
> enable_fwd_latency)
> >                         continue;
> >                 }
> >
> > +               if (prod_crypto_type &&
> > +                   (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> > +                       struct rte_crypto_op *op = ev.event_ptr;
> > +
> > +                       if (op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +                               if (op->sym->m_dst == NULL)
> > +                                       ev.event_ptr = op->sym->m_src;
> > +                               else
> > +                                       ev.event_ptr = op->sym->m_dst;
> > +                               rte_crypto_op_free(op);
> > +                       } else {
> > +                               rte_crypto_op_free(op);
> > +                               continue;
> > +                       }
> > +               }
> > +
> >                 if (enable_fwd_latency && !prod_timer_type)
> >                 /* first stage in pipeline, mark ts to compute fwd latency */
> >                         atq_mark_fwd_latency(&ev); @@ -87,6 +103,25 @@
> > perf_atq_worker_burst(void *arg, const int enable_fwd_latency)
> >                 }
> >
> >                 for (i = 0; i < nb_rx; i++) {
> > +                       if (prod_crypto_type &&
> > +                           (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> > +                               struct rte_crypto_op *op =
> > + ev[i].event_ptr;
> > +
> > +                               if (op->status ==
> > +                                   RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +                                       if (op->sym->m_dst == NULL)
> > +                                               ev[i].event_ptr =
> > +                                                       op->sym->m_src;
> > +                                       else
> > +                                               ev[i].event_ptr =
> > +                                                       op->sym->m_dst;
> > +                                       rte_crypto_op_free(op);
> > +                               } else {
> > +                                       rte_crypto_op_free(op);
> > +                                       continue;
> > +                               }
> > +                       }
> > +
> >                         if (enable_fwd_latency && !prod_timer_type) {
> >                                 rte_prefetch0(ev[i+1].event_ptr);
> >                                 /* first stage in pipeline.
> > @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test,
> struct evt_options *opt)
> >                                 return ret;
> >                         }
> >                 }
> > +       } else if (opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> > +               uint8_t cdev_id, cdev_count;
> > +
> > +               cdev_count = rte_cryptodev_count();
> > +               for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +                       ret = rte_cryptodev_start(cdev_id);
> > +                       if (ret) {
> > +                               evt_err("Failed to start cryptodev %u",
> > +                                       cdev_id);
> > +                               return ret;
> > +                       }
> > +               }
> > +
> > +               rte_event_crypto_adapter_start(t->crypto_adptr.id);
> >         }
> >
> >         return 0;
> > @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
> >         .opt_dump           = perf_atq_opt_dump,
> >         .test_setup         = perf_test_setup,
> >         .ethdev_setup       = perf_ethdev_setup,
> > +       .cryptodev_setup    = perf_cryptodev_setup,
> >         .mempool_setup      = perf_mempool_setup,
> >         .eventdev_setup     = perf_atq_eventdev_setup,
> >         .launch_lcores      = perf_atq_launch_lcores,
> >         .eventdev_destroy   = perf_eventdev_destroy,
> >         .mempool_destroy    = perf_mempool_destroy,
> >         .ethdev_destroy     = perf_ethdev_destroy,
> > +       .cryptodev_destroy  = perf_cryptodev_destroy,
> >         .test_result        = perf_test_result,
> >         .test_destroy       = perf_test_destroy,
> >  };
> > diff --git a/app/test-eventdev/test_perf_common.c
> > b/app/test-eventdev/test_perf_common.c
> > index 9b73874151..91cb6748ee 100644
> > --- a/app/test-eventdev/test_perf_common.c
> > +++ b/app/test-eventdev/test_perf_common.c
> > @@ -6,6 +6,8 @@
> >
> >  #include "test_perf_common.h"
> >
> > +#define NB_CRYPTODEV_DESCRIPTORS 128
> > +
> >  int
> >  perf_test_result(struct evt_test *test, struct evt_options *opt)  {
> > @@ -272,6 +274,125 @@ perf_event_timer_producer_burst(void *arg)
> >         return 0;
> >  }
> >
> > +static inline void
> > +crypto_adapter_enq_op_new(struct prod_data *p) {
> > +       struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> > +       struct test_perf *t = p->t;
> > +       const uint32_t nb_flows = t->nb_flows;
> > +       const uint64_t nb_pkts = t->nb_pkts;
> > +       struct rte_mempool *pool = t->pool;
> > +       struct rte_crypto_sym_op *sym_op;
> > +       struct evt_options *opt = t->opt;
> > +       uint16_t qp_id = p->cdev_qp_id;
> > +       uint8_t cdev_id = p->cdev_id;
> > +       uint32_t flow_counter = 0;
> > +       struct rte_crypto_op *op;
> > +       struct rte_mbuf *m;
> > +       uint64_t count = 0;
> > +       uint16_t len;
> > +
> > +       if (opt->verbose_level > 1)
> > +               printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id %u\n",
> > +                      __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
> > +                      p->cdev_qp_id);
> > +
> > +       len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> > +
> > +       while (count < nb_pkts && t->done == false) {
> > +               m = rte_pktmbuf_alloc(pool);
> > +               if (m == NULL)
> > +                       continue;
> > +
> > +               rte_pktmbuf_append(m, len);
> > +               op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> > +                                        RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> > +               sym_op = op->sym;
> > +               sym_op->m_src = m;
> > +               sym_op->cipher.data.offset = 0;
> > +               sym_op->cipher.data.length = len;
> > +               rte_crypto_op_attach_sym_session(
> > +                       op, crypto_sess[flow_counter++ % nb_flows]);
> > +               while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op, 1) !=
> > +                      1) {
> > +                       if (t->done)
> > +                               break;
> > +                       rte_pause();
> > +               }
> > +               count++;
> > +       }
> > +}
> > +
> > +static inline void
> > +crypto_adapter_enq_op_fwd(struct prod_data *p) {
> > +       struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> > +       const uint8_t dev_id = p->dev_id;
> > +       const uint8_t port = p->port_id;
> > +       struct test_perf *t = p->t;
> > +       const uint32_t nb_flows = t->nb_flows;
> > +       const uint64_t nb_pkts = t->nb_pkts;
> > +       struct rte_mempool *pool = t->pool;
> > +       struct evt_options *opt = t->opt;
> > +       struct rte_crypto_sym_op *sym_op;
> > +       uint32_t flow_counter = 0;
> > +       struct rte_crypto_op *op;
> > +       struct rte_event ev;
> > +       struct rte_mbuf *m;
> > +       uint64_t count = 0;
> > +       uint16_t len;
> > +
> > +       if (opt->verbose_level > 1)
> > +               printf("%s(): lcore %d port %d queue %d cdev_id %u cdev_qp_id
> %u\n",
> > +                      __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
> > +                      p->cdev_qp_id);
> > +
> > +       ev.event = 0;
> > +       ev.op = RTE_EVENT_OP_NEW;
> > +       ev.queue_id = p->queue_id;
> > +       ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
> > +       ev.event_type = RTE_EVENT_TYPE_CPU;
> > +       len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> > +
> > +       while (count < nb_pkts && t->done == false) {
> > +               m = rte_pktmbuf_alloc(pool);
> > +               if (m == NULL)
> > +                       continue;
> > +
> > +               rte_pktmbuf_append(m, len);
> > +               op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> > +                                        RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> > +               sym_op = op->sym;
> > +               sym_op->m_src = m;
> > +               sym_op->cipher.data.offset = 0;
> > +               sym_op->cipher.data.length = len;
> > +               rte_crypto_op_attach_sym_session(
> > +                       op, crypto_sess[flow_counter++ % nb_flows]);
> > +               ev.event_ptr = op;
> > +               while (rte_event_crypto_adapter_enqueue(dev_id, port, &ev, 1)
> !=
> > +                      1) {
> > +                       if (t->done)
> > +                               break;
> > +                       rte_pause();
> > +               }
> > +               count++;
> > +       }
> > +}
> > +
> > +static inline int
> > +perf_event_crypto_producer(void *arg) {
> > +       struct prod_data *p = arg;
> > +       struct evt_options *opt = p->t->opt;
> > +
> > +       if (opt->crypto_adptr_mode ==
> RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
> > +               crypto_adapter_enq_op_new(p);
> > +       else
> > +               crypto_adapter_enq_op_fwd(p);
> > +
> > +       return 0;
> > +}
> > +
> >  static int
> >  perf_producer_wrapper(void *arg)
> >  {
> > @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
> >         else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR
> &&
> >                         t->opt->timdev_use_burst)
> >                 return perf_event_timer_producer_burst(arg);
> > +       else if (t->opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> > +               return perf_event_crypto_producer(arg);
> >         return 0;
> >  }
> >
> > @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
> evt_options *opt,
> >                         if (remaining <= 0) {
> >                                 t->result = EVT_TEST_SUCCESS;
> >                                 if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -                                       opt->prod_type ==
> > -                                       EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> > +                                   opt->prod_type ==
> > +                                           EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> > +                                   opt->prod_type ==
> > +
> > + EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >                                         t->done = true;
> >                                         break;
> >                                 }
> > @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
> > evt_options *opt,
> >
> >                 if (new_cycles - dead_lock_cycles > dead_lock_sample &&
> >                     (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -                    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
> > +                    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> > +                    opt->prod_type ==
> > + EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
> >                         remaining = t->outstand_pkts - processed_pkts(t);
> >                         if (dead_lock_remaining == remaining) {
> >                                 rte_event_dev_dump(opt->dev_id,
> > stdout); @@ -537,6 +663,96 @@ perf_event_timer_adapter_setup(struct
> test_perf *t)
> >         return 0;
> >  }
> >
> > +static int
> > +perf_event_crypto_adapter_setup(struct test_perf *t,
> > +                               struct rte_event_port_conf port_conf)
> > +{
> > +       struct evt_options *opt = t->opt;
> > +       uint8_t cdev_id, cdev_count;
> > +       int ret;
> > +
> > +       t->crypto_adptr.id = 0;
> > +       ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
> >dev_id,
> > +                                             &port_conf, 0);
> > +       if (ret)
> > +               return ret;
> > +
> > +       cdev_count = rte_cryptodev_count();
> > +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +               uint32_t cap;
> > +
> > +               ret = rte_event_crypto_adapter_caps_get(opt->dev_id, cdev_id,
> > +                                                       &cap);
> > +               if (ret) {
> > +                       evt_err("Failed to get crypto adapter capabilities");
> > +                       return ret;
> > +               }
> > +
> > +               if (((opt->crypto_adptr_mode ==
> > +                     RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
> > +                    !(cap &
> > +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
> > +                   ((opt->crypto_adptr_mode ==
> > +                     RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
> > +                    !(cap &
> > +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
> > +                       evt_err("crypto adapter %s mode unsupported\n",
> > +                               opt->crypto_adptr_mode ? "OP_FORWARD" :
> > +                                                        "OP_NEW");
> > +                       return -EINVAL;
> > +               }
> > +
> > +               if (!(cap &
> > +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
> > +                       evt_err("Storing crypto session not supported");
> > +                       return -EINVAL;
> > +               }
> > +
> > +               if (cap &
> > +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
> > +                       struct rte_event response_info;
> > +
> > +                       response_info.event = 0;
> > +                       ret = rte_event_crypto_adapter_queue_pair_add(
> > +                               t->crypto_adptr.id, cdev_id, -1,
> > +                               &response_info);
> > +               } else {
> > +                       ret = rte_event_crypto_adapter_queue_pair_add(
> > +                               t->crypto_adptr.id, cdev_id, -1, NULL);
> > +               }
> > +               if (ret)
> > +                       return ret;
> > +       }
> > +
> > +       return 0;
> > +}
> > +
> > +static struct rte_cryptodev_sym_session *
> > +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
> > +       struct rte_crypto_sym_xform cipher_xform;
> > +       struct rte_cryptodev_sym_session *sess;
> > +
> > +       cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
> > +       cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
> > +       cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
> > +       cipher_xform.next = NULL;
> > +
> > +       sess = rte_cryptodev_sym_session_create(t-
> >crypto_adptr.sess_pool);
> > +       if (sess == NULL) {
> > +               evt_err("Failed to create sym session");
> > +               return NULL;
> > +       }
> > +
> > +       if (rte_cryptodev_sym_session_init(p->cdev_id, sess, &cipher_xform,
> > +                                          t->crypto_adptr.sess_priv_pool)) {
> > +               evt_err("Failed to init session");
> > +               return NULL;
> > +       }
> > +
> > +       return sess;
> > +}
> > +
> >  int
> >  perf_event_dev_port_setup(struct evt_test *test, struct evt_options
> *opt,
> >                                 uint8_t stride, uint8_t nb_queues, @@
> > -598,6 +814,55 @@ perf_event_dev_port_setup(struct evt_test *test,
> struct evt_options *opt,
> >                 ret = perf_event_timer_adapter_setup(t);
> >                 if (ret)
> >                         return ret;
> > +       } else if (opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> > +               uint8_t cdev_id = 0;
> > +               uint16_t qp_id = 0;
> > +
> > +               prod = 0;
> > +               for (; port < perf_nb_event_ports(opt); port++) {
> > +                       struct rte_cryptodev_sym_session *crypto_sess;
> > +                       union rte_event_crypto_metadata m_data;
> > +                       struct prod_data *p = &t->prod[port];
> > +                       uint32_t flow_id;
> > +
> > +                       if (qp_id == rte_cryptodev_queue_pair_count(cdev_id)) {
> > +                               cdev_id++;
> > +                               qp_id = 0;
> > +                       }
> > +
> > +                       p->dev_id = opt->dev_id;
> > +                       p->port_id = port;
> > +                       p->queue_id = prod * stride;
> > +                       p->cdev_id = cdev_id;
> > +                       p->cdev_qp_id = qp_id;
> > +                       p->crypto_sess = rte_zmalloc_socket(
> > +                               NULL, sizeof(crypto_sess) * t->nb_flows,
> > +                               RTE_CACHE_LINE_SIZE, opt->socket_id);
> > +
> > +                       m_data.request_info.cdev_id = p->cdev_id;
> > +                       m_data.request_info.queue_pair_id = p->cdev_qp_id;
> > +                       m_data.response_info.op = RTE_EVENT_OP_NEW;
> > +                       m_data.response_info.sched_type =
> RTE_SCHED_TYPE_ATOMIC;
> > +                       m_data.response_info.event_type = RTE_EVENT_TYPE_CPU;
> > +                       m_data.response_info.queue_id = p->queue_id;
> > +                       for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
> > +                               crypto_sess = cryptodev_sym_sess_create(p, t);
> > +                               if (crypto_sess == NULL)
> > +                                       return -ENOMEM;
> > +
> > +                               m_data.response_info.flow_id = flow_id;
> > +                               rte_cryptodev_sym_session_set_user_data(
> > +                                       crypto_sess, &m_data, sizeof(m_data));
> > +                               p->crypto_sess[flow_id] = crypto_sess;
> > +                       }
> > +                       p->t = t;
> > +                       qp_id++;
> > +                       prod++;
> > +               }
> > +
> > +               ret = perf_event_crypto_adapter_setup(t, *port_conf);
> > +               if (ret)
> > +                       return ret;
> >         } else {
> >                 prod = 0;
> >                 for ( ; port < perf_nb_event_ports(opt); port++) { @@
> > -659,7 +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t
> nb_queues)
> >         }
> >
> >         if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -                       opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> > +           opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> > +           opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >                 /* Validate producer lcores */
> >                 if (evt_lcores_has_overlap(opt->plcores,
> >                                         rte_get_main_lcore())) { @@
> > -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct
> evt_options *opt)
> >                 },
> >         };
> >
> > -       if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -                       opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
> > +       if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
> >                 return 0;
> >
> >         if (!rte_eth_dev_count_avail()) { @@ -841,6 +1106,139 @@ void
> > perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt)
> >         }
> >  }
> >
> > +int
> > +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt)
> > +{
> > +       uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
> > +       struct test_perf *t = evt_test_priv(test);
> > +       unsigned int max_session_size;
> > +       uint32_t nb_sessions;
> > +       int ret;
> > +
> > +       if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> > +               return 0;
> > +
> > +       cdev_count = rte_cryptodev_count();
> > +       if (cdev_count == 0) {
> > +               evt_err("No crypto devices available\n");
> > +               return -ENODEV;
> > +       }
> > +
> > +       t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
> > +               "crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt-
> >pool_sz,
> > +               128, 0, rte_socket_id());
> > +       if (t->crypto_adptr.op_pool == NULL) {
> > +               evt_err("Failed to create crypto op pool");
> > +               return -ENOMEM;
> > +       }
> > +
> > +       nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
> > +       t->crypto_adptr.sess_pool =
> rte_cryptodev_sym_session_pool_create(
> > +               "ca_sess_pool", nb_sessions, 0, 0,
> > +               sizeof(union rte_event_crypto_metadata), SOCKET_ID_ANY);
> > +       if (t->crypto_adptr.sess_pool == NULL) {
> > +               evt_err("Failed to create sym session pool");
> > +               ret = -ENOMEM;
> > +               goto err;
> > +       }
> > +
> > +       max_session_size = 0;
> > +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +               unsigned int session_size;
> > +
> > +               session_size =
> > +                       rte_cryptodev_sym_get_private_session_size(cdev_id);
> > +               if (session_size > max_session_size)
> > +                       max_session_size = session_size;
> > +       }
> > +       max_session_size += sizeof(union rte_event_crypto_metadata);
> > +       t->crypto_adptr.sess_priv_pool = rte_mempool_create(
> > +               "ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0, NULL,
> > +               NULL, NULL, NULL, SOCKET_ID_ANY, 0);
> > +       if (t->crypto_adptr.sess_priv_pool == NULL) {
> > +               evt_err("failed to create sym session private pool");
> > +               ret = -ENOMEM;
> > +               goto err;
> > +       }
> > +
> > +       nb_plcores = evt_nr_active_lcores(opt->plcores);
> > +       nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) + 1 :
> > +                                            nb_plcores / cdev_count;
> > +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +               struct rte_cryptodev_qp_conf qp_conf;
> > +               struct rte_cryptodev_config conf;
> > +               struct rte_cryptodev_info info;
> > +               int qp_id;
> > +
> > +               rte_cryptodev_info_get(cdev_id, &info);
> > +               if (nb_qps > info.max_nb_queue_pairs) {
> > +                       evt_err("Not enough queue pairs per cryptodev (%u)",
> > +                               nb_qps);
> > +                       ret = -EINVAL;
> > +                       goto err;
> > +               }
> > +
> > +               conf.nb_queue_pairs = nb_qps;
> > +               conf.socket_id = SOCKET_ID_ANY;
> > +               conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
> > +
> > +               ret = rte_cryptodev_configure(cdev_id, &conf);
> > +               if (ret) {
> > +                       evt_err("Failed to configure cryptodev (%u)", cdev_id);
> > +                       goto err;
> > +               }
> > +
> > +               qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
> > +               qp_conf.mp_session = t->crypto_adptr.sess_pool;
> > +               qp_conf.mp_session_private =
> > + t->crypto_adptr.sess_priv_pool;
> > +
> > +               for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
> > +                       ret = rte_cryptodev_queue_pair_setup(
> > +                               cdev_id, qp_id, &qp_conf,
> > +                               rte_cryptodev_socket_id(cdev_id));
> > +                       if (ret) {
> > +                               evt_err("Failed to setup queue pairs on cryptodev %u\n",
> > +                                       cdev_id);
> > +                               goto err;
> > +                       }
> > +               }
> > +       }
> > +
> > +       return 0;
> > +err:
> > +       rte_mempool_free(t->crypto_adptr.op_pool);
> > +       rte_mempool_free(t->crypto_adptr.sess_pool);
> > +       rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> > +
> > +       return ret;
> > +}
> > +
> > +void
> > +perf_cryptodev_destroy(struct evt_test *test, struct evt_options
> > +*opt) {
> > +       uint8_t cdev_id, cdev_count = rte_cryptodev_count();
> > +       struct test_perf *t = evt_test_priv(test);
> > +
> > +       RTE_SET_USED(opt);
> > +
> > +       if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> > +               return;
> > +
> > +       rte_event_crypto_adapter_stop(t->crypto_adptr.id);
> > +
> > +       for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +               rte_cryptodev_stop(cdev_id);
> > +               rte_event_crypto_adapter_queue_pair_del(t->crypto_adptr.id,
> > +                                                       cdev_id, -1);
> > +       }
> > +
> > +       rte_event_crypto_adapter_free(t->crypto_adptr.id);
> > +
> > +       rte_mempool_free(t->crypto_adptr.op_pool);
> > +       rte_mempool_free(t->crypto_adptr.sess_pool);
> > +       rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> > +}
> > +
> >  int
> >  perf_mempool_setup(struct evt_test *test, struct evt_options *opt)  {
> > diff --git a/app/test-eventdev/test_perf_common.h
> > b/app/test-eventdev/test_perf_common.h
> > index 14dcf80429..d9ad3a0b0d 100644
> > --- a/app/test-eventdev/test_perf_common.h
> > +++ b/app/test-eventdev/test_perf_common.h
> > @@ -9,9 +9,11 @@
> >  #include <stdbool.h>
> >  #include <unistd.h>
> >
> > +#include <rte_cryptodev.h>
> >  #include <rte_cycles.h>
> >  #include <rte_ethdev.h>
> >  #include <rte_eventdev.h>
> > +#include <rte_event_crypto_adapter.h>
> >  #include <rte_event_eth_rx_adapter.h>  #include
> > <rte_event_timer_adapter.h>  #include <rte_lcore.h> @@ -37,9 +39,18
> @@
> > struct prod_data {
> >         uint8_t dev_id;
> >         uint8_t port_id;
> >         uint8_t queue_id;
> > +       uint8_t cdev_id;
> > +       uint16_t cdev_qp_id;
> > +       struct rte_cryptodev_sym_session **crypto_sess;
> >         struct test_perf *t;
> >  } __rte_cache_aligned;
> >
> > +struct crypto_adptr_data {
> > +       uint8_t id;
> > +       struct rte_mempool *op_pool;
> > +       struct rte_mempool *sess_pool;
> > +       struct rte_mempool *sess_priv_pool; };
> >
> >  struct test_perf {
> >         /* Don't change the offset of "done". Signal handler use this
> > memory @@ -58,6 +69,7 @@ struct test_perf {
> >         uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
> >         struct rte_event_timer_adapter *timer_adptr[
> >                 RTE_EVENT_TIMER_ADAPTER_NUM_MAX] __rte_cache_aligned;
> > +       struct crypto_adptr_data crypto_adptr;
> >  } __rte_cache_aligned;
> >
> >  struct perf_elt {
> > @@ -81,6 +93,8 @@ struct perf_elt {
> >         const uint8_t port = w->port_id;\
> >         const uint8_t prod_timer_type = \
> >                 opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
> > +       const uint8_t prod_crypto_type = \
> > +               opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
> >         uint8_t *const sched_type_list = &t->sched_type_list[0];\
> >         struct rte_mempool *const pool = t->pool;\
> >         const uint8_t nb_stages = t->opt->nb_stages;\ @@ -154,6 +168,7
> > @@ int perf_test_result(struct evt_test *test, struct evt_options
> > *opt);  int perf_opt_check(struct evt_options *opt, uint64_t
> > nb_queues);  int perf_test_setup(struct evt_test *test, struct
> > evt_options *opt);  int perf_ethdev_setup(struct evt_test *test,
> > struct evt_options *opt);
> > +int perf_cryptodev_setup(struct evt_test *test, struct evt_options
> > +*opt);
> >  int perf_mempool_setup(struct evt_test *test, struct evt_options
> > *opt);  int perf_event_dev_port_setup(struct evt_test *test, struct
> evt_options *opt,
> >                                 uint8_t stride, uint8_t nb_queues, @@
> > -164,6 +179,7 @@ int perf_launch_lcores(struct evt_test *test, struct
> > evt_options *opt,  void perf_opt_dump(struct evt_options *opt, uint8_t
> > nb_queues);  void perf_test_destroy(struct evt_test *test, struct
> > evt_options *opt);  void perf_eventdev_destroy(struct evt_test *test,
> > struct evt_options *opt);
> > +void perf_cryptodev_destroy(struct evt_test *test, struct evt_options
> > +*opt);
> >  void perf_ethdev_destroy(struct evt_test *test, struct evt_options
> > *opt);  void perf_mempool_destroy(struct evt_test *test, struct
> > evt_options *opt);
> >
> > diff --git a/app/test-eventdev/test_perf_queue.c
> > b/app/test-eventdev/test_perf_queue.c
> > index f4ea3a795f..5657c8b3cd 100644
> > --- a/app/test-eventdev/test_perf_queue.c
> > +++ b/app/test-eventdev/test_perf_queue.c
> > @@ -49,6 +49,23 @@ perf_queue_worker(void *arg, const int
> enable_fwd_latency)
> >                         rte_pause();
> >                         continue;
> >                 }
> > +
> > +               if (prod_crypto_type &&
> > +                   (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> > +                       struct rte_crypto_op *op = ev.event_ptr;
> > +
> > +                       if (op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +                               if (op->sym->m_dst == NULL)
> > +                                       ev.event_ptr = op->sym->m_src;
> > +                               else
> > +                                       ev.event_ptr = op->sym->m_dst;
> > +                               rte_crypto_op_free(op);
> > +                       } else {
> > +                               rte_crypto_op_free(op);
> > +                               continue;
> > +                       }
> > +               }
> > +
> >                 if (enable_fwd_latency && !prod_timer_type)
> >                 /* first q in pipeline, mark timestamp to compute fwd latency */
> >                         mark_fwd_latency(&ev, nb_stages); @@ -88,6
> > +105,25 @@ perf_queue_worker_burst(void *arg, const int
> enable_fwd_latency)
> >                 }
> >
> >                 for (i = 0; i < nb_rx; i++) {
> > +                       if (prod_crypto_type &&
> > +                           (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> > +                               struct rte_crypto_op *op =
> > + ev[i].event_ptr;
> > +
> > +                               if (op->status ==
> > +                                   RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +                                       if (op->sym->m_dst == NULL)
> > +                                               ev[i].event_ptr =
> > +                                                       op->sym->m_src;
> > +                                       else
> > +                                               ev[i].event_ptr =
> > +                                                       op->sym->m_dst;
> > +                                       rte_crypto_op_free(op);
> > +                               } else {
> > +                                       rte_crypto_op_free(op);
> > +                                       continue;
> > +                               }
> > +                       }
> > +
> >                         if (enable_fwd_latency && !prod_timer_type) {
> >                                 rte_prefetch0(ev[i+1].event_ptr);
> >                                 /* first queue in pipeline.
> > @@ -269,6 +305,20 @@ perf_queue_eventdev_setup(struct evt_test
> *test, struct evt_options *opt)
> >                                 return ret;
> >                         }
> >                 }
> > +       } else if (opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> > +               uint8_t cdev_id, cdev_count;
> > +
> > +               cdev_count = rte_cryptodev_count();
> > +               for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +                       ret = rte_cryptodev_start(cdev_id);
> > +                       if (ret) {
> > +                               evt_err("Failed to start cryptodev %u",
> > +                                       cdev_id);
> > +                               return ret;
> > +                       }
> > +               }
> > +
> > +               rte_event_crypto_adapter_start(t->crypto_adptr.id);
> >         }
> >
> >         return 0;
> > @@ -311,11 +361,13 @@ static const struct evt_test_ops perf_queue =  {
> >         .test_setup         = perf_test_setup,
> >         .mempool_setup      = perf_mempool_setup,
> >         .ethdev_setup       = perf_ethdev_setup,
> > +       .cryptodev_setup    = perf_cryptodev_setup,
> >         .eventdev_setup     = perf_queue_eventdev_setup,
> >         .launch_lcores      = perf_queue_launch_lcores,
> >         .eventdev_destroy   = perf_eventdev_destroy,
> >         .mempool_destroy    = perf_mempool_destroy,
> >         .ethdev_destroy     = perf_ethdev_destroy,
> > +       .cryptodev_destroy  = perf_cryptodev_destroy,
> >         .test_result        = perf_test_result,
> >         .test_destroy       = perf_test_destroy,
> >  };
> > diff --git a/doc/guides/tools/testeventdev.rst
> > b/doc/guides/tools/testeventdev.rst
> > index 48efb9ea6e..f7d813226d 100644
> > --- a/doc/guides/tools/testeventdev.rst
> > +++ b/doc/guides/tools/testeventdev.rst
> > @@ -120,6 +120,10 @@ The following are the application command-line
> options:
> >
> >         Use burst mode event timer adapter as producer.
> >
> > +* ``--prod_type_cryptodev``
> > +
> > +        Use crypto device as producer.
> > +
> >  * ``--timer_tick_nsec``
> >
> >         Used to dictate number of nano seconds between bucket
> > traversal of the @@ -148,6 +152,11 @@ The following are the application
> command-line options:
> >         timeout is out of the supported range of event device it will be
> >         adjusted to the highest/lowest supported dequeue timeout
> supported.
> >
> > +* ``--crypto_adptr_mode``
> > +
> > +        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
> > +        OP_FORWARD mode.
> > +
> >  * ``--mbuf_sz``
> >
> >         Set packet mbuf size. Can be used to configure Jumbo Frames.
> > Only @@ -420,6 +429,7 @@ Supported application command line options
> are following::
> >          --prod_type_ethdev
> >          --prod_type_timerdev_burst
> >          --prod_type_timerdev
> > +        --prod_type_cryptodev
> >          --prod_enq_burst_sz
> >          --timer_tick_nsec
> >          --max_tmo_nsec
> > @@ -427,6 +437,7 @@ Supported application command line options are
> following::
> >          --nb_timers
> >          --nb_timer_adptrs
> >          --deq_tmo_nsec
> > +        --crypto_adptr_mode
> >
> >  Example
> >  ^^^^^^^
> > @@ -529,12 +540,14 @@ Supported application command line options are
> following::
> >          --prod_type_ethdev
> >          --prod_type_timerdev_burst
> >          --prod_type_timerdev
> > +        --prod_type_cryptodev
> >          --timer_tick_nsec
> >          --max_tmo_nsec
> >          --expiry_nsec
> >          --nb_timers
> >          --nb_timer_adptrs
> >          --deq_tmo_nsec
> > +        --crypto_adptr_mode
> >
> >  Example
> >  ^^^^^^^
> > --
> > 2.25.1
> >
Gujjar, Abhinandan S Jan. 23, 2022, 6:44 p.m. UTC | #3
Hi Shijith,

Please find some comments inline.

> -----Original Message-----
> From: Shijith Thotton <sthotton@marvell.com>
> Sent: Tuesday, January 4, 2022 4:01 PM
> To: dev@dpdk.org; jerinj@marvell.com
> Cc: Shijith Thotton <sthotton@marvell.com>; anoobj@marvell.com;
> pbhagavatula@marvell.com; gakhil@marvell.com; Gujjar, Abhinandan S
> <abhinandan.gujjar@intel.com>
> Subject: [PATCH v3] app/eventdev: add crypto producer mode
> 
> In crypto producer mode, producer core enqueues cryptodev with software
> generated crypto ops and worker core dequeues crypto completion events
> from the eventdev. Event crypto metadata used for above processing is pre-
> populated in each crypto session.
> 
> Parameter --prod_type_cryptodev can be used to enable crypto producer
> mode. Parameter --crypto_adptr_mode can be set to select the crypto
> adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
> 
> This mode can be used to measure the performance of crypto adapter.
> 
> Example:
>   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
>   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
>   --stlist=a --wlcores 1 --plcores 2
> 
> Signed-off-by: Shijith Thotton <sthotton@marvell.com>
> ---
> v3:
> * Reduce dereference inside loop.
> 
> v2:
> * Fix RHEL compilation warning.
> 
>  app/test-eventdev/evt_common.h       |   3 +
>  app/test-eventdev/evt_main.c         |  13 +-
>  app/test-eventdev/evt_options.c      |  27 ++
>  app/test-eventdev/evt_options.h      |  12 +
>  app/test-eventdev/evt_test.h         |   6 +
>  app/test-eventdev/test_perf_atq.c    |  51 ++++
>  app/test-eventdev/test_perf_common.c | 410
> ++++++++++++++++++++++++++-  app/test-
> eventdev/test_perf_common.h |  16 ++  app/test-
> eventdev/test_perf_queue.c  |  52 ++++
>  doc/guides/tools/testeventdev.rst    |  13 +
>  10 files changed, 596 insertions(+), 7 deletions(-)
> 
> diff --git a/app/test-eventdev/evt_common.h b/app/test-
> eventdev/evt_common.h index f466434459..2f301a7e79 100644
> --- a/app/test-eventdev/evt_common.h
> +++ b/app/test-eventdev/evt_common.h
> @@ -7,6 +7,7 @@
> 
>  #include <rte_common.h>
>  #include <rte_debug.h>
> +#include <rte_event_crypto_adapter.h>
>  #include <rte_eventdev.h>
>  #include <rte_service.h>
> 
> @@ -39,6 +40,7 @@ enum evt_prod_type {
>  	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
>  	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter.
> */
>  	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer
> Adapter. */
> +	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto
> Adapter. */
>  	EVT_PROD_TYPE_MAX,
>  };
> 
> @@ -77,6 +79,7 @@ struct evt_options {
>  	uint64_t timer_tick_nsec;
>  	uint64_t optm_timer_tick_nsec;
>  	enum evt_prod_type prod_type;
> +	enum rte_event_crypto_adapter_mode crypto_adptr_mode;
>  };
> 
>  static inline bool
> diff --git a/app/test-eventdev/evt_main.c b/app/test-eventdev/evt_main.c
> index 194c980c7a..cef0fb1382 100644
> --- a/app/test-eventdev/evt_main.c
> +++ b/app/test-eventdev/evt_main.c
> @@ -161,12 +161,19 @@ main(int argc, char **argv)
>  			goto mempool_destroy;
>  		}
>  	}
New line required
> +	/* Test specific cryptodev setup */
> +	if (test->ops.cryptodev_setup) {
> +		if (test->ops.cryptodev_setup(test, &opt)) {
> +			evt_err("%s: cryptodev setup failed",
> opt.test_name);
> +			goto ethdev_destroy;
> +		}
> +	}
> 
>  	/* Test specific eventdev setup */
>  	if (test->ops.eventdev_setup) {
>  		if (test->ops.eventdev_setup(test, &opt)) {
>  			evt_err("%s: eventdev setup failed",
> opt.test_name);
> -			goto ethdev_destroy;
> +			goto cryptodev_destroy;
>  		}
>  	}
> 
> @@ -197,6 +204,10 @@ main(int argc, char **argv)
>  	if (test->ops.eventdev_destroy)
>  		test->ops.eventdev_destroy(test, &opt);
> 
> +cryptodev_destroy:
> +	if (test->ops.cryptodev_destroy)
> +		test->ops.cryptodev_destroy(test, &opt);
> +
>  ethdev_destroy:
>  	if (test->ops.ethdev_destroy)
>  		test->ops.ethdev_destroy(test, &opt); diff --git a/app/test-
> eventdev/evt_options.c b/app/test-eventdev/evt_options.c index
> 753a7dbd7d..5ad1491020 100644
> --- a/app/test-eventdev/evt_options.c
> +++ b/app/test-eventdev/evt_options.c
> @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct
> evt_options *opt,
>  	return 0;
>  }
> 
> +static int
> +evt_parse_crypto_prod_type(struct evt_options *opt,
> +			   const char *arg __rte_unused)
> +{
> +	opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
> +	return 0;
> +}
> +
> +static int
> +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg) {
> +	uint8_t mode;
> +	int ret;
> +
> +	ret = parser_read_uint8(&mode, arg);
> +	opt->crypto_adptr_mode = mode ?
> RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
> +
> 	RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
> +	return ret;
> +}
> +
>  static int
>  evt_parse_test_name(struct evt_options *opt, const char *arg)  { @@ -
> 335,6 +355,7 @@ usage(char *program)
>  		"\t--queue_priority   : enable queue priority\n"
>  		"\t--deq_tmo_nsec     : global dequeue timeout\n"
>  		"\t--prod_type_ethdev : use ethernet device as
> producer.\n"
> +		"\t--prod_type_cryptodev : use crypto device as
> producer.\n"
>  		"\t--prod_type_timerdev : use event timer device as
> producer.\n"
>  		"\t                     expity_nsec would be the timeout\n"
>  		"\t                     in ns.\n"
> @@ -345,6 +366,8 @@ usage(char *program)
>  		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
>  		"\t--max_tmo_nsec     : max timeout interval in ns.\n"
>  		"\t--expiry_nsec      : event timer expiry ns.\n"
> +		"\t--crypto_adptr_mode : 0 for OP_NEW mode (default)
> and\n"
> +		"\t                      1 for OP_FORWARD mode.\n"
>  		"\t--mbuf_sz          : packet mbuf size.\n"
>  		"\t--max_pkt_sz       : max packet size.\n"
>  		"\t--prod_enq_burst_sz : producer enqueue burst size.\n"
> @@ -415,8 +438,10 @@ static struct option lgopts[] = {
>  	{ EVT_QUEUE_PRIORITY,      0, 0, 0 },
>  	{ EVT_DEQ_TMO_NSEC,        1, 0, 0 },
>  	{ EVT_PROD_ETHDEV,         0, 0, 0 },
> +	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
>  	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
>  	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
> +	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
>  	{ EVT_NB_TIMERS,           1, 0, 0 },
>  	{ EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
>  	{ EVT_TIMER_TICK_NSEC,     1, 0, 0 },
> @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct evt_options
> *opt)
>  		{ EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
>  		{ EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
>  		{ EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
> +		{ EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
>  		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
>  		{ EVT_PROD_TIMERDEV_BURST,
> evt_parse_timer_prod_type_burst},
> +		{ EVT_CRYPTO_ADPTR_MODE,
> evt_parse_crypto_adptr_mode},
>  		{ EVT_NB_TIMERS, evt_parse_nb_timers},
>  		{ EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
>  		{ EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec}, diff --
> git a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
> index 413d7092f0..2231c58801 100644
> --- a/app/test-eventdev/evt_options.h
> +++ b/app/test-eventdev/evt_options.h
> @@ -9,6 +9,7 @@
>  #include <stdbool.h>
> 
>  #include <rte_common.h>
> +#include <rte_cryptodev.h>
>  #include <rte_ethdev.h>
>  #include <rte_eventdev.h>
>  #include <rte_lcore.h>
> @@ -33,8 +34,10 @@
>  #define EVT_QUEUE_PRIORITY       ("queue_priority")
>  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
>  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
> +#define EVT_PROD_CRYPTODEV	 ("prod_type_cryptodev")
>  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
>  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
> +#define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
>  #define EVT_NB_TIMERS            ("nb_timers")
>  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
>  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
> @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type
> prod_type)
>  		return "Ethdev Rx Adapter";
>  	case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
>  		return "Event timer adapter";
> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> +		return "Event crypto adapter";
>  	}
> 
>  	return "";
> @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options *opt)
>  			evt_dump("timer_tick_nsec", "%"PRIu64"",
>  					opt->timer_tick_nsec);
>  		break;
> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> +		snprintf(name, EVT_PROD_MAX_NAME_LEN,
> +			 "Event crypto adapter producers");
> +		evt_dump("crypto adapter mode", "%s",
> +			 opt->crypto_adptr_mode ? "OP_FORWARD" :
> "OP_NEW");
> +		evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
> +		break;
>  	}
>  	evt_dump("prod_type", "%s", name);
>  }
> diff --git a/app/test-eventdev/evt_test.h b/app/test-eventdev/evt_test.h
> index f07d2c3336..50fa474ec2 100644
> --- a/app/test-eventdev/evt_test.h
> +++ b/app/test-eventdev/evt_test.h
> @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
>  		(struct evt_test *test, struct evt_options *opt);  typedef int
> (*evt_test_ethdev_setup_t)
>  		(struct evt_test *test, struct evt_options *opt);
> +typedef int (*evt_test_cryptodev_setup_t)
> +		(struct evt_test *test, struct evt_options *opt);
>  typedef int (*evt_test_eventdev_setup_t)
>  		(struct evt_test *test, struct evt_options *opt);  typedef int
> (*evt_test_launch_lcores_t) @@ -39,6 +41,8 @@ typedef void
> (*evt_test_eventdev_destroy_t)
>  		(struct evt_test *test, struct evt_options *opt);  typedef void
> (*evt_test_ethdev_destroy_t)
>  		(struct evt_test *test, struct evt_options *opt);
> +typedef void (*evt_test_cryptodev_destroy_t)
> +		(struct evt_test *test, struct evt_options *opt);
>  typedef void (*evt_test_mempool_destroy_t)
>  		(struct evt_test *test, struct evt_options *opt);  typedef void
> (*evt_test_destroy_t) @@ -52,10 +56,12 @@ struct evt_test_ops {
>  	evt_test_mempool_setup_t mempool_setup;
>  	evt_test_ethdev_setup_t ethdev_setup;
>  	evt_test_eventdev_setup_t eventdev_setup;
> +	evt_test_cryptodev_setup_t cryptodev_setup;
>  	evt_test_launch_lcores_t launch_lcores;
>  	evt_test_result_t test_result;
>  	evt_test_eventdev_destroy_t eventdev_destroy;
>  	evt_test_ethdev_destroy_t ethdev_destroy;
> +	evt_test_cryptodev_destroy_t cryptodev_destroy;
>  	evt_test_mempool_destroy_t mempool_destroy;
>  	evt_test_destroy_t test_destroy;
>  };
> diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-
> eventdev/test_perf_atq.c
> index 8fd51004ee..dbb1dc8c0c 100644
> --- a/app/test-eventdev/test_perf_atq.c
> +++ b/app/test-eventdev/test_perf_atq.c
> @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int
> enable_fwd_latency)
>  			continue;
>  		}
> 
> +		if (prod_crypto_type &&
> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> +			struct rte_crypto_op *op = ev.event_ptr;
> +
> +			if (op->status ==
> RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +				if (op->sym->m_dst == NULL)
> +					ev.event_ptr = op->sym->m_src;
> +				else
> +					ev.event_ptr = op->sym->m_dst;
> +				rte_crypto_op_free(op);
> +			} else {
> +				rte_crypto_op_free(op);
> +				continue;
> +			}
> +		}
> +
>  		if (enable_fwd_latency && !prod_timer_type)
>  		/* first stage in pipeline, mark ts to compute fwd latency */
>  			atq_mark_fwd_latency(&ev);
> @@ -87,6 +103,25 @@ perf_atq_worker_burst(void *arg, const int
> enable_fwd_latency)
>  		}
> 
>  		for (i = 0; i < nb_rx; i++) {
> +			if (prod_crypto_type &&
> +			    (ev[i].event_type ==
> RTE_EVENT_TYPE_CRYPTODEV)) {
> +				struct rte_crypto_op *op = ev[i].event_ptr;
> +
> +				if (op->status ==
> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +					if (op->sym->m_dst == NULL)
> +						ev[i].event_ptr =
> +							op->sym->m_src;
> +					else
> +						ev[i].event_ptr =
> +							op->sym->m_dst;
> +					rte_crypto_op_free(op);
> +				} else {
> +					rte_crypto_op_free(op);
> +					continue;
> +				}
> +			}
> +
>  			if (enable_fwd_latency && !prod_timer_type) {
>  				rte_prefetch0(ev[i+1].event_ptr);
>  				/* first stage in pipeline.
> @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test,
> struct evt_options *opt)
>  				return ret;
>  			}
>  		}
> +	} else if (opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> +		uint8_t cdev_id, cdev_count;
> +
> +		cdev_count = rte_cryptodev_count();
> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +			ret = rte_cryptodev_start(cdev_id);
> +			if (ret) {
> +				evt_err("Failed to start cryptodev %u",
> +					cdev_id);
> +				return ret;
> +			}
> +		}
> +
> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
>  	}
> 
>  	return 0;
> @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
>  	.opt_dump           = perf_atq_opt_dump,
>  	.test_setup         = perf_test_setup,
>  	.ethdev_setup       = perf_ethdev_setup,
> +	.cryptodev_setup    = perf_cryptodev_setup,
>  	.mempool_setup      = perf_mempool_setup,
>  	.eventdev_setup     = perf_atq_eventdev_setup,
>  	.launch_lcores      = perf_atq_launch_lcores,
>  	.eventdev_destroy   = perf_eventdev_destroy,
>  	.mempool_destroy    = perf_mempool_destroy,
>  	.ethdev_destroy     = perf_ethdev_destroy,
> +	.cryptodev_destroy  = perf_cryptodev_destroy,
>  	.test_result        = perf_test_result,
>  	.test_destroy       = perf_test_destroy,
>  };
> diff --git a/app/test-eventdev/test_perf_common.c b/app/test-
> eventdev/test_perf_common.c
> index 9b73874151..91cb6748ee 100644
> --- a/app/test-eventdev/test_perf_common.c
> +++ b/app/test-eventdev/test_perf_common.c
> @@ -6,6 +6,8 @@
> 
>  #include "test_perf_common.h"
> 
> +#define NB_CRYPTODEV_DESCRIPTORS 128
> +
>  int
>  perf_test_result(struct evt_test *test, struct evt_options *opt)  { @@ -272,6
> +274,125 @@ perf_event_timer_producer_burst(void *arg)
>  	return 0;
>  }
> 
> +static inline void
> +crypto_adapter_enq_op_new(struct prod_data *p) {
> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> +	struct test_perf *t = p->t;
> +	const uint32_t nb_flows = t->nb_flows;
> +	const uint64_t nb_pkts = t->nb_pkts;
> +	struct rte_mempool *pool = t->pool;
> +	struct rte_crypto_sym_op *sym_op;
> +	struct evt_options *opt = t->opt;
> +	uint16_t qp_id = p->cdev_qp_id;
> +	uint8_t cdev_id = p->cdev_id;
> +	uint32_t flow_counter = 0;
> +	struct rte_crypto_op *op;
> +	struct rte_mbuf *m;
> +	uint64_t count = 0;
> +	uint16_t len;
> +
> +	if (opt->verbose_level > 1)
> +		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id
> %u\n",
> +		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
> +		       p->cdev_qp_id);
> +
> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> +
> +	while (count < nb_pkts && t->done == false) {
> +		m = rte_pktmbuf_alloc(pool);
> +		if (m == NULL)
> +			continue;
> +
> +		rte_pktmbuf_append(m, len);
> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> +
> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> +		sym_op = op->sym;
> +		sym_op->m_src = m;
> +		sym_op->cipher.data.offset = 0;
> +		sym_op->cipher.data.length = len;
> +		rte_crypto_op_attach_sym_session(
> +			op, crypto_sess[flow_counter++ % nb_flows]);
> +		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op,
> 1) !=
> +		       1) {
> +			if (t->done)
> +				break;
> +			rte_pause();
> +		}
> +		count++;
> +	}
> +}
> +
> +static inline void
> +crypto_adapter_enq_op_fwd(struct prod_data *p) {
> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> +	const uint8_t dev_id = p->dev_id;
> +	const uint8_t port = p->port_id;
> +	struct test_perf *t = p->t;
> +	const uint32_t nb_flows = t->nb_flows;
> +	const uint64_t nb_pkts = t->nb_pkts;
> +	struct rte_mempool *pool = t->pool;
> +	struct evt_options *opt = t->opt;
> +	struct rte_crypto_sym_op *sym_op;
> +	uint32_t flow_counter = 0;
> +	struct rte_crypto_op *op;
> +	struct rte_event ev;
> +	struct rte_mbuf *m;
> +	uint64_t count = 0;
> +	uint16_t len;
> +
> +	if (opt->verbose_level > 1)
> +		printf("%s(): lcore %d port %d queue %d cdev_id %u
> cdev_qp_id %u\n",
> +		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
> +		       p->cdev_qp_id);
> +
> +	ev.event = 0;
> +	ev.op = RTE_EVENT_OP_NEW;
> +	ev.queue_id = p->queue_id;
> +	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
> +	ev.event_type = RTE_EVENT_TYPE_CPU;
> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> +
> +	while (count < nb_pkts && t->done == false) {
> +		m = rte_pktmbuf_alloc(pool);
> +		if (m == NULL)
> +			continue;
> +
> +		rte_pktmbuf_append(m, len);
> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> +
> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> +		sym_op = op->sym;
> +		sym_op->m_src = m;
> +		sym_op->cipher.data.offset = 0;
> +		sym_op->cipher.data.length = len;
> +		rte_crypto_op_attach_sym_session(
> +			op, crypto_sess[flow_counter++ % nb_flows]);
> +		ev.event_ptr = op;
> +		while (rte_event_crypto_adapter_enqueue(dev_id, port,
> &ev, 1) !=
> +		       1) {
> +			if (t->done)
> +				break;
> +			rte_pause();
> +		}
> +		count++;
> +	}
> +}
> +
> +static inline int
> +perf_event_crypto_producer(void *arg)
> +{
> +	struct prod_data *p = arg;
> +	struct evt_options *opt = p->t->opt;
> +
> +	if (opt->crypto_adptr_mode ==
> RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
> +		crypto_adapter_enq_op_new(p);
> +	else
> +		crypto_adapter_enq_op_fwd(p);
> +
> +	return 0;
> +}
> +
>  static int
>  perf_producer_wrapper(void *arg)
>  {
> @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
>  	else if (t->opt->prod_type ==
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
>  			t->opt->timdev_use_burst)
>  		return perf_event_timer_producer_burst(arg);
> +	else if (t->opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> +		return perf_event_crypto_producer(arg);
>  	return 0;
>  }
> 
> @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
> evt_options *opt,
>  			if (remaining <= 0) {
>  				t->result = EVT_TEST_SUCCESS;
>  				if (opt->prod_type ==
> EVT_PROD_TYPE_SYNT ||
> -					opt->prod_type ==
> -
> 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> +				    opt->prod_type ==
> +
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> +				    opt->prod_type ==
> +
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>  					t->done = true;
>  					break;
>  				}
> @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
> evt_options *opt,
> 
>  		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
>  		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -		     opt->prod_type ==
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
> +		     opt->prod_type ==
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> +		     opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
>  			remaining = t->outstand_pkts - processed_pkts(t);
>  			if (dead_lock_remaining == remaining) {
>  				rte_event_dev_dump(opt->dev_id, stdout);
> @@ -537,6 +663,96 @@ perf_event_timer_adapter_setup(struct test_perf
> *t)
>  	return 0;
>  }
> 
> +static int
> +perf_event_crypto_adapter_setup(struct test_perf *t,
> +				struct rte_event_port_conf port_conf) {
> +	struct evt_options *opt = t->opt;
> +	uint8_t cdev_id, cdev_count;
> +	int ret;
> +
> +	t->crypto_adptr.id = 0;
> +	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
> >dev_id,
> +					      &port_conf, 0);
> +	if (ret)
> +		return ret;
> +
> +	cdev_count = rte_cryptodev_count();
> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +		uint32_t cap;
> +
> +		ret = rte_event_crypto_adapter_caps_get(opt->dev_id,
> cdev_id,
> +							&cap);
> +		if (ret) {
> +			evt_err("Failed to get crypto adapter capabilities");
> +			return ret;
> +		}
> +
> +		if (((opt->crypto_adptr_mode ==
> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
> +		     !(cap &
> +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
> +		    ((opt->crypto_adptr_mode ==
> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
> +		     !(cap &
> +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
> +			evt_err("crypto adapter %s mode unsupported\n",
> +				opt->crypto_adptr_mode ? "OP_FORWARD"
> :
> +							 "OP_NEW");
> +			return -EINVAL;
> +		}
> +
> +		if (!(cap &
> +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
> +			evt_err("Storing crypto session not supported");
> +			return -EINVAL;
> +		}
> +
> +		if (cap &
> +
> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
> +			struct rte_event response_info;
> +
> +			response_info.event = 0;
> +			ret = rte_event_crypto_adapter_queue_pair_add(
> +				t->crypto_adptr.id, cdev_id, -1,
> +				&response_info);
> +		} else {
> +			ret = rte_event_crypto_adapter_queue_pair_add(
> +				t->crypto_adptr.id, cdev_id, -1, NULL);
> +		}
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static struct rte_cryptodev_sym_session *
> +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
> +	struct rte_crypto_sym_xform cipher_xform;
> +	struct rte_cryptodev_sym_session *sess;
> +
> +	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
> +	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
> +	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
> +	cipher_xform.next = NULL;
> +
> +	sess = rte_cryptodev_sym_session_create(t-
> >crypto_adptr.sess_pool);
> +	if (sess == NULL) {
> +		evt_err("Failed to create sym session");
> +		return NULL;
> +	}
> +
> +	if (rte_cryptodev_sym_session_init(p->cdev_id, sess,
> &cipher_xform,
> +					   t->crypto_adptr.sess_priv_pool)) {
> +		evt_err("Failed to init session");
> +		return NULL;
> +	}
> +
> +	return sess;
> +}
> +
>  int
>  perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>  				uint8_t stride, uint8_t nb_queues,
> @@ -598,6 +814,55 @@ perf_event_dev_port_setup(struct evt_test *test,
> struct evt_options *opt,
>  		ret = perf_event_timer_adapter_setup(t);
>  		if (ret)
>  			return ret;
> +	} else if (opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> +		uint8_t cdev_id = 0;
> +		uint16_t qp_id = 0;
> +
> +		prod = 0;
> +		for (; port < perf_nb_event_ports(opt); port++) {
> +			struct rte_cryptodev_sym_session *crypto_sess;
> +			union rte_event_crypto_metadata m_data;
> +			struct prod_data *p = &t->prod[port];
> +			uint32_t flow_id;
> +
> +			if (qp_id ==
> rte_cryptodev_queue_pair_count(cdev_id)) {
> +				cdev_id++;
> +				qp_id = 0;
> +			}
> +
> +			p->dev_id = opt->dev_id;
> +			p->port_id = port;
> +			p->queue_id = prod * stride;
> +			p->cdev_id = cdev_id;
> +			p->cdev_qp_id = qp_id;
> +			p->crypto_sess = rte_zmalloc_socket(
> +				NULL, sizeof(crypto_sess) * t->nb_flows,
> +				RTE_CACHE_LINE_SIZE, opt->socket_id);
> +
> +			m_data.request_info.cdev_id = p->cdev_id;
> +			m_data.request_info.queue_pair_id = p-
> >cdev_qp_id;
> +			m_data.response_info.op = RTE_EVENT_OP_NEW;
> +			m_data.response_info.sched_type =
> RTE_SCHED_TYPE_ATOMIC;
> +			m_data.response_info.event_type =
> RTE_EVENT_TYPE_CPU;
> +			m_data.response_info.queue_id = p->queue_id;
> +			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
> +				crypto_sess =
> cryptodev_sym_sess_create(p, t);
> +				if (crypto_sess == NULL)
> +					return -ENOMEM;
> +
> +				m_data.response_info.flow_id = flow_id;
> +				rte_cryptodev_sym_session_set_user_data(
> +					crypto_sess, &m_data,
> sizeof(m_data));
> +				p->crypto_sess[flow_id] = crypto_sess;
> +			}
> +			p->t = t;
> +			qp_id++;
> +			prod++;
> +		}
> +
> +		ret = perf_event_crypto_adapter_setup(t, *port_conf);
> +		if (ret)
> +			return ret;
>  	} else {
>  		prod = 0;
>  		for ( ; port < perf_nb_event_ports(opt); port++) { @@ -659,7
> +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
>  	}
> 
>  	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -			opt->prod_type ==
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>  		/* Validate producer lcores */
>  		if (evt_lcores_has_overlap(opt->plcores,
>  					rte_get_main_lcore())) {
> @@ -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct
> evt_options *opt)
>  		},
>  	};
> 
> -	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> -			opt->prod_type ==
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
> +	if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
>  		return 0;
> 
>  	if (!rte_eth_dev_count_avail()) {
> @@ -841,6 +1106,139 @@ void perf_ethdev_destroy(struct evt_test *test,
> struct evt_options *opt)
>  	}
>  }
> 
> +int
> +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt) {
> +	uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
> +	struct test_perf *t = evt_test_priv(test);
> +	unsigned int max_session_size;
> +	uint32_t nb_sessions;
> +	int ret;
> +
> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> +		return 0;
How do you differentiate between this failed case as you are returning 0 in case of success?

> +
> +	cdev_count = rte_cryptodev_count();
> +	if (cdev_count == 0) {
> +		evt_err("No crypto devices available\n");
> +		return -ENODEV;
> +	}
> +
> +	t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
> +		"crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt-
> >pool_sz,
> +		128, 0, rte_socket_id());
> +	if (t->crypto_adptr.op_pool == NULL) {
> +		evt_err("Failed to create crypto op pool");
> +		return -ENOMEM;
> +	}
> +
> +	nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
> +	t->crypto_adptr.sess_pool =
> rte_cryptodev_sym_session_pool_create(
> +		"ca_sess_pool", nb_sessions, 0, 0,
> +		sizeof(union rte_event_crypto_metadata),
> SOCKET_ID_ANY);
> +	if (t->crypto_adptr.sess_pool == NULL) {
> +		evt_err("Failed to create sym session pool");
> +		ret = -ENOMEM;
> +		goto err;
> +	}
> +
> +	max_session_size = 0;
> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +		unsigned int session_size;
> +
> +		session_size =
> +
> 	rte_cryptodev_sym_get_private_session_size(cdev_id);
> +		if (session_size > max_session_size)
> +			max_session_size = session_size;
> +	}
New line required
> +	max_session_size += sizeof(union rte_event_crypto_metadata);
> +	t->crypto_adptr.sess_priv_pool = rte_mempool_create(
> +		"ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0,
> NULL,
> +		NULL, NULL, NULL, SOCKET_ID_ANY, 0);
> +	if (t->crypto_adptr.sess_priv_pool == NULL) {
> +		evt_err("failed to create sym session private pool");
> +		ret = -ENOMEM;
> +		goto err;
> +	}
> +
> +	nb_plcores = evt_nr_active_lcores(opt->plcores);
> +	nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) +
> 1 :
> +					     nb_plcores / cdev_count;
Let's take an example:
Cdev1 -> 8 qps
Cdev2 -> 2 qps
Cdev_count = 2
nb_plcores = 7
As per above statement, nb_qps = ( 7 % 2 ) 7/2 + 1 = 4 qps
So, this fails to setup qps for cdev2 as it supports only 2 qps and test exits! Am I missing anything?

> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +		struct rte_cryptodev_qp_conf qp_conf;
> +		struct rte_cryptodev_config conf;
> +		struct rte_cryptodev_info info;
> +		int qp_id;
> +
> +		rte_cryptodev_info_get(cdev_id, &info);
> +		if (nb_qps > info.max_nb_queue_pairs) {
> +			evt_err("Not enough queue pairs per cryptodev
> (%u)",
> +				nb_qps);
> +			ret = -EINVAL;
> +			goto err;
> +		}
> +
> +		conf.nb_queue_pairs = nb_qps;
> +		conf.socket_id = SOCKET_ID_ANY;
> +		conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
> +
> +		ret = rte_cryptodev_configure(cdev_id, &conf);
> +		if (ret) {
> +			evt_err("Failed to configure cryptodev (%u)",
> cdev_id);
> +			goto err;
> +		}
> +
> +		qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
> +		qp_conf.mp_session = t->crypto_adptr.sess_pool;
> +		qp_conf.mp_session_private = t-
> >crypto_adptr.sess_priv_pool;
> +
> +		for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
> +			ret = rte_cryptodev_queue_pair_setup(
> +				cdev_id, qp_id, &qp_conf,
> +				rte_cryptodev_socket_id(cdev_id));
> +			if (ret) {
> +				evt_err("Failed to setup queue pairs on
> cryptodev %u\n",
> +					cdev_id);
> +				goto err;
> +			}
> +		}
> +	}
> +
> +	return 0;
> +err:
> +	rte_mempool_free(t->crypto_adptr.op_pool);
> +	rte_mempool_free(t->crypto_adptr.sess_pool);
> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> +
> +	return ret;
> +}
> +
> +void
> +perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt)
> +{
> +	uint8_t cdev_id, cdev_count = rte_cryptodev_count();
> +	struct test_perf *t = evt_test_priv(test);
> +
> +	RTE_SET_USED(opt);
> +
> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> +		return;
> +
> +	rte_event_crypto_adapter_stop(t->crypto_adptr.id);
> +
> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +		rte_cryptodev_stop(cdev_id);
> +		rte_event_crypto_adapter_queue_pair_del(t-
> >crypto_adptr.id,
> +							cdev_id, -1);
Any reason for passing -1? This can not ensure to cleanup all the preconfigured qps as per API.
> +	}
> +
> +	rte_event_crypto_adapter_free(t->crypto_adptr.id);
> +
> +	rte_mempool_free(t->crypto_adptr.op_pool);
> +	rte_mempool_free(t->crypto_adptr.sess_pool);
> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> +}
> +
>  int
>  perf_mempool_setup(struct evt_test *test, struct evt_options *opt)  { diff -
> -git a/app/test-eventdev/test_perf_common.h b/app/test-
> eventdev/test_perf_common.h
> index 14dcf80429..d9ad3a0b0d 100644
> --- a/app/test-eventdev/test_perf_common.h
> +++ b/app/test-eventdev/test_perf_common.h
> @@ -9,9 +9,11 @@
>  #include <stdbool.h>
>  #include <unistd.h>
> 
> +#include <rte_cryptodev.h>
>  #include <rte_cycles.h>
>  #include <rte_ethdev.h>
>  #include <rte_eventdev.h>
> +#include <rte_event_crypto_adapter.h>
>  #include <rte_event_eth_rx_adapter.h>
>  #include <rte_event_timer_adapter.h>
>  #include <rte_lcore.h>
> @@ -37,9 +39,18 @@ struct prod_data {
>  	uint8_t dev_id;
>  	uint8_t port_id;
>  	uint8_t queue_id;
> +	uint8_t cdev_id;
> +	uint16_t cdev_qp_id;
> +	struct rte_cryptodev_sym_session **crypto_sess;
>  	struct test_perf *t;
>  } __rte_cache_aligned;
> 
> +struct crypto_adptr_data {
> +	uint8_t id;
> +	struct rte_mempool *op_pool;
> +	struct rte_mempool *sess_pool;
> +	struct rte_mempool *sess_priv_pool;
> +};
> 
>  struct test_perf {
>  	/* Don't change the offset of "done". Signal handler use this memory
> @@ -58,6 +69,7 @@ struct test_perf {
>  	uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
>  	struct rte_event_timer_adapter *timer_adptr[
>  		RTE_EVENT_TIMER_ADAPTER_NUM_MAX]
> __rte_cache_aligned;
> +	struct crypto_adptr_data crypto_adptr;
>  } __rte_cache_aligned;
> 
>  struct perf_elt {
> @@ -81,6 +93,8 @@ struct perf_elt {
>  	const uint8_t port = w->port_id;\
>  	const uint8_t prod_timer_type = \
>  		opt->prod_type ==
> EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
> +	const uint8_t prod_crypto_type = \
> +		opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
>  	uint8_t *const sched_type_list = &t->sched_type_list[0];\
>  	struct rte_mempool *const pool = t->pool;\
>  	const uint8_t nb_stages = t->opt->nb_stages;\ @@ -154,6 +168,7
> @@ int perf_test_result(struct evt_test *test, struct evt_options *opt);  int
> perf_opt_check(struct evt_options *opt, uint64_t nb_queues);  int
> perf_test_setup(struct evt_test *test, struct evt_options *opt);  int
> perf_ethdev_setup(struct evt_test *test, struct evt_options *opt);
> +int perf_cryptodev_setup(struct evt_test *test, struct evt_options
> +*opt);
>  int perf_mempool_setup(struct evt_test *test, struct evt_options *opt);  int
> perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>  				uint8_t stride, uint8_t nb_queues,
> @@ -164,6 +179,7 @@ int perf_launch_lcores(struct evt_test *test, struct
> evt_options *opt,  void perf_opt_dump(struct evt_options *opt, uint8_t
> nb_queues);  void perf_test_destroy(struct evt_test *test, struct
> evt_options *opt);  void perf_eventdev_destroy(struct evt_test *test, struct
> evt_options *opt);
> +void perf_cryptodev_destroy(struct evt_test *test, struct evt_options
> +*opt);
>  void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt);
> void perf_mempool_destroy(struct evt_test *test, struct evt_options *opt);
> 
> diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-
> eventdev/test_perf_queue.c
> index f4ea3a795f..5657c8b3cd 100644
> --- a/app/test-eventdev/test_perf_queue.c
> +++ b/app/test-eventdev/test_perf_queue.c
> @@ -49,6 +49,23 @@ perf_queue_worker(void *arg, const int
> enable_fwd_latency)
>  			rte_pause();
>  			continue;
>  		}
> +
> +		if (prod_crypto_type &&
> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> +			struct rte_crypto_op *op = ev.event_ptr;
> +
> +			if (op->status ==
> RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +				if (op->sym->m_dst == NULL)
> +					ev.event_ptr = op->sym->m_src;
> +				else
> +					ev.event_ptr = op->sym->m_dst;
> +				rte_crypto_op_free(op);
> +			} else {
> +				rte_crypto_op_free(op);
> +				continue;
In case of failure, ops are freed and "ev.event_ptr" won't be set to mbuf.
What would be the expected test result?
> +			}
> +		}
> +
>  		if (enable_fwd_latency && !prod_timer_type)
>  		/* first q in pipeline, mark timestamp to compute fwd latency
> */
>  			mark_fwd_latency(&ev, nb_stages);
> @@ -88,6 +105,25 @@ perf_queue_worker_burst(void *arg, const int
> enable_fwd_latency)
>  		}
> 
>  		for (i = 0; i < nb_rx; i++) {
> +			if (prod_crypto_type &&
> +			    (ev[i].event_type ==
> RTE_EVENT_TYPE_CRYPTODEV)) {
> +				struct rte_crypto_op *op = ev[i].event_ptr;
> +
> +				if (op->status ==
> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
> +					if (op->sym->m_dst == NULL)
> +						ev[i].event_ptr =
> +							op->sym->m_src;
> +					else
> +						ev[i].event_ptr =
> +							op->sym->m_dst;
> +					rte_crypto_op_free(op);
> +				} else {
> +					rte_crypto_op_free(op);
> +					continue;
> +				}
> +			}
> +
>  			if (enable_fwd_latency && !prod_timer_type) {
>  				rte_prefetch0(ev[i+1].event_ptr);
>  				/* first queue in pipeline.
> @@ -269,6 +305,20 @@ perf_queue_eventdev_setup(struct evt_test *test,
> struct evt_options *opt)
>  				return ret;
>  			}
>  		}
> +	} else if (opt->prod_type ==
> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> +		uint8_t cdev_id, cdev_count;
> +
> +		cdev_count = rte_cryptodev_count();
> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> +			ret = rte_cryptodev_start(cdev_id);
> +			if (ret) {
> +				evt_err("Failed to start cryptodev %u",
> +					cdev_id);
> +				return ret;
> +			}
> +		}
> +
> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
>  	}
> 
>  	return 0;
> @@ -311,11 +361,13 @@ static const struct evt_test_ops perf_queue =  {
>  	.test_setup         = perf_test_setup,
>  	.mempool_setup      = perf_mempool_setup,
>  	.ethdev_setup	    = perf_ethdev_setup,
> +	.cryptodev_setup    = perf_cryptodev_setup,
>  	.eventdev_setup     = perf_queue_eventdev_setup,
>  	.launch_lcores      = perf_queue_launch_lcores,
>  	.eventdev_destroy   = perf_eventdev_destroy,
>  	.mempool_destroy    = perf_mempool_destroy,
>  	.ethdev_destroy	    = perf_ethdev_destroy,
> +	.cryptodev_destroy  = perf_cryptodev_destroy,
>  	.test_result        = perf_test_result,
>  	.test_destroy       = perf_test_destroy,
>  };
> diff --git a/doc/guides/tools/testeventdev.rst
> b/doc/guides/tools/testeventdev.rst
> index 48efb9ea6e..f7d813226d 100644
> --- a/doc/guides/tools/testeventdev.rst
> +++ b/doc/guides/tools/testeventdev.rst
> @@ -120,6 +120,10 @@ The following are the application command-line
> options:
> 
>         Use burst mode event timer adapter as producer.
> 
> +* ``--prod_type_cryptodev``
> +
> +        Use crypto device as producer.
> +
>  * ``--timer_tick_nsec``
> 
>         Used to dictate number of nano seconds between bucket traversal of
> the @@ -148,6 +152,11 @@ The following are the application command-line
> options:
>         timeout is out of the supported range of event device it will be
>         adjusted to the highest/lowest supported dequeue timeout supported.
> 
> +* ``--crypto_adptr_mode``
> +
> +        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
> +        OP_FORWARD mode.
> +
>  * ``--mbuf_sz``
> 
>         Set packet mbuf size. Can be used to configure Jumbo Frames. Only @@
> -420,6 +429,7 @@ Supported application command line options are
> following::
>          --prod_type_ethdev
>          --prod_type_timerdev_burst
>          --prod_type_timerdev
> +        --prod_type_cryptodev
>          --prod_enq_burst_sz
>          --timer_tick_nsec
>          --max_tmo_nsec
> @@ -427,6 +437,7 @@ Supported application command line options are
> following::
>          --nb_timers
>          --nb_timer_adptrs
>          --deq_tmo_nsec
> +        --crypto_adptr_mode
> 
>  Example
>  ^^^^^^^
> @@ -529,12 +540,14 @@ Supported application command line options are
> following::
>          --prod_type_ethdev
>          --prod_type_timerdev_burst
>          --prod_type_timerdev
> +        --prod_type_cryptodev
>          --timer_tick_nsec
>          --max_tmo_nsec
>          --expiry_nsec
>          --nb_timers
>          --nb_timer_adptrs
>          --deq_tmo_nsec
> +        --crypto_adptr_mode
> 
>  Example
>  ^^^^^^^
> --
> 2.25.1
Shijith Thotton Jan. 24, 2022, 6:09 a.m. UTC | #4
Hi Abhinandan,
>>
>> In crypto producer mode, producer core enqueues cryptodev with software
>> generated crypto ops and worker core dequeues crypto completion events
>> from the eventdev. Event crypto metadata used for above processing is pre-
>> populated in each crypto session.
>>
>> Parameter --prod_type_cryptodev can be used to enable crypto producer
>> mode. Parameter --crypto_adptr_mode can be set to select the crypto
>> adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
>>
>> This mode can be used to measure the performance of crypto adapter.
>>
>> Example:
>>   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
>>   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
>>   --stlist=a --wlcores 1 --plcores 2
>>
>> Signed-off-by: Shijith Thotton <sthotton@marvell.com>
>> ---
>> v3:
>> * Reduce dereference inside loop.
>>
>> v2:
>> * Fix RHEL compilation warning.
>>
>>  app/test-eventdev/evt_common.h       |   3 +
>>  app/test-eventdev/evt_main.c         |  13 +-
>>  app/test-eventdev/evt_options.c      |  27 ++
>>  app/test-eventdev/evt_options.h      |  12 +
>>  app/test-eventdev/evt_test.h         |   6 +
>>  app/test-eventdev/test_perf_atq.c    |  51 ++++
>>  app/test-eventdev/test_perf_common.c | 410
>> ++++++++++++++++++++++++++-  app/test-
>> eventdev/test_perf_common.h |  16 ++  app/test-
>> eventdev/test_perf_queue.c  |  52 ++++
>>  doc/guides/tools/testeventdev.rst    |  13 +
>>  10 files changed, 596 insertions(+), 7 deletions(-)
>>
>> diff --git a/app/test-eventdev/evt_common.h b/app/test-
>> eventdev/evt_common.h index f466434459..2f301a7e79 100644
>> --- a/app/test-eventdev/evt_common.h
>> +++ b/app/test-eventdev/evt_common.h
>> @@ -7,6 +7,7 @@
>>
>>  #include <rte_common.h>
>>  #include <rte_debug.h>
>> +#include <rte_event_crypto_adapter.h>
>>  #include <rte_eventdev.h>
>>  #include <rte_service.h>
>>
>> @@ -39,6 +40,7 @@ enum evt_prod_type {
>>  	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
>>  	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter.
>> */
>>  	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer
>> Adapter. */
>> +	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto
>> Adapter. */
>>  	EVT_PROD_TYPE_MAX,
>>  };
>>
>> @@ -77,6 +79,7 @@ struct evt_options {
>>  	uint64_t timer_tick_nsec;
>>  	uint64_t optm_timer_tick_nsec;
>>  	enum evt_prod_type prod_type;
>> +	enum rte_event_crypto_adapter_mode crypto_adptr_mode;
>>  };
>>
>>  static inline bool
>> diff --git a/app/test-eventdev/evt_main.c b/app/test-eventdev/evt_main.c
>> index 194c980c7a..cef0fb1382 100644
>> --- a/app/test-eventdev/evt_main.c
>> +++ b/app/test-eventdev/evt_main.c
>> @@ -161,12 +161,19 @@ main(int argc, char **argv)
>>  			goto mempool_destroy;
>>  		}
>>  	}
>New line required
>> +	/* Test specific cryptodev setup */
>> +	if (test->ops.cryptodev_setup) {
>> +		if (test->ops.cryptodev_setup(test, &opt)) {
>> +			evt_err("%s: cryptodev setup failed",
>> opt.test_name);
>> +			goto ethdev_destroy;
>> +		}
>> +	}
>>
>>  	/* Test specific eventdev setup */
>>  	if (test->ops.eventdev_setup) {
>>  		if (test->ops.eventdev_setup(test, &opt)) {
>>  			evt_err("%s: eventdev setup failed",
>> opt.test_name);
>> -			goto ethdev_destroy;
>> +			goto cryptodev_destroy;
>>  		}
>>  	}
>>
>> @@ -197,6 +204,10 @@ main(int argc, char **argv)
>>  	if (test->ops.eventdev_destroy)
>>  		test->ops.eventdev_destroy(test, &opt);
>>
>> +cryptodev_destroy:
>> +	if (test->ops.cryptodev_destroy)
>> +		test->ops.cryptodev_destroy(test, &opt);
>> +
>>  ethdev_destroy:
>>  	if (test->ops.ethdev_destroy)
>>  		test->ops.ethdev_destroy(test, &opt); diff --git a/app/test-
>> eventdev/evt_options.c b/app/test-eventdev/evt_options.c index
>> 753a7dbd7d..5ad1491020 100644
>> --- a/app/test-eventdev/evt_options.c
>> +++ b/app/test-eventdev/evt_options.c
>> @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct
>> evt_options *opt,
>>  	return 0;
>>  }
>>
>> +static int
>> +evt_parse_crypto_prod_type(struct evt_options *opt,
>> +			   const char *arg __rte_unused)
>> +{
>> +	opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
>> +	return 0;
>> +}
>> +
>> +static int
>> +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg) {
>> +	uint8_t mode;
>> +	int ret;
>> +
>> +	ret = parser_read_uint8(&mode, arg);
>> +	opt->crypto_adptr_mode = mode ?
>> RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
>> +
>> 	RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
>> +	return ret;
>> +}
>> +
>>  static int
>>  evt_parse_test_name(struct evt_options *opt, const char *arg)  { @@ -
>> 335,6 +355,7 @@ usage(char *program)
>>  		"\t--queue_priority   : enable queue priority\n"
>>  		"\t--deq_tmo_nsec     : global dequeue timeout\n"
>>  		"\t--prod_type_ethdev : use ethernet device as
>> producer.\n"
>> +		"\t--prod_type_cryptodev : use crypto device as
>> producer.\n"
>>  		"\t--prod_type_timerdev : use event timer device as
>> producer.\n"
>>  		"\t                     expity_nsec would be the timeout\n"
>>  		"\t                     in ns.\n"
>> @@ -345,6 +366,8 @@ usage(char *program)
>>  		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
>>  		"\t--max_tmo_nsec     : max timeout interval in ns.\n"
>>  		"\t--expiry_nsec      : event timer expiry ns.\n"
>> +		"\t--crypto_adptr_mode : 0 for OP_NEW mode (default)
>> and\n"
>> +		"\t                      1 for OP_FORWARD mode.\n"
>>  		"\t--mbuf_sz          : packet mbuf size.\n"
>>  		"\t--max_pkt_sz       : max packet size.\n"
>>  		"\t--prod_enq_burst_sz : producer enqueue burst size.\n"
>> @@ -415,8 +438,10 @@ static struct option lgopts[] = {
>>  	{ EVT_QUEUE_PRIORITY,      0, 0, 0 },
>>  	{ EVT_DEQ_TMO_NSEC,        1, 0, 0 },
>>  	{ EVT_PROD_ETHDEV,         0, 0, 0 },
>> +	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
>>  	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
>>  	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
>> +	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
>>  	{ EVT_NB_TIMERS,           1, 0, 0 },
>>  	{ EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
>>  	{ EVT_TIMER_TICK_NSEC,     1, 0, 0 },
>> @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct evt_options
>> *opt)
>>  		{ EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
>>  		{ EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
>>  		{ EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
>> +		{ EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
>>  		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
>>  		{ EVT_PROD_TIMERDEV_BURST,
>> evt_parse_timer_prod_type_burst},
>> +		{ EVT_CRYPTO_ADPTR_MODE,
>> evt_parse_crypto_adptr_mode},
>>  		{ EVT_NB_TIMERS, evt_parse_nb_timers},
>>  		{ EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
>>  		{ EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec}, diff --
>> git a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
>> index 413d7092f0..2231c58801 100644
>> --- a/app/test-eventdev/evt_options.h
>> +++ b/app/test-eventdev/evt_options.h
>> @@ -9,6 +9,7 @@
>>  #include <stdbool.h>
>>
>>  #include <rte_common.h>
>> +#include <rte_cryptodev.h>
>>  #include <rte_ethdev.h>
>>  #include <rte_eventdev.h>
>>  #include <rte_lcore.h>
>> @@ -33,8 +34,10 @@
>>  #define EVT_QUEUE_PRIORITY       ("queue_priority")
>>  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
>>  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
>> +#define EVT_PROD_CRYPTODEV	 ("prod_type_cryptodev")
>>  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
>>  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
>> +#define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
>>  #define EVT_NB_TIMERS            ("nb_timers")
>>  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
>>  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
>> @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type
>> prod_type)
>>  		return "Ethdev Rx Adapter";
>>  	case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
>>  		return "Event timer adapter";
>> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
>> +		return "Event crypto adapter";
>>  	}
>>
>>  	return "";
>> @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options *opt)
>>  			evt_dump("timer_tick_nsec", "%"PRIu64"",
>>  					opt->timer_tick_nsec);
>>  		break;
>> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
>> +		snprintf(name, EVT_PROD_MAX_NAME_LEN,
>> +			 "Event crypto adapter producers");
>> +		evt_dump("crypto adapter mode", "%s",
>> +			 opt->crypto_adptr_mode ? "OP_FORWARD" :
>> "OP_NEW");
>> +		evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
>> +		break;
>>  	}
>>  	evt_dump("prod_type", "%s", name);
>>  }
>> diff --git a/app/test-eventdev/evt_test.h b/app/test-eventdev/evt_test.h
>> index f07d2c3336..50fa474ec2 100644
>> --- a/app/test-eventdev/evt_test.h
>> +++ b/app/test-eventdev/evt_test.h
>> @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef int
>> (*evt_test_ethdev_setup_t)
>>  		(struct evt_test *test, struct evt_options *opt);
>> +typedef int (*evt_test_cryptodev_setup_t)
>> +		(struct evt_test *test, struct evt_options *opt);
>>  typedef int (*evt_test_eventdev_setup_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef int
>> (*evt_test_launch_lcores_t) @@ -39,6 +41,8 @@ typedef void
>> (*evt_test_eventdev_destroy_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef void
>> (*evt_test_ethdev_destroy_t)
>>  		(struct evt_test *test, struct evt_options *opt);
>> +typedef void (*evt_test_cryptodev_destroy_t)
>> +		(struct evt_test *test, struct evt_options *opt);
>>  typedef void (*evt_test_mempool_destroy_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef void
>> (*evt_test_destroy_t) @@ -52,10 +56,12 @@ struct evt_test_ops {
>>  	evt_test_mempool_setup_t mempool_setup;
>>  	evt_test_ethdev_setup_t ethdev_setup;
>>  	evt_test_eventdev_setup_t eventdev_setup;
>> +	evt_test_cryptodev_setup_t cryptodev_setup;
>>  	evt_test_launch_lcores_t launch_lcores;
>>  	evt_test_result_t test_result;
>>  	evt_test_eventdev_destroy_t eventdev_destroy;
>>  	evt_test_ethdev_destroy_t ethdev_destroy;
>> +	evt_test_cryptodev_destroy_t cryptodev_destroy;
>>  	evt_test_mempool_destroy_t mempool_destroy;
>>  	evt_test_destroy_t test_destroy;
>>  };
>> diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-
>> eventdev/test_perf_atq.c
>> index 8fd51004ee..dbb1dc8c0c 100644
>> --- a/app/test-eventdev/test_perf_atq.c
>> +++ b/app/test-eventdev/test_perf_atq.c
>> @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int
>> enable_fwd_latency)
>>  			continue;
>>  		}
>>
>> +		if (prod_crypto_type &&
>> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
>> +			struct rte_crypto_op *op = ev.event_ptr;
>> +
>> +			if (op->status ==
>> RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +				if (op->sym->m_dst == NULL)
>> +					ev.event_ptr = op->sym->m_src;
>> +				else
>> +					ev.event_ptr = op->sym->m_dst;
>> +				rte_crypto_op_free(op);
>> +			} else {
>> +				rte_crypto_op_free(op);
>> +				continue;
>> +			}
>> +		}
>> +
>>  		if (enable_fwd_latency && !prod_timer_type)
>>  		/* first stage in pipeline, mark ts to compute fwd latency */
>>  			atq_mark_fwd_latency(&ev);
>> @@ -87,6 +103,25 @@ perf_atq_worker_burst(void *arg, const int
>> enable_fwd_latency)
>>  		}
>>
>>  		for (i = 0; i < nb_rx; i++) {
>> +			if (prod_crypto_type &&
>> +			    (ev[i].event_type ==
>> RTE_EVENT_TYPE_CRYPTODEV)) {
>> +				struct rte_crypto_op *op = ev[i].event_ptr;
>> +
>> +				if (op->status ==
>> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +					if (op->sym->m_dst == NULL)
>> +						ev[i].event_ptr =
>> +							op->sym->m_src;
>> +					else
>> +						ev[i].event_ptr =
>> +							op->sym->m_dst;
>> +					rte_crypto_op_free(op);
>> +				} else {
>> +					rte_crypto_op_free(op);
>> +					continue;
>> +				}
>> +			}
>> +
>>  			if (enable_fwd_latency && !prod_timer_type) {
>>  				rte_prefetch0(ev[i+1].event_ptr);
>>  				/* first stage in pipeline.
>> @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test,
>> struct evt_options *opt)
>>  				return ret;
>>  			}
>>  		}
>> +	} else if (opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> +		uint8_t cdev_id, cdev_count;
>> +
>> +		cdev_count = rte_cryptodev_count();
>> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +			ret = rte_cryptodev_start(cdev_id);
>> +			if (ret) {
>> +				evt_err("Failed to start cryptodev %u",
>> +					cdev_id);
>> +				return ret;
>> +			}
>> +		}
>> +
>> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
>>  	}
>>
>>  	return 0;
>> @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
>>  	.opt_dump           = perf_atq_opt_dump,
>>  	.test_setup         = perf_test_setup,
>>  	.ethdev_setup       = perf_ethdev_setup,
>> +	.cryptodev_setup    = perf_cryptodev_setup,
>>  	.mempool_setup      = perf_mempool_setup,
>>  	.eventdev_setup     = perf_atq_eventdev_setup,
>>  	.launch_lcores      = perf_atq_launch_lcores,
>>  	.eventdev_destroy   = perf_eventdev_destroy,
>>  	.mempool_destroy    = perf_mempool_destroy,
>>  	.ethdev_destroy     = perf_ethdev_destroy,
>> +	.cryptodev_destroy  = perf_cryptodev_destroy,
>>  	.test_result        = perf_test_result,
>>  	.test_destroy       = perf_test_destroy,
>>  };
>> diff --git a/app/test-eventdev/test_perf_common.c b/app/test-
>> eventdev/test_perf_common.c
>> index 9b73874151..91cb6748ee 100644
>> --- a/app/test-eventdev/test_perf_common.c
>> +++ b/app/test-eventdev/test_perf_common.c
>> @@ -6,6 +6,8 @@
>>
>>  #include "test_perf_common.h"
>>
>> +#define NB_CRYPTODEV_DESCRIPTORS 128
>> +
>>  int
>>  perf_test_result(struct evt_test *test, struct evt_options *opt)  { @@ -272,6
>> +274,125 @@ perf_event_timer_producer_burst(void *arg)
>>  	return 0;
>>  }
>>
>> +static inline void
>> +crypto_adapter_enq_op_new(struct prod_data *p) {
>> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
>> +	struct test_perf *t = p->t;
>> +	const uint32_t nb_flows = t->nb_flows;
>> +	const uint64_t nb_pkts = t->nb_pkts;
>> +	struct rte_mempool *pool = t->pool;
>> +	struct rte_crypto_sym_op *sym_op;
>> +	struct evt_options *opt = t->opt;
>> +	uint16_t qp_id = p->cdev_qp_id;
>> +	uint8_t cdev_id = p->cdev_id;
>> +	uint32_t flow_counter = 0;
>> +	struct rte_crypto_op *op;
>> +	struct rte_mbuf *m;
>> +	uint64_t count = 0;
>> +	uint16_t len;
>> +
>> +	if (opt->verbose_level > 1)
>> +		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id
>> %u\n",
>> +		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
>> +		       p->cdev_qp_id);
>> +
>> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
>> +
>> +	while (count < nb_pkts && t->done == false) {
>> +		m = rte_pktmbuf_alloc(pool);
>> +		if (m == NULL)
>> +			continue;
>> +
>> +		rte_pktmbuf_append(m, len);
>> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
>> +
>> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
>> +		sym_op = op->sym;
>> +		sym_op->m_src = m;
>> +		sym_op->cipher.data.offset = 0;
>> +		sym_op->cipher.data.length = len;
>> +		rte_crypto_op_attach_sym_session(
>> +			op, crypto_sess[flow_counter++ % nb_flows]);
>> +		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op,
>> 1) !=
>> +		       1) {
>> +			if (t->done)
>> +				break;
>> +			rte_pause();
>> +		}
>> +		count++;
>> +	}
>> +}
>> +
>> +static inline void
>> +crypto_adapter_enq_op_fwd(struct prod_data *p) {
>> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
>> +	const uint8_t dev_id = p->dev_id;
>> +	const uint8_t port = p->port_id;
>> +	struct test_perf *t = p->t;
>> +	const uint32_t nb_flows = t->nb_flows;
>> +	const uint64_t nb_pkts = t->nb_pkts;
>> +	struct rte_mempool *pool = t->pool;
>> +	struct evt_options *opt = t->opt;
>> +	struct rte_crypto_sym_op *sym_op;
>> +	uint32_t flow_counter = 0;
>> +	struct rte_crypto_op *op;
>> +	struct rte_event ev;
>> +	struct rte_mbuf *m;
>> +	uint64_t count = 0;
>> +	uint16_t len;
>> +
>> +	if (opt->verbose_level > 1)
>> +		printf("%s(): lcore %d port %d queue %d cdev_id %u
>> cdev_qp_id %u\n",
>> +		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
>> +		       p->cdev_qp_id);
>> +
>> +	ev.event = 0;
>> +	ev.op = RTE_EVENT_OP_NEW;
>> +	ev.queue_id = p->queue_id;
>> +	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
>> +	ev.event_type = RTE_EVENT_TYPE_CPU;
>> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
>> +
>> +	while (count < nb_pkts && t->done == false) {
>> +		m = rte_pktmbuf_alloc(pool);
>> +		if (m == NULL)
>> +			continue;
>> +
>> +		rte_pktmbuf_append(m, len);
>> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
>> +
>> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
>> +		sym_op = op->sym;
>> +		sym_op->m_src = m;
>> +		sym_op->cipher.data.offset = 0;
>> +		sym_op->cipher.data.length = len;
>> +		rte_crypto_op_attach_sym_session(
>> +			op, crypto_sess[flow_counter++ % nb_flows]);
>> +		ev.event_ptr = op;
>> +		while (rte_event_crypto_adapter_enqueue(dev_id, port,
>> &ev, 1) !=
>> +		       1) {
>> +			if (t->done)
>> +				break;
>> +			rte_pause();
>> +		}
>> +		count++;
>> +	}
>> +}
>> +
>> +static inline int
>> +perf_event_crypto_producer(void *arg)
>> +{
>> +	struct prod_data *p = arg;
>> +	struct evt_options *opt = p->t->opt;
>> +
>> +	if (opt->crypto_adptr_mode ==
>> RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
>> +		crypto_adapter_enq_op_new(p);
>> +	else
>> +		crypto_adapter_enq_op_fwd(p);
>> +
>> +	return 0;
>> +}
>> +
>>  static int
>>  perf_producer_wrapper(void *arg)
>>  {
>> @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
>>  	else if (t->opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
>>  			t->opt->timdev_use_burst)
>>  		return perf_event_timer_producer_burst(arg);
>> +	else if (t->opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> +		return perf_event_crypto_producer(arg);
>>  	return 0;
>>  }
>>
>> @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
>> evt_options *opt,
>>  			if (remaining <= 0) {
>>  				t->result = EVT_TEST_SUCCESS;
>>  				if (opt->prod_type ==
>> EVT_PROD_TYPE_SYNT ||
>> -					opt->prod_type ==
>> -
>> 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
>> +				    opt->prod_type ==
>> +
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> +				    opt->prod_type ==
>> +
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>>  					t->done = true;
>>  					break;
>>  				}
>> @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
>> evt_options *opt,
>>
>>  		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
>>  		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> -		     opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
>> +		     opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> +		     opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
>>  			remaining = t->outstand_pkts - processed_pkts(t);
>>  			if (dead_lock_remaining == remaining) {
>>  				rte_event_dev_dump(opt->dev_id, stdout);
>> @@ -537,6 +663,96 @@ perf_event_timer_adapter_setup(struct test_perf
>> *t)
>>  	return 0;
>>  }
>>
>> +static int
>> +perf_event_crypto_adapter_setup(struct test_perf *t,
>> +				struct rte_event_port_conf port_conf) {
>> +	struct evt_options *opt = t->opt;
>> +	uint8_t cdev_id, cdev_count;
>> +	int ret;
>> +
>> +	t->crypto_adptr.id = 0;
>> +	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
>> >dev_id,
>> +					      &port_conf, 0);
>> +	if (ret)
>> +		return ret;
>> +
>> +	cdev_count = rte_cryptodev_count();
>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		uint32_t cap;
>> +
>> +		ret = rte_event_crypto_adapter_caps_get(opt->dev_id,
>> cdev_id,
>> +							&cap);
>> +		if (ret) {
>> +			evt_err("Failed to get crypto adapter capabilities");
>> +			return ret;
>> +		}
>> +
>> +		if (((opt->crypto_adptr_mode ==
>> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
>> +		     !(cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
>> +		    ((opt->crypto_adptr_mode ==
>> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
>> +		     !(cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
>> +			evt_err("crypto adapter %s mode unsupported\n",
>> +				opt->crypto_adptr_mode ? "OP_FORWARD"
>> :
>> +							 "OP_NEW");
>> +			return -EINVAL;
>> +		}
>> +
>> +		if (!(cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
>> +			evt_err("Storing crypto session not supported");
>> +			return -EINVAL;
>> +		}
>> +
>> +		if (cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
>> +			struct rte_event response_info;
>> +
>> +			response_info.event = 0;
>> +			ret = rte_event_crypto_adapter_queue_pair_add(
>> +				t->crypto_adptr.id, cdev_id, -1,
>> +				&response_info);
>> +		} else {
>> +			ret = rte_event_crypto_adapter_queue_pair_add(
>> +				t->crypto_adptr.id, cdev_id, -1, NULL);
>> +		}
>> +		if (ret)
>> +			return ret;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static struct rte_cryptodev_sym_session *
>> +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
>> +	struct rte_crypto_sym_xform cipher_xform;
>> +	struct rte_cryptodev_sym_session *sess;
>> +
>> +	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
>> +	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
>> +	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
>> +	cipher_xform.next = NULL;
>> +
>> +	sess = rte_cryptodev_sym_session_create(t-
>> >crypto_adptr.sess_pool);
>> +	if (sess == NULL) {
>> +		evt_err("Failed to create sym session");
>> +		return NULL;
>> +	}
>> +
>> +	if (rte_cryptodev_sym_session_init(p->cdev_id, sess,
>> &cipher_xform,
>> +					   t->crypto_adptr.sess_priv_pool)) {
>> +		evt_err("Failed to init session");
>> +		return NULL;
>> +	}
>> +
>> +	return sess;
>> +}
>> +
>>  int
>>  perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>>  				uint8_t stride, uint8_t nb_queues,
>> @@ -598,6 +814,55 @@ perf_event_dev_port_setup(struct evt_test *test,
>> struct evt_options *opt,
>>  		ret = perf_event_timer_adapter_setup(t);
>>  		if (ret)
>>  			return ret;
>> +	} else if (opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> +		uint8_t cdev_id = 0;
>> +		uint16_t qp_id = 0;
>> +
>> +		prod = 0;
>> +		for (; port < perf_nb_event_ports(opt); port++) {
>> +			struct rte_cryptodev_sym_session *crypto_sess;
>> +			union rte_event_crypto_metadata m_data;
>> +			struct prod_data *p = &t->prod[port];
>> +			uint32_t flow_id;
>> +
>> +			if (qp_id ==
>> rte_cryptodev_queue_pair_count(cdev_id)) {
>> +				cdev_id++;
>> +				qp_id = 0;
>> +			}
>> +
>> +			p->dev_id = opt->dev_id;
>> +			p->port_id = port;
>> +			p->queue_id = prod * stride;
>> +			p->cdev_id = cdev_id;
>> +			p->cdev_qp_id = qp_id;
>> +			p->crypto_sess = rte_zmalloc_socket(
>> +				NULL, sizeof(crypto_sess) * t->nb_flows,
>> +				RTE_CACHE_LINE_SIZE, opt->socket_id);
>> +
>> +			m_data.request_info.cdev_id = p->cdev_id;
>> +			m_data.request_info.queue_pair_id = p-
>> >cdev_qp_id;
>> +			m_data.response_info.op = RTE_EVENT_OP_NEW;
>> +			m_data.response_info.sched_type =
>> RTE_SCHED_TYPE_ATOMIC;
>> +			m_data.response_info.event_type =
>> RTE_EVENT_TYPE_CPU;
>> +			m_data.response_info.queue_id = p->queue_id;
>> +			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
>> +				crypto_sess =
>> cryptodev_sym_sess_create(p, t);
>> +				if (crypto_sess == NULL)
>> +					return -ENOMEM;
>> +
>> +				m_data.response_info.flow_id = flow_id;
>> +				rte_cryptodev_sym_session_set_user_data(
>> +					crypto_sess, &m_data,
>> sizeof(m_data));
>> +				p->crypto_sess[flow_id] = crypto_sess;
>> +			}
>> +			p->t = t;
>> +			qp_id++;
>> +			prod++;
>> +		}
>> +
>> +		ret = perf_event_crypto_adapter_setup(t, *port_conf);
>> +		if (ret)
>> +			return ret;
>>  	} else {
>>  		prod = 0;
>>  		for ( ; port < perf_nb_event_ports(opt); port++) { @@ -659,7
>> +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
>>  	}
>>
>>  	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> -			opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
>> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>>  		/* Validate producer lcores */
>>  		if (evt_lcores_has_overlap(opt->plcores,
>>  					rte_get_main_lcore())) {
>> @@ -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct
>> evt_options *opt)
>>  		},
>>  	};
>>
>> -	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> -			opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
>> +	if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
>>  		return 0;
>>
>>  	if (!rte_eth_dev_count_avail()) {
>> @@ -841,6 +1106,139 @@ void perf_ethdev_destroy(struct evt_test *test,
>> struct evt_options *opt)
>>  	}
>>  }
>>
>> +int
>> +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt) {
>> +	uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
>> +	struct test_perf *t = evt_test_priv(test);
>> +	unsigned int max_session_size;
>> +	uint32_t nb_sessions;
>> +	int ret;
>> +
>> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> +		return 0;
>How do you differentiate between this failed case as you are returning 0 in case of
>success?
>
>> +
>> +	cdev_count = rte_cryptodev_count();
>> +	if (cdev_count == 0) {
>> +		evt_err("No crypto devices available\n");
>> +		return -ENODEV;
>> +	}
>> +
>> +	t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
>> +		"crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt-
>> >pool_sz,
>> +		128, 0, rte_socket_id());
>> +	if (t->crypto_adptr.op_pool == NULL) {
>> +		evt_err("Failed to create crypto op pool");
>> +		return -ENOMEM;
>> +	}
>> +
>> +	nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
>> +	t->crypto_adptr.sess_pool =
>> rte_cryptodev_sym_session_pool_create(
>> +		"ca_sess_pool", nb_sessions, 0, 0,
>> +		sizeof(union rte_event_crypto_metadata),
>> SOCKET_ID_ANY);
>> +	if (t->crypto_adptr.sess_pool == NULL) {
>> +		evt_err("Failed to create sym session pool");
>> +		ret = -ENOMEM;
>> +		goto err;
>> +	}
>> +
>> +	max_session_size = 0;
>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		unsigned int session_size;
>> +
>> +		session_size =
>> +
>> 	rte_cryptodev_sym_get_private_session_size(cdev_id);
>> +		if (session_size > max_session_size)
>> +			max_session_size = session_size;
>> +	}
>New line required
>> +	max_session_size += sizeof(union rte_event_crypto_metadata);
>> +	t->crypto_adptr.sess_priv_pool = rte_mempool_create(
>> +		"ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0,
>> NULL,
>> +		NULL, NULL, NULL, SOCKET_ID_ANY, 0);
>> +	if (t->crypto_adptr.sess_priv_pool == NULL) {
>> +		evt_err("failed to create sym session private pool");
>> +		ret = -ENOMEM;
>> +		goto err;
>> +	}
>> +
>> +	nb_plcores = evt_nr_active_lcores(opt->plcores);
>> +	nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) +
>> 1 :
>> +					     nb_plcores / cdev_count;
>Let's take an example:
>Cdev1 -> 8 qps
>Cdev2 -> 2 qps
>Cdev_count = 2
>nb_plcores = 7
>As per above statement, nb_qps = ( 7 % 2 ) 7/2 + 1 = 4 qps
>So, this fails to setup qps for cdev2 as it supports only 2 qps and test exits! Am I
>missing anything?
>

What you told is correct. But this is a simple logic to distribute qps across
multiple cdev and doesn't consider the case you mentioned. You could see
similar logic used in other apps. I will add a comment as below:
        /*
         * 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.
         */

>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		struct rte_cryptodev_qp_conf qp_conf;
>> +		struct rte_cryptodev_config conf;
>> +		struct rte_cryptodev_info info;
>> +		int qp_id;
>> +
>> +		rte_cryptodev_info_get(cdev_id, &info);
>> +		if (nb_qps > info.max_nb_queue_pairs) {
>> +			evt_err("Not enough queue pairs per cryptodev
>> (%u)",
>> +				nb_qps);
>> +			ret = -EINVAL;
>> +			goto err;
>> +		}
>> +
>> +		conf.nb_queue_pairs = nb_qps;
>> +		conf.socket_id = SOCKET_ID_ANY;
>> +		conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
>> +
>> +		ret = rte_cryptodev_configure(cdev_id, &conf);
>> +		if (ret) {
>> +			evt_err("Failed to configure cryptodev (%u)",
>> cdev_id);
>> +			goto err;
>> +		}
>> +
>> +		qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
>> +		qp_conf.mp_session = t->crypto_adptr.sess_pool;
>> +		qp_conf.mp_session_private = t-
>> >crypto_adptr.sess_priv_pool;
>> +
>> +		for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
>> +			ret = rte_cryptodev_queue_pair_setup(
>> +				cdev_id, qp_id, &qp_conf,
>> +				rte_cryptodev_socket_id(cdev_id));
>> +			if (ret) {
>> +				evt_err("Failed to setup queue pairs on
>> cryptodev %u\n",
>> +					cdev_id);
>> +				goto err;
>> +			}
>> +		}
>> +	}
>> +
>> +	return 0;
>> +err:
>> +	rte_mempool_free(t->crypto_adptr.op_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
>> +
>> +	return ret;
>> +}
>> +
>> +void
>> +perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt)
>> +{
>> +	uint8_t cdev_id, cdev_count = rte_cryptodev_count();
>> +	struct test_perf *t = evt_test_priv(test);
>> +
>> +	RTE_SET_USED(opt);
>> +
>> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> +		return;
>> +
>> +	rte_event_crypto_adapter_stop(t->crypto_adptr.id);
>> +
>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		rte_cryptodev_stop(cdev_id);
>> +		rte_event_crypto_adapter_queue_pair_del(t-
>> >crypto_adptr.id,
>> +							cdev_id, -1);
>Any reason for passing -1? This can not ensure to cleanup all the preconfigured
>qps as per API.
>> +	}
>> +
>> +	rte_event_crypto_adapter_free(t->crypto_adptr.id);
>> +
>> +	rte_mempool_free(t->crypto_adptr.op_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
>> +}
>> +
>>  int
>>  perf_mempool_setup(struct evt_test *test, struct evt_options *opt)  { diff -
>> -git a/app/test-eventdev/test_perf_common.h b/app/test-
>> eventdev/test_perf_common.h
>> index 14dcf80429..d9ad3a0b0d 100644
>> --- a/app/test-eventdev/test_perf_common.h
>> +++ b/app/test-eventdev/test_perf_common.h
>> @@ -9,9 +9,11 @@
>>  #include <stdbool.h>
>>  #include <unistd.h>
>>
>> +#include <rte_cryptodev.h>
>>  #include <rte_cycles.h>
>>  #include <rte_ethdev.h>
>>  #include <rte_eventdev.h>
>> +#include <rte_event_crypto_adapter.h>
>>  #include <rte_event_eth_rx_adapter.h>
>>  #include <rte_event_timer_adapter.h>
>>  #include <rte_lcore.h>
>> @@ -37,9 +39,18 @@ struct prod_data {
>>  	uint8_t dev_id;
>>  	uint8_t port_id;
>>  	uint8_t queue_id;
>> +	uint8_t cdev_id;
>> +	uint16_t cdev_qp_id;
>> +	struct rte_cryptodev_sym_session **crypto_sess;
>>  	struct test_perf *t;
>>  } __rte_cache_aligned;
>>
>> +struct crypto_adptr_data {
>> +	uint8_t id;
>> +	struct rte_mempool *op_pool;
>> +	struct rte_mempool *sess_pool;
>> +	struct rte_mempool *sess_priv_pool;
>> +};
>>
>>  struct test_perf {
>>  	/* Don't change the offset of "done". Signal handler use this memory
>> @@ -58,6 +69,7 @@ struct test_perf {
>>  	uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
>>  	struct rte_event_timer_adapter *timer_adptr[
>>  		RTE_EVENT_TIMER_ADAPTER_NUM_MAX]
>> __rte_cache_aligned;
>> +	struct crypto_adptr_data crypto_adptr;
>>  } __rte_cache_aligned;
>>
>>  struct perf_elt {
>> @@ -81,6 +93,8 @@ struct perf_elt {
>>  	const uint8_t port = w->port_id;\
>>  	const uint8_t prod_timer_type = \
>>  		opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
>> +	const uint8_t prod_crypto_type = \
>> +		opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
>>  	uint8_t *const sched_type_list = &t->sched_type_list[0];\
>>  	struct rte_mempool *const pool = t->pool;\
>>  	const uint8_t nb_stages = t->opt->nb_stages;\ @@ -154,6 +168,7
>> @@ int perf_test_result(struct evt_test *test, struct evt_options *opt);  int
>> perf_opt_check(struct evt_options *opt, uint64_t nb_queues);  int
>> perf_test_setup(struct evt_test *test, struct evt_options *opt);  int
>> perf_ethdev_setup(struct evt_test *test, struct evt_options *opt);
>> +int perf_cryptodev_setup(struct evt_test *test, struct evt_options
>> +*opt);
>>  int perf_mempool_setup(struct evt_test *test, struct evt_options *opt);  int
>> perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>>  				uint8_t stride, uint8_t nb_queues,
>> @@ -164,6 +179,7 @@ int perf_launch_lcores(struct evt_test *test, struct
>> evt_options *opt,  void perf_opt_dump(struct evt_options *opt, uint8_t
>> nb_queues);  void perf_test_destroy(struct evt_test *test, struct
>> evt_options *opt);  void perf_eventdev_destroy(struct evt_test *test, struct
>> evt_options *opt);
>> +void perf_cryptodev_destroy(struct evt_test *test, struct evt_options
>> +*opt);
>>  void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt);
>> void perf_mempool_destroy(struct evt_test *test, struct evt_options *opt);
>>
>> diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-
>> eventdev/test_perf_queue.c
>> index f4ea3a795f..5657c8b3cd 100644
>> --- a/app/test-eventdev/test_perf_queue.c
>> +++ b/app/test-eventdev/test_perf_queue.c
>> @@ -49,6 +49,23 @@ perf_queue_worker(void *arg, const int
>> enable_fwd_latency)
>>  			rte_pause();
>>  			continue;
>>  		}
>> +
>> +		if (prod_crypto_type &&
>> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
>> +			struct rte_crypto_op *op = ev.event_ptr;
>> +
>> +			if (op->status ==
>> RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +				if (op->sym->m_dst == NULL)
>> +					ev.event_ptr = op->sym->m_src;
>> +				else
>> +					ev.event_ptr = op->sym->m_dst;
>> +				rte_crypto_op_free(op);
>> +			} else {
>> +				rte_crypto_op_free(op);
>> +				continue;
>In case of failure, ops are freed and "ev.event_ptr" won't be set to mbuf.
>What would be the expected test result?
>> +			}
>> +		}
>> +
>>  		if (enable_fwd_latency && !prod_timer_type)
>>  		/* first q in pipeline, mark timestamp to compute fwd latency
>> */
>>  			mark_fwd_latency(&ev, nb_stages);
>> @@ -88,6 +105,25 @@ perf_queue_worker_burst(void *arg, const int
>> enable_fwd_latency)
>>  		}
>>
>>  		for (i = 0; i < nb_rx; i++) {
>> +			if (prod_crypto_type &&
>> +			    (ev[i].event_type ==
>> RTE_EVENT_TYPE_CRYPTODEV)) {
>> +				struct rte_crypto_op *op = ev[i].event_ptr;
>> +
>> +				if (op->status ==
>> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +					if (op->sym->m_dst == NULL)
>> +						ev[i].event_ptr =
>> +							op->sym->m_src;
>> +					else
>> +						ev[i].event_ptr =
>> +							op->sym->m_dst;
>> +					rte_crypto_op_free(op);
>> +				} else {
>> +					rte_crypto_op_free(op);
>> +					continue;
>> +				}
>> +			}
>> +
>>  			if (enable_fwd_latency && !prod_timer_type) {
>>  				rte_prefetch0(ev[i+1].event_ptr);
>>  				/* first queue in pipeline.
>> @@ -269,6 +305,20 @@ perf_queue_eventdev_setup(struct evt_test *test,
>> struct evt_options *opt)
>>  				return ret;
>>  			}
>>  		}
>> +	} else if (opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> +		uint8_t cdev_id, cdev_count;
>> +
>> +		cdev_count = rte_cryptodev_count();
>> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +			ret = rte_cryptodev_start(cdev_id);
>> +			if (ret) {
>> +				evt_err("Failed to start cryptodev %u",
>> +					cdev_id);
>> +				return ret;
>> +			}
>> +		}
>> +
>> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
>>  	}
>>
>>  	return 0;
>> @@ -311,11 +361,13 @@ static const struct evt_test_ops perf_queue =  {
>>  	.test_setup         = perf_test_setup,
>>  	.mempool_setup      = perf_mempool_setup,
>>  	.ethdev_setup	    = perf_ethdev_setup,
>> +	.cryptodev_setup    = perf_cryptodev_setup,
>>  	.eventdev_setup     = perf_queue_eventdev_setup,
>>  	.launch_lcores      = perf_queue_launch_lcores,
>>  	.eventdev_destroy   = perf_eventdev_destroy,
>>  	.mempool_destroy    = perf_mempool_destroy,
>>  	.ethdev_destroy	    = perf_ethdev_destroy,
>> +	.cryptodev_destroy  = perf_cryptodev_destroy,
>>  	.test_result        = perf_test_result,
>>  	.test_destroy       = perf_test_destroy,
>>  };
>> diff --git a/doc/guides/tools/testeventdev.rst
>> b/doc/guides/tools/testeventdev.rst
>> index 48efb9ea6e..f7d813226d 100644
>> --- a/doc/guides/tools/testeventdev.rst
>> +++ b/doc/guides/tools/testeventdev.rst
>> @@ -120,6 +120,10 @@ The following are the application command-line
>> options:
>>
>>         Use burst mode event timer adapter as producer.
>>
>> +* ``--prod_type_cryptodev``
>> +
>> +        Use crypto device as producer.
>> +
>>  * ``--timer_tick_nsec``
>>
>>         Used to dictate number of nano seconds between bucket traversal of
>> the @@ -148,6 +152,11 @@ The following are the application command-line
>> options:
>>         timeout is out of the supported range of event device it will be
>>         adjusted to the highest/lowest supported dequeue timeout supported.
>>
>> +* ``--crypto_adptr_mode``
>> +
>> +        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
>> +        OP_FORWARD mode.
>> +
>>  * ``--mbuf_sz``
>>
>>         Set packet mbuf size. Can be used to configure Jumbo Frames. Only @@
>> -420,6 +429,7 @@ Supported application command line options are
>> following::
>>          --prod_type_ethdev
>>          --prod_type_timerdev_burst
>>          --prod_type_timerdev
>> +        --prod_type_cryptodev
>>          --prod_enq_burst_sz
>>          --timer_tick_nsec
>>          --max_tmo_nsec
>> @@ -427,6 +437,7 @@ Supported application command line options are
>> following::
>>          --nb_timers
>>          --nb_timer_adptrs
>>          --deq_tmo_nsec
>> +        --crypto_adptr_mode
>>
>>  Example
>>  ^^^^^^^
>> @@ -529,12 +540,14 @@ Supported application command line options are
>> following::
>>          --prod_type_ethdev
>>          --prod_type_timerdev_burst
>>          --prod_type_timerdev
>> +        --prod_type_cryptodev
>>          --timer_tick_nsec
>>          --max_tmo_nsec
>>          --expiry_nsec
>>          --nb_timers
>>          --nb_timer_adptrs
>>          --deq_tmo_nsec
>> +        --crypto_adptr_mode
>>
>>  Example
>>  ^^^^^^^
>> --
>> 2.25.1
Shijith Thotton Jan. 24, 2022, 6:59 a.m. UTC | #5
Missed some comments in last mail.

>>
>> In crypto producer mode, producer core enqueues cryptodev with software
>> generated crypto ops and worker core dequeues crypto completion events
>> from the eventdev. Event crypto metadata used for above processing is pre-
>> populated in each crypto session.
>>
>> Parameter --prod_type_cryptodev can be used to enable crypto producer
>> mode. Parameter --crypto_adptr_mode can be set to select the crypto
>> adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
>>
>> This mode can be used to measure the performance of crypto adapter.
>>
>> Example:
>>   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
>>   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
>>   --stlist=a --wlcores 1 --plcores 2
>>
>> Signed-off-by: Shijith Thotton <sthotton@marvell.com>
>> ---
>> v3:
>> * Reduce dereference inside loop.
>>
>> v2:
>> * Fix RHEL compilation warning.
>>
>>  app/test-eventdev/evt_common.h       |   3 +
>>  app/test-eventdev/evt_main.c         |  13 +-
>>  app/test-eventdev/evt_options.c      |  27 ++
>>  app/test-eventdev/evt_options.h      |  12 +
>>  app/test-eventdev/evt_test.h         |   6 +
>>  app/test-eventdev/test_perf_atq.c    |  51 ++++
>>  app/test-eventdev/test_perf_common.c | 410
>> ++++++++++++++++++++++++++-  app/test-
>> eventdev/test_perf_common.h |  16 ++  app/test-
>> eventdev/test_perf_queue.c  |  52 ++++
>>  doc/guides/tools/testeventdev.rst    |  13 +
>>  10 files changed, 596 insertions(+), 7 deletions(-)
>>
>> diff --git a/app/test-eventdev/evt_common.h b/app/test-
>> eventdev/evt_common.h index f466434459..2f301a7e79 100644
>> --- a/app/test-eventdev/evt_common.h
>> +++ b/app/test-eventdev/evt_common.h
>> @@ -7,6 +7,7 @@
>>
>>  #include <rte_common.h>
>>  #include <rte_debug.h>
>> +#include <rte_event_crypto_adapter.h>
>>  #include <rte_eventdev.h>
>>  #include <rte_service.h>
>>
>> @@ -39,6 +40,7 @@ enum evt_prod_type {
>>  	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
>>  	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter.
>> */
>>  	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer
>> Adapter. */
>> +	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto
>> Adapter. */
>>  	EVT_PROD_TYPE_MAX,
>>  };
>>
>> @@ -77,6 +79,7 @@ struct evt_options {
>>  	uint64_t timer_tick_nsec;
>>  	uint64_t optm_timer_tick_nsec;
>>  	enum evt_prod_type prod_type;
>> +	enum rte_event_crypto_adapter_mode crypto_adptr_mode;
>>  };
>>
>>  static inline bool
>> diff --git a/app/test-eventdev/evt_main.c b/app/test-eventdev/evt_main.c
>> index 194c980c7a..cef0fb1382 100644
>> --- a/app/test-eventdev/evt_main.c
>> +++ b/app/test-eventdev/evt_main.c
>> @@ -161,12 +161,19 @@ main(int argc, char **argv)
>>  			goto mempool_destroy;
>>  		}
>>  	}
>New line required
Will add.

>> +	/* Test specific cryptodev setup */
>> +	if (test->ops.cryptodev_setup) {
>> +		if (test->ops.cryptodev_setup(test, &opt)) {
>> +			evt_err("%s: cryptodev setup failed",
>> opt.test_name);
>> +			goto ethdev_destroy;
>> +		}
>> +	}
>>
>>  	/* Test specific eventdev setup */
>>  	if (test->ops.eventdev_setup) {
>>  		if (test->ops.eventdev_setup(test, &opt)) {
>>  			evt_err("%s: eventdev setup failed",
>> opt.test_name);
>> -			goto ethdev_destroy;
>> +			goto cryptodev_destroy;
>>  		}
>>  	}
>>
>> @@ -197,6 +204,10 @@ main(int argc, char **argv)
>>  	if (test->ops.eventdev_destroy)
>>  		test->ops.eventdev_destroy(test, &opt);
>>
>> +cryptodev_destroy:
>> +	if (test->ops.cryptodev_destroy)
>> +		test->ops.cryptodev_destroy(test, &opt);
>> +
>>  ethdev_destroy:
>>  	if (test->ops.ethdev_destroy)
>>  		test->ops.ethdev_destroy(test, &opt); diff --git a/app/test-
>> eventdev/evt_options.c b/app/test-eventdev/evt_options.c index
>> 753a7dbd7d..5ad1491020 100644
>> --- a/app/test-eventdev/evt_options.c
>> +++ b/app/test-eventdev/evt_options.c
>> @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct
>> evt_options *opt,
>>  	return 0;
>>  }
>>
>> +static int
>> +evt_parse_crypto_prod_type(struct evt_options *opt,
>> +			   const char *arg __rte_unused)
>> +{
>> +	opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
>> +	return 0;
>> +}
>> +
>> +static int
>> +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg) {
>> +	uint8_t mode;
>> +	int ret;
>> +
>> +	ret = parser_read_uint8(&mode, arg);
>> +	opt->crypto_adptr_mode = mode ?
>> RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
>> +
>> 	RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
>> +	return ret;
>> +}
>> +
>>  static int
>>  evt_parse_test_name(struct evt_options *opt, const char *arg)  { @@ -
>> 335,6 +355,7 @@ usage(char *program)
>>  		"\t--queue_priority   : enable queue priority\n"
>>  		"\t--deq_tmo_nsec     : global dequeue timeout\n"
>>  		"\t--prod_type_ethdev : use ethernet device as
>> producer.\n"
>> +		"\t--prod_type_cryptodev : use crypto device as
>> producer.\n"
>>  		"\t--prod_type_timerdev : use event timer device as
>> producer.\n"
>>  		"\t                     expity_nsec would be the timeout\n"
>>  		"\t                     in ns.\n"
>> @@ -345,6 +366,8 @@ usage(char *program)
>>  		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
>>  		"\t--max_tmo_nsec     : max timeout interval in ns.\n"
>>  		"\t--expiry_nsec      : event timer expiry ns.\n"
>> +		"\t--crypto_adptr_mode : 0 for OP_NEW mode (default)
>> and\n"
>> +		"\t                      1 for OP_FORWARD mode.\n"
>>  		"\t--mbuf_sz          : packet mbuf size.\n"
>>  		"\t--max_pkt_sz       : max packet size.\n"
>>  		"\t--prod_enq_burst_sz : producer enqueue burst size.\n"
>> @@ -415,8 +438,10 @@ static struct option lgopts[] = {
>>  	{ EVT_QUEUE_PRIORITY,      0, 0, 0 },
>>  	{ EVT_DEQ_TMO_NSEC,        1, 0, 0 },
>>  	{ EVT_PROD_ETHDEV,         0, 0, 0 },
>> +	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
>>  	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
>>  	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
>> +	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
>>  	{ EVT_NB_TIMERS,           1, 0, 0 },
>>  	{ EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
>>  	{ EVT_TIMER_TICK_NSEC,     1, 0, 0 },
>> @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct evt_options
>> *opt)
>>  		{ EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
>>  		{ EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
>>  		{ EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
>> +		{ EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
>>  		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
>>  		{ EVT_PROD_TIMERDEV_BURST,
>> evt_parse_timer_prod_type_burst},
>> +		{ EVT_CRYPTO_ADPTR_MODE,
>> evt_parse_crypto_adptr_mode},
>>  		{ EVT_NB_TIMERS, evt_parse_nb_timers},
>>  		{ EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
>>  		{ EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec}, diff --
>> git a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
>> index 413d7092f0..2231c58801 100644
>> --- a/app/test-eventdev/evt_options.h
>> +++ b/app/test-eventdev/evt_options.h
>> @@ -9,6 +9,7 @@
>>  #include <stdbool.h>
>>
>>  #include <rte_common.h>
>> +#include <rte_cryptodev.h>
>>  #include <rte_ethdev.h>
>>  #include <rte_eventdev.h>
>>  #include <rte_lcore.h>
>> @@ -33,8 +34,10 @@
>>  #define EVT_QUEUE_PRIORITY       ("queue_priority")
>>  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
>>  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
>> +#define EVT_PROD_CRYPTODEV	 ("prod_type_cryptodev")
>>  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
>>  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
>> +#define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
>>  #define EVT_NB_TIMERS            ("nb_timers")
>>  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
>>  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
>> @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type
>> prod_type)
>>  		return "Ethdev Rx Adapter";
>>  	case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
>>  		return "Event timer adapter";
>> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
>> +		return "Event crypto adapter";
>>  	}
>>
>>  	return "";
>> @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options *opt)
>>  			evt_dump("timer_tick_nsec", "%"PRIu64"",
>>  					opt->timer_tick_nsec);
>>  		break;
>> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
>> +		snprintf(name, EVT_PROD_MAX_NAME_LEN,
>> +			 "Event crypto adapter producers");
>> +		evt_dump("crypto adapter mode", "%s",
>> +			 opt->crypto_adptr_mode ? "OP_FORWARD" :
>> "OP_NEW");
>> +		evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
>> +		break;
>>  	}
>>  	evt_dump("prod_type", "%s", name);
>>  }
>> diff --git a/app/test-eventdev/evt_test.h b/app/test-eventdev/evt_test.h
>> index f07d2c3336..50fa474ec2 100644
>> --- a/app/test-eventdev/evt_test.h
>> +++ b/app/test-eventdev/evt_test.h
>> @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef int
>> (*evt_test_ethdev_setup_t)
>>  		(struct evt_test *test, struct evt_options *opt);
>> +typedef int (*evt_test_cryptodev_setup_t)
>> +		(struct evt_test *test, struct evt_options *opt);
>>  typedef int (*evt_test_eventdev_setup_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef int
>> (*evt_test_launch_lcores_t) @@ -39,6 +41,8 @@ typedef void
>> (*evt_test_eventdev_destroy_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef void
>> (*evt_test_ethdev_destroy_t)
>>  		(struct evt_test *test, struct evt_options *opt);
>> +typedef void (*evt_test_cryptodev_destroy_t)
>> +		(struct evt_test *test, struct evt_options *opt);
>>  typedef void (*evt_test_mempool_destroy_t)
>>  		(struct evt_test *test, struct evt_options *opt);  typedef void
>> (*evt_test_destroy_t) @@ -52,10 +56,12 @@ struct evt_test_ops {
>>  	evt_test_mempool_setup_t mempool_setup;
>>  	evt_test_ethdev_setup_t ethdev_setup;
>>  	evt_test_eventdev_setup_t eventdev_setup;
>> +	evt_test_cryptodev_setup_t cryptodev_setup;
>>  	evt_test_launch_lcores_t launch_lcores;
>>  	evt_test_result_t test_result;
>>  	evt_test_eventdev_destroy_t eventdev_destroy;
>>  	evt_test_ethdev_destroy_t ethdev_destroy;
>> +	evt_test_cryptodev_destroy_t cryptodev_destroy;
>>  	evt_test_mempool_destroy_t mempool_destroy;
>>  	evt_test_destroy_t test_destroy;
>>  };
>> diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-
>> eventdev/test_perf_atq.c
>> index 8fd51004ee..dbb1dc8c0c 100644
>> --- a/app/test-eventdev/test_perf_atq.c
>> +++ b/app/test-eventdev/test_perf_atq.c
>> @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int
>> enable_fwd_latency)
>>  			continue;
>>  		}
>>
>> +		if (prod_crypto_type &&
>> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
>> +			struct rte_crypto_op *op = ev.event_ptr;
>> +
>> +			if (op->status ==
>> RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +				if (op->sym->m_dst == NULL)
>> +					ev.event_ptr = op->sym->m_src;
>> +				else
>> +					ev.event_ptr = op->sym->m_dst;
>> +				rte_crypto_op_free(op);
>> +			} else {
>> +				rte_crypto_op_free(op);
>> +				continue;
>> +			}
>> +		}
>> +
>>  		if (enable_fwd_latency && !prod_timer_type)
>>  		/* first stage in pipeline, mark ts to compute fwd latency */
>>  			atq_mark_fwd_latency(&ev);
>> @@ -87,6 +103,25 @@ perf_atq_worker_burst(void *arg, const int
>> enable_fwd_latency)
>>  		}
>>
>>  		for (i = 0; i < nb_rx; i++) {
>> +			if (prod_crypto_type &&
>> +			    (ev[i].event_type ==
>> RTE_EVENT_TYPE_CRYPTODEV)) {
>> +				struct rte_crypto_op *op = ev[i].event_ptr;
>> +
>> +				if (op->status ==
>> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +					if (op->sym->m_dst == NULL)
>> +						ev[i].event_ptr =
>> +							op->sym->m_src;
>> +					else
>> +						ev[i].event_ptr =
>> +							op->sym->m_dst;
>> +					rte_crypto_op_free(op);
>> +				} else {
>> +					rte_crypto_op_free(op);
>> +					continue;
>> +				}
>> +			}
>> +
>>  			if (enable_fwd_latency && !prod_timer_type) {
>>  				rte_prefetch0(ev[i+1].event_ptr);
>>  				/* first stage in pipeline.
>> @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test,
>> struct evt_options *opt)
>>  				return ret;
>>  			}
>>  		}
>> +	} else if (opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> +		uint8_t cdev_id, cdev_count;
>> +
>> +		cdev_count = rte_cryptodev_count();
>> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +			ret = rte_cryptodev_start(cdev_id);
>> +			if (ret) {
>> +				evt_err("Failed to start cryptodev %u",
>> +					cdev_id);
>> +				return ret;
>> +			}
>> +		}
>> +
>> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
>>  	}
>>
>>  	return 0;
>> @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
>>  	.opt_dump           = perf_atq_opt_dump,
>>  	.test_setup         = perf_test_setup,
>>  	.ethdev_setup       = perf_ethdev_setup,
>> +	.cryptodev_setup    = perf_cryptodev_setup,
>>  	.mempool_setup      = perf_mempool_setup,
>>  	.eventdev_setup     = perf_atq_eventdev_setup,
>>  	.launch_lcores      = perf_atq_launch_lcores,
>>  	.eventdev_destroy   = perf_eventdev_destroy,
>>  	.mempool_destroy    = perf_mempool_destroy,
>>  	.ethdev_destroy     = perf_ethdev_destroy,
>> +	.cryptodev_destroy  = perf_cryptodev_destroy,
>>  	.test_result        = perf_test_result,
>>  	.test_destroy       = perf_test_destroy,
>>  };
>> diff --git a/app/test-eventdev/test_perf_common.c b/app/test-
>> eventdev/test_perf_common.c
>> index 9b73874151..91cb6748ee 100644
>> --- a/app/test-eventdev/test_perf_common.c
>> +++ b/app/test-eventdev/test_perf_common.c
>> @@ -6,6 +6,8 @@
>>
>>  #include "test_perf_common.h"
>>
>> +#define NB_CRYPTODEV_DESCRIPTORS 128
>> +
>>  int
>>  perf_test_result(struct evt_test *test, struct evt_options *opt)  { @@ -272,6
>> +274,125 @@ perf_event_timer_producer_burst(void *arg)
>>  	return 0;
>>  }
>>
>> +static inline void
>> +crypto_adapter_enq_op_new(struct prod_data *p) {
>> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
>> +	struct test_perf *t = p->t;
>> +	const uint32_t nb_flows = t->nb_flows;
>> +	const uint64_t nb_pkts = t->nb_pkts;
>> +	struct rte_mempool *pool = t->pool;
>> +	struct rte_crypto_sym_op *sym_op;
>> +	struct evt_options *opt = t->opt;
>> +	uint16_t qp_id = p->cdev_qp_id;
>> +	uint8_t cdev_id = p->cdev_id;
>> +	uint32_t flow_counter = 0;
>> +	struct rte_crypto_op *op;
>> +	struct rte_mbuf *m;
>> +	uint64_t count = 0;
>> +	uint16_t len;
>> +
>> +	if (opt->verbose_level > 1)
>> +		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id
>> %u\n",
>> +		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
>> +		       p->cdev_qp_id);
>> +
>> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
>> +
>> +	while (count < nb_pkts && t->done == false) {
>> +		m = rte_pktmbuf_alloc(pool);
>> +		if (m == NULL)
>> +			continue;
>> +
>> +		rte_pktmbuf_append(m, len);
>> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
>> +
>> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
>> +		sym_op = op->sym;
>> +		sym_op->m_src = m;
>> +		sym_op->cipher.data.offset = 0;
>> +		sym_op->cipher.data.length = len;
>> +		rte_crypto_op_attach_sym_session(
>> +			op, crypto_sess[flow_counter++ % nb_flows]);
>> +		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op,
>> 1) !=
>> +		       1) {
>> +			if (t->done)
>> +				break;
>> +			rte_pause();
>> +		}
>> +		count++;
>> +	}
>> +}
>> +
>> +static inline void
>> +crypto_adapter_enq_op_fwd(struct prod_data *p) {
>> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
>> +	const uint8_t dev_id = p->dev_id;
>> +	const uint8_t port = p->port_id;
>> +	struct test_perf *t = p->t;
>> +	const uint32_t nb_flows = t->nb_flows;
>> +	const uint64_t nb_pkts = t->nb_pkts;
>> +	struct rte_mempool *pool = t->pool;
>> +	struct evt_options *opt = t->opt;
>> +	struct rte_crypto_sym_op *sym_op;
>> +	uint32_t flow_counter = 0;
>> +	struct rte_crypto_op *op;
>> +	struct rte_event ev;
>> +	struct rte_mbuf *m;
>> +	uint64_t count = 0;
>> +	uint16_t len;
>> +
>> +	if (opt->verbose_level > 1)
>> +		printf("%s(): lcore %d port %d queue %d cdev_id %u
>> cdev_qp_id %u\n",
>> +		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
>> +		       p->cdev_qp_id);
>> +
>> +	ev.event = 0;
>> +	ev.op = RTE_EVENT_OP_NEW;
>> +	ev.queue_id = p->queue_id;
>> +	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
>> +	ev.event_type = RTE_EVENT_TYPE_CPU;
>> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
>> +
>> +	while (count < nb_pkts && t->done == false) {
>> +		m = rte_pktmbuf_alloc(pool);
>> +		if (m == NULL)
>> +			continue;
>> +
>> +		rte_pktmbuf_append(m, len);
>> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
>> +
>> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
>> +		sym_op = op->sym;
>> +		sym_op->m_src = m;
>> +		sym_op->cipher.data.offset = 0;
>> +		sym_op->cipher.data.length = len;
>> +		rte_crypto_op_attach_sym_session(
>> +			op, crypto_sess[flow_counter++ % nb_flows]);
>> +		ev.event_ptr = op;
>> +		while (rte_event_crypto_adapter_enqueue(dev_id, port,
>> &ev, 1) !=
>> +		       1) {
>> +			if (t->done)
>> +				break;
>> +			rte_pause();
>> +		}
>> +		count++;
>> +	}
>> +}
>> +
>> +static inline int
>> +perf_event_crypto_producer(void *arg)
>> +{
>> +	struct prod_data *p = arg;
>> +	struct evt_options *opt = p->t->opt;
>> +
>> +	if (opt->crypto_adptr_mode ==
>> RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
>> +		crypto_adapter_enq_op_new(p);
>> +	else
>> +		crypto_adapter_enq_op_fwd(p);
>> +
>> +	return 0;
>> +}
>> +
>>  static int
>>  perf_producer_wrapper(void *arg)
>>  {
>> @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
>>  	else if (t->opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
>>  			t->opt->timdev_use_burst)
>>  		return perf_event_timer_producer_burst(arg);
>> +	else if (t->opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> +		return perf_event_crypto_producer(arg);
>>  	return 0;
>>  }
>>
>> @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
>> evt_options *opt,
>>  			if (remaining <= 0) {
>>  				t->result = EVT_TEST_SUCCESS;
>>  				if (opt->prod_type ==
>> EVT_PROD_TYPE_SYNT ||
>> -					opt->prod_type ==
>> -
>> 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
>> +				    opt->prod_type ==
>> +
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> +				    opt->prod_type ==
>> +
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>>  					t->done = true;
>>  					break;
>>  				}
>> @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
>> evt_options *opt,
>>
>>  		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
>>  		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> -		     opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
>> +		     opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> +		     opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
>>  			remaining = t->outstand_pkts - processed_pkts(t);
>>  			if (dead_lock_remaining == remaining) {
>>  				rte_event_dev_dump(opt->dev_id, stdout);
>> @@ -537,6 +663,96 @@ perf_event_timer_adapter_setup(struct test_perf
>> *t)
>>  	return 0;
>>  }
>>
>> +static int
>> +perf_event_crypto_adapter_setup(struct test_perf *t,
>> +				struct rte_event_port_conf port_conf) {
>> +	struct evt_options *opt = t->opt;
>> +	uint8_t cdev_id, cdev_count;
>> +	int ret;
>> +
>> +	t->crypto_adptr.id = 0;
>> +	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
>> >dev_id,
>> +					      &port_conf, 0);
>> +	if (ret)
>> +		return ret;
>> +
>> +	cdev_count = rte_cryptodev_count();
>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		uint32_t cap;
>> +
>> +		ret = rte_event_crypto_adapter_caps_get(opt->dev_id,
>> cdev_id,
>> +							&cap);
>> +		if (ret) {
>> +			evt_err("Failed to get crypto adapter capabilities");
>> +			return ret;
>> +		}
>> +
>> +		if (((opt->crypto_adptr_mode ==
>> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
>> +		     !(cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
>> +		    ((opt->crypto_adptr_mode ==
>> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
>> +		     !(cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
>> +			evt_err("crypto adapter %s mode unsupported\n",
>> +				opt->crypto_adptr_mode ? "OP_FORWARD"
>> :
>> +							 "OP_NEW");
>> +			return -EINVAL;
>> +		}
>> +
>> +		if (!(cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
>> +			evt_err("Storing crypto session not supported");
>> +			return -EINVAL;
>> +		}
>> +
>> +		if (cap &
>> +
>> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
>> +			struct rte_event response_info;
>> +
>> +			response_info.event = 0;
>> +			ret = rte_event_crypto_adapter_queue_pair_add(
>> +				t->crypto_adptr.id, cdev_id, -1,
>> +				&response_info);
>> +		} else {
>> +			ret = rte_event_crypto_adapter_queue_pair_add(
>> +				t->crypto_adptr.id, cdev_id, -1, NULL);
>> +		}
>> +		if (ret)
>> +			return ret;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static struct rte_cryptodev_sym_session *
>> +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
>> +	struct rte_crypto_sym_xform cipher_xform;
>> +	struct rte_cryptodev_sym_session *sess;
>> +
>> +	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
>> +	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
>> +	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
>> +	cipher_xform.next = NULL;
>> +
>> +	sess = rte_cryptodev_sym_session_create(t-
>> >crypto_adptr.sess_pool);
>> +	if (sess == NULL) {
>> +		evt_err("Failed to create sym session");
>> +		return NULL;
>> +	}
>> +
>> +	if (rte_cryptodev_sym_session_init(p->cdev_id, sess,
>> &cipher_xform,
>> +					   t->crypto_adptr.sess_priv_pool)) {
>> +		evt_err("Failed to init session");
>> +		return NULL;
>> +	}
>> +
>> +	return sess;
>> +}
>> +
>>  int
>>  perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>>  				uint8_t stride, uint8_t nb_queues,
>> @@ -598,6 +814,55 @@ perf_event_dev_port_setup(struct evt_test *test,
>> struct evt_options *opt,
>>  		ret = perf_event_timer_adapter_setup(t);
>>  		if (ret)
>>  			return ret;
>> +	} else if (opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> +		uint8_t cdev_id = 0;
>> +		uint16_t qp_id = 0;
>> +
>> +		prod = 0;
>> +		for (; port < perf_nb_event_ports(opt); port++) {
>> +			struct rte_cryptodev_sym_session *crypto_sess;
>> +			union rte_event_crypto_metadata m_data;
>> +			struct prod_data *p = &t->prod[port];
>> +			uint32_t flow_id;
>> +
>> +			if (qp_id ==
>> rte_cryptodev_queue_pair_count(cdev_id)) {
>> +				cdev_id++;
>> +				qp_id = 0;
>> +			}
>> +
>> +			p->dev_id = opt->dev_id;
>> +			p->port_id = port;
>> +			p->queue_id = prod * stride;
>> +			p->cdev_id = cdev_id;
>> +			p->cdev_qp_id = qp_id;
>> +			p->crypto_sess = rte_zmalloc_socket(
>> +				NULL, sizeof(crypto_sess) * t->nb_flows,
>> +				RTE_CACHE_LINE_SIZE, opt->socket_id);
>> +
>> +			m_data.request_info.cdev_id = p->cdev_id;
>> +			m_data.request_info.queue_pair_id = p-
>> >cdev_qp_id;
>> +			m_data.response_info.op = RTE_EVENT_OP_NEW;
>> +			m_data.response_info.sched_type =
>> RTE_SCHED_TYPE_ATOMIC;
>> +			m_data.response_info.event_type =
>> RTE_EVENT_TYPE_CPU;
>> +			m_data.response_info.queue_id = p->queue_id;
>> +			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
>> +				crypto_sess =
>> cryptodev_sym_sess_create(p, t);
>> +				if (crypto_sess == NULL)
>> +					return -ENOMEM;
>> +
>> +				m_data.response_info.flow_id = flow_id;
>> +				rte_cryptodev_sym_session_set_user_data(
>> +					crypto_sess, &m_data,
>> sizeof(m_data));
>> +				p->crypto_sess[flow_id] = crypto_sess;
>> +			}
>> +			p->t = t;
>> +			qp_id++;
>> +			prod++;
>> +		}
>> +
>> +		ret = perf_event_crypto_adapter_setup(t, *port_conf);
>> +		if (ret)
>> +			return ret;
>>  	} else {
>>  		prod = 0;
>>  		for ( ; port < perf_nb_event_ports(opt); port++) { @@ -659,7
>> +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
>>  	}
>>
>>  	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> -			opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
>> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>>  		/* Validate producer lcores */
>>  		if (evt_lcores_has_overlap(opt->plcores,
>>  					rte_get_main_lcore())) {
>> @@ -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct
>> evt_options *opt)
>>  		},
>>  	};
>>
>> -	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> -			opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
>> +	if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
>>  		return 0;
>>
>>  	if (!rte_eth_dev_count_avail()) {
>> @@ -841,6 +1106,139 @@ void perf_ethdev_destroy(struct evt_test *test,
>> struct evt_options *opt)
>>  	}
>>  }
>>
>> +int
>> +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt) {
>> +	uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
>> +	struct test_perf *t = evt_test_priv(test);
>> +	unsigned int max_session_size;
>> +	uint32_t nb_sessions;
>> +	int ret;
>> +
>> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> +		return 0;
>How do you differentiate between this failed case as you are returning 0 in case of
>success?

This is not a failed case. cryptodev setup is not needed in other modes and is ignored.

>> +
>> +	cdev_count = rte_cryptodev_count();
>> +	if (cdev_count == 0) {
>> +		evt_err("No crypto devices available\n");
>> +		return -ENODEV;
>> +	}
>> +
>> +	t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
>> +		"crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt-
>> >pool_sz,
>> +		128, 0, rte_socket_id());
>> +	if (t->crypto_adptr.op_pool == NULL) {
>> +		evt_err("Failed to create crypto op pool");
>> +		return -ENOMEM;
>> +	}
>> +
>> +	nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
>> +	t->crypto_adptr.sess_pool =
>> rte_cryptodev_sym_session_pool_create(
>> +		"ca_sess_pool", nb_sessions, 0, 0,
>> +		sizeof(union rte_event_crypto_metadata),
>> SOCKET_ID_ANY);
>> +	if (t->crypto_adptr.sess_pool == NULL) {
>> +		evt_err("Failed to create sym session pool");
>> +		ret = -ENOMEM;
>> +		goto err;
>> +	}
>> +
>> +	max_session_size = 0;
>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		unsigned int session_size;
>> +
>> +		session_size =
>> +
>> 	rte_cryptodev_sym_get_private_session_size(cdev_id);
>> +		if (session_size > max_session_size)
>> +			max_session_size = session_size;
>> +	}
>New line required
Will add.

>> +	max_session_size += sizeof(union rte_event_crypto_metadata);
>> +	t->crypto_adptr.sess_priv_pool = rte_mempool_create(
>> +		"ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0,
>> NULL,
>> +		NULL, NULL, NULL, SOCKET_ID_ANY, 0);
>> +	if (t->crypto_adptr.sess_priv_pool == NULL) {
>> +		evt_err("failed to create sym session private pool");
>> +		ret = -ENOMEM;
>> +		goto err;
>> +	}
>> +
>> +	nb_plcores = evt_nr_active_lcores(opt->plcores);
>> +	nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) +
>> 1 :
>> +					     nb_plcores / cdev_count;
>Let's take an example:
>Cdev1 -> 8 qps
>Cdev2 -> 2 qps
>Cdev_count = 2
>nb_plcores = 7
>As per above statement, nb_qps = ( 7 % 2 ) 7/2 + 1 = 4 qps
>So, this fails to setup qps for cdev2 as it supports only 2 qps and test exits! Am I
>missing anything?
>
What you told is correct. But this is a simple logic to distribute qps across
multiple cdev and doesn't consider the case you mentioned. You could see
similar logic used in other apps. I will add a comment as below:
        /*
         * 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.
         */

>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		struct rte_cryptodev_qp_conf qp_conf;
>> +		struct rte_cryptodev_config conf;
>> +		struct rte_cryptodev_info info;
>> +		int qp_id;
>> +
>> +		rte_cryptodev_info_get(cdev_id, &info);
>> +		if (nb_qps > info.max_nb_queue_pairs) {
>> +			evt_err("Not enough queue pairs per cryptodev
>> (%u)",
>> +				nb_qps);
>> +			ret = -EINVAL;
>> +			goto err;
>> +		}
>> +
>> +		conf.nb_queue_pairs = nb_qps;
>> +		conf.socket_id = SOCKET_ID_ANY;
>> +		conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
>> +
>> +		ret = rte_cryptodev_configure(cdev_id, &conf);
>> +		if (ret) {
>> +			evt_err("Failed to configure cryptodev (%u)",
>> cdev_id);
>> +			goto err;
>> +		}
>> +
>> +		qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
>> +		qp_conf.mp_session = t->crypto_adptr.sess_pool;
>> +		qp_conf.mp_session_private = t-
>> >crypto_adptr.sess_priv_pool;
>> +
>> +		for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
>> +			ret = rte_cryptodev_queue_pair_setup(
>> +				cdev_id, qp_id, &qp_conf,
>> +				rte_cryptodev_socket_id(cdev_id));
>> +			if (ret) {
>> +				evt_err("Failed to setup queue pairs on
>> cryptodev %u\n",
>> +					cdev_id);
>> +				goto err;
>> +			}
>> +		}
>> +	}
>> +
>> +	return 0;
>> +err:
>> +	rte_mempool_free(t->crypto_adptr.op_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
>> +
>> +	return ret;
>> +}
>> +
>> +void
>> +perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt)
>> +{
>> +	uint8_t cdev_id, cdev_count = rte_cryptodev_count();
>> +	struct test_perf *t = evt_test_priv(test);
>> +
>> +	RTE_SET_USED(opt);
>> +
>> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> +		return;
>> +
>> +	rte_event_crypto_adapter_stop(t->crypto_adptr.id);
>> +
>> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +		rte_cryptodev_stop(cdev_id);
>> +		rte_event_crypto_adapter_queue_pair_del(t-
>> >crypto_adptr.id,
>> +							cdev_id, -1);
>Any reason for passing -1? This can not ensure to cleanup all the preconfigured
>qps as per API.
Okay, I thought the behavior is like rte_event_crypto_adapter_queue_pair_add.
Any reason, spec desn't consider -1 for rte_event_crypto_adapter_queue_pair_del ?

>> +	}
>> +
>> +	rte_event_crypto_adapter_free(t->crypto_adptr.id);
>> +
>> +	rte_mempool_free(t->crypto_adptr.op_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_pool);
>> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
>> +}
>> +
>>  int
>>  perf_mempool_setup(struct evt_test *test, struct evt_options *opt)  { diff -
>> -git a/app/test-eventdev/test_perf_common.h b/app/test-
>> eventdev/test_perf_common.h
>> index 14dcf80429..d9ad3a0b0d 100644
>> --- a/app/test-eventdev/test_perf_common.h
>> +++ b/app/test-eventdev/test_perf_common.h
>> @@ -9,9 +9,11 @@
>>  #include <stdbool.h>
>>  #include <unistd.h>
>>
>> +#include <rte_cryptodev.h>
>>  #include <rte_cycles.h>
>>  #include <rte_ethdev.h>
>>  #include <rte_eventdev.h>
>> +#include <rte_event_crypto_adapter.h>
>>  #include <rte_event_eth_rx_adapter.h>
>>  #include <rte_event_timer_adapter.h>
>>  #include <rte_lcore.h>
>> @@ -37,9 +39,18 @@ struct prod_data {
>>  	uint8_t dev_id;
>>  	uint8_t port_id;
>>  	uint8_t queue_id;
>> +	uint8_t cdev_id;
>> +	uint16_t cdev_qp_id;
>> +	struct rte_cryptodev_sym_session **crypto_sess;
>>  	struct test_perf *t;
>>  } __rte_cache_aligned;
>>
>> +struct crypto_adptr_data {
>> +	uint8_t id;
>> +	struct rte_mempool *op_pool;
>> +	struct rte_mempool *sess_pool;
>> +	struct rte_mempool *sess_priv_pool;
>> +};
>>
>>  struct test_perf {
>>  	/* Don't change the offset of "done". Signal handler use this memory
>> @@ -58,6 +69,7 @@ struct test_perf {
>>  	uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
>>  	struct rte_event_timer_adapter *timer_adptr[
>>  		RTE_EVENT_TIMER_ADAPTER_NUM_MAX]
>> __rte_cache_aligned;
>> +	struct crypto_adptr_data crypto_adptr;
>>  } __rte_cache_aligned;
>>
>>  struct perf_elt {
>> @@ -81,6 +93,8 @@ struct perf_elt {
>>  	const uint8_t port = w->port_id;\
>>  	const uint8_t prod_timer_type = \
>>  		opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
>> +	const uint8_t prod_crypto_type = \
>> +		opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
>>  	uint8_t *const sched_type_list = &t->sched_type_list[0];\
>>  	struct rte_mempool *const pool = t->pool;\
>>  	const uint8_t nb_stages = t->opt->nb_stages;\ @@ -154,6 +168,7
>> @@ int perf_test_result(struct evt_test *test, struct evt_options *opt);  int
>> perf_opt_check(struct evt_options *opt, uint64_t nb_queues);  int
>> perf_test_setup(struct evt_test *test, struct evt_options *opt);  int
>> perf_ethdev_setup(struct evt_test *test, struct evt_options *opt);
>> +int perf_cryptodev_setup(struct evt_test *test, struct evt_options
>> +*opt);
>>  int perf_mempool_setup(struct evt_test *test, struct evt_options *opt);  int
>> perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
>>  				uint8_t stride, uint8_t nb_queues,
>> @@ -164,6 +179,7 @@ int perf_launch_lcores(struct evt_test *test, struct
>> evt_options *opt,  void perf_opt_dump(struct evt_options *opt, uint8_t
>> nb_queues);  void perf_test_destroy(struct evt_test *test, struct
>> evt_options *opt);  void perf_eventdev_destroy(struct evt_test *test, struct
>> evt_options *opt);
>> +void perf_cryptodev_destroy(struct evt_test *test, struct evt_options
>> +*opt);
>>  void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt);
>> void perf_mempool_destroy(struct evt_test *test, struct evt_options *opt);
>>
>> diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-
>> eventdev/test_perf_queue.c
>> index f4ea3a795f..5657c8b3cd 100644
>> --- a/app/test-eventdev/test_perf_queue.c
>> +++ b/app/test-eventdev/test_perf_queue.c
>> @@ -49,6 +49,23 @@ perf_queue_worker(void *arg, const int
>> enable_fwd_latency)
>>  			rte_pause();
>>  			continue;
>>  		}
>> +
>> +		if (prod_crypto_type &&
>> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
>> +			struct rte_crypto_op *op = ev.event_ptr;
>> +
>> +			if (op->status ==
>> RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +				if (op->sym->m_dst == NULL)
>> +					ev.event_ptr = op->sym->m_src;
>> +				else
>> +					ev.event_ptr = op->sym->m_dst;
>> +				rte_crypto_op_free(op);
>> +			} else {
>> +				rte_crypto_op_free(op);
>> +				continue;
>In case of failure, ops are freed and "ev.event_ptr" won't be set to mbuf.
>What would be the expected test result?
In case of error, processed_pkts is not updated. If all packets fails, output will be 0 PPS.

>> +			}
>> +		}
>> +
>>  		if (enable_fwd_latency && !prod_timer_type)
>>  		/* first q in pipeline, mark timestamp to compute fwd latency
>> */
>>  			mark_fwd_latency(&ev, nb_stages);
>> @@ -88,6 +105,25 @@ perf_queue_worker_burst(void *arg, const int
>> enable_fwd_latency)
>>  		}
>>
>>  		for (i = 0; i < nb_rx; i++) {
>> +			if (prod_crypto_type &&
>> +			    (ev[i].event_type ==
>> RTE_EVENT_TYPE_CRYPTODEV)) {
>> +				struct rte_crypto_op *op = ev[i].event_ptr;
>> +
>> +				if (op->status ==
>> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
>> +					if (op->sym->m_dst == NULL)
>> +						ev[i].event_ptr =
>> +							op->sym->m_src;
>> +					else
>> +						ev[i].event_ptr =
>> +							op->sym->m_dst;
>> +					rte_crypto_op_free(op);
>> +				} else {
>> +					rte_crypto_op_free(op);
>> +					continue;
>> +				}
>> +			}
>> +
>>  			if (enable_fwd_latency && !prod_timer_type) {
>>  				rte_prefetch0(ev[i+1].event_ptr);
>>  				/* first queue in pipeline.
>> @@ -269,6 +305,20 @@ perf_queue_eventdev_setup(struct evt_test *test,
>> struct evt_options *opt)
>>  				return ret;
>>  			}
>>  		}
>> +	} else if (opt->prod_type ==
>> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> +		uint8_t cdev_id, cdev_count;
>> +
>> +		cdev_count = rte_cryptodev_count();
>> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> +			ret = rte_cryptodev_start(cdev_id);
>> +			if (ret) {
>> +				evt_err("Failed to start cryptodev %u",
>> +					cdev_id);
>> +				return ret;
>> +			}
>> +		}
>> +
>> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
>>  	}
>>
>>  	return 0;
>> @@ -311,11 +361,13 @@ static const struct evt_test_ops perf_queue =  {
>>  	.test_setup         = perf_test_setup,
>>  	.mempool_setup      = perf_mempool_setup,
>>  	.ethdev_setup	    = perf_ethdev_setup,
>> +	.cryptodev_setup    = perf_cryptodev_setup,
>>  	.eventdev_setup     = perf_queue_eventdev_setup,
>>  	.launch_lcores      = perf_queue_launch_lcores,
>>  	.eventdev_destroy   = perf_eventdev_destroy,
>>  	.mempool_destroy    = perf_mempool_destroy,
>>  	.ethdev_destroy	    = perf_ethdev_destroy,
>> +	.cryptodev_destroy  = perf_cryptodev_destroy,
>>  	.test_result        = perf_test_result,
>>  	.test_destroy       = perf_test_destroy,
>>  };
>> diff --git a/doc/guides/tools/testeventdev.rst
>> b/doc/guides/tools/testeventdev.rst
>> index 48efb9ea6e..f7d813226d 100644
>> --- a/doc/guides/tools/testeventdev.rst
>> +++ b/doc/guides/tools/testeventdev.rst
>> @@ -120,6 +120,10 @@ The following are the application command-line
>> options:
>>
>>         Use burst mode event timer adapter as producer.
>>
>> +* ``--prod_type_cryptodev``
>> +
>> +        Use crypto device as producer.
>> +
>>  * ``--timer_tick_nsec``
>>
>>         Used to dictate number of nano seconds between bucket traversal of
>> the @@ -148,6 +152,11 @@ The following are the application command-line
>> options:
>>         timeout is out of the supported range of event device it will be
>>         adjusted to the highest/lowest supported dequeue timeout supported.
>>
>> +* ``--crypto_adptr_mode``
>> +
>> +        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
>> +        OP_FORWARD mode.
>> +
>>  * ``--mbuf_sz``
>>
>>         Set packet mbuf size. Can be used to configure Jumbo Frames. Only @@
>> -420,6 +429,7 @@ Supported application command line options are
>> following::
>>          --prod_type_ethdev
>>          --prod_type_timerdev_burst
>>          --prod_type_timerdev
>> +        --prod_type_cryptodev
>>          --prod_enq_burst_sz
>>          --timer_tick_nsec
>>          --max_tmo_nsec
>> @@ -427,6 +437,7 @@ Supported application command line options are
>> following::
>>          --nb_timers
>>          --nb_timer_adptrs
>>          --deq_tmo_nsec
>> +        --crypto_adptr_mode
>>
>>  Example
>>  ^^^^^^^
>> @@ -529,12 +540,14 @@ Supported application command line options are
>> following::
>>          --prod_type_ethdev
>>          --prod_type_timerdev_burst
>>          --prod_type_timerdev
>> +        --prod_type_cryptodev
>>          --timer_tick_nsec
>>          --max_tmo_nsec
>>          --expiry_nsec
>>          --nb_timers
>>          --nb_timer_adptrs
>>          --deq_tmo_nsec
>> +        --crypto_adptr_mode
>>
>>  Example
>>  ^^^^^^^
>> --
>> 2.25.1
Gujjar, Abhinandan S Jan. 25, 2022, 1:39 p.m. UTC | #6
Hi Shijith,

Some more comments.

> -----Original Message-----
> From: Gujjar, Abhinandan S
> Sent: Monday, January 24, 2022 12:14 AM
> To: Shijith Thotton <sthotton@marvell.com>; dev@dpdk.org;
> jerinj@marvell.com
> Cc: anoobj@marvell.com; pbhagavatula@marvell.com; gakhil@marvell.com
> Subject: RE: [PATCH v3] app/eventdev: add crypto producer mode
> 
> Hi Shijith,
> 
> Please find some comments inline.
> 
> > -----Original Message-----
> > From: Shijith Thotton <sthotton@marvell.com>
> > Sent: Tuesday, January 4, 2022 4:01 PM
> > To: dev@dpdk.org; jerinj@marvell.com
> > Cc: Shijith Thotton <sthotton@marvell.com>; anoobj@marvell.com;
> > pbhagavatula@marvell.com; gakhil@marvell.com; Gujjar, Abhinandan S
> > <abhinandan.gujjar@intel.com>
> > Subject: [PATCH v3] app/eventdev: add crypto producer mode
> >
> > In crypto producer mode, producer core enqueues cryptodev with
> > software generated crypto ops and worker core dequeues crypto
> > completion events from the eventdev. Event crypto metadata used for
> > above processing is pre- populated in each crypto session.
> >
> > Parameter --prod_type_cryptodev can be used to enable crypto producer
> > mode. Parameter --crypto_adptr_mode can be set to select the crypto
> > adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
> >
> > This mode can be used to measure the performance of crypto adapter.
> >
> > Example:
> >   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
> >   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
> >   --stlist=a --wlcores 1 --plcores 2
> >
> > Signed-off-by: Shijith Thotton <sthotton@marvell.com>
> > ---
> > v3:
> > * Reduce dereference inside loop.
> >
> > v2:
> > * Fix RHEL compilation warning.
> >
> >  app/test-eventdev/evt_common.h       |   3 +
> >  app/test-eventdev/evt_main.c         |  13 +-
> >  app/test-eventdev/evt_options.c      |  27 ++
> >  app/test-eventdev/evt_options.h      |  12 +
> >  app/test-eventdev/evt_test.h         |   6 +
> >  app/test-eventdev/test_perf_atq.c    |  51 ++++
> >  app/test-eventdev/test_perf_common.c | 410
> > ++++++++++++++++++++++++++-  app/test-
> > eventdev/test_perf_common.h |  16 ++  app/test-
> > eventdev/test_perf_queue.c  |  52 ++++
> >  doc/guides/tools/testeventdev.rst    |  13 +
> >  10 files changed, 596 insertions(+), 7 deletions(-)
> >
> > diff --git a/app/test-eventdev/evt_common.h b/app/test-
> > eventdev/evt_common.h index f466434459..2f301a7e79 100644
> > --- a/app/test-eventdev/evt_common.h
> > +++ b/app/test-eventdev/evt_common.h
> > @@ -7,6 +7,7 @@
> >
> >  #include <rte_common.h>
> >  #include <rte_debug.h>
> > +#include <rte_event_crypto_adapter.h>
> >  #include <rte_eventdev.h>
> >  #include <rte_service.h>
> >
> > @@ -39,6 +40,7 @@ enum evt_prod_type {
> >  	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
> >  	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter.
> > */
> >  	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer
> Adapter. */
> > +	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto
> > Adapter. */
> >  	EVT_PROD_TYPE_MAX,
> >  };
> >
> > @@ -77,6 +79,7 @@ struct evt_options {
> >  	uint64_t timer_tick_nsec;
> >  	uint64_t optm_timer_tick_nsec;
> >  	enum evt_prod_type prod_type;
> > +	enum rte_event_crypto_adapter_mode crypto_adptr_mode;
> >  };
> >
> >  static inline bool
> > diff --git a/app/test-eventdev/evt_main.c
> > b/app/test-eventdev/evt_main.c index 194c980c7a..cef0fb1382 100644
> > --- a/app/test-eventdev/evt_main.c
> > +++ b/app/test-eventdev/evt_main.c
> > @@ -161,12 +161,19 @@ main(int argc, char **argv)
> >  			goto mempool_destroy;
> >  		}
> >  	}
> New line required
> > +	/* Test specific cryptodev setup */
> > +	if (test->ops.cryptodev_setup) {
> > +		if (test->ops.cryptodev_setup(test, &opt)) {
> > +			evt_err("%s: cryptodev setup failed",
> > opt.test_name);
> > +			goto ethdev_destroy;
> > +		}
> > +	}
> >
> >  	/* Test specific eventdev setup */
> >  	if (test->ops.eventdev_setup) {
> >  		if (test->ops.eventdev_setup(test, &opt)) {
> >  			evt_err("%s: eventdev setup failed",
> opt.test_name);
> > -			goto ethdev_destroy;
> > +			goto cryptodev_destroy;
> >  		}
> >  	}
> >
> > @@ -197,6 +204,10 @@ main(int argc, char **argv)
> >  	if (test->ops.eventdev_destroy)
> >  		test->ops.eventdev_destroy(test, &opt);
> >
> > +cryptodev_destroy:
> > +	if (test->ops.cryptodev_destroy)
> > +		test->ops.cryptodev_destroy(test, &opt);
> > +
> >  ethdev_destroy:
> >  	if (test->ops.ethdev_destroy)
> >  		test->ops.ethdev_destroy(test, &opt); diff --git a/app/test-
> > eventdev/evt_options.c b/app/test-eventdev/evt_options.c index
> > 753a7dbd7d..5ad1491020 100644
> > --- a/app/test-eventdev/evt_options.c
> > +++ b/app/test-eventdev/evt_options.c
> > @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct
> > evt_options *opt,
> >  	return 0;
> >  }
> >
> > +static int
> > +evt_parse_crypto_prod_type(struct evt_options *opt,
> > +			   const char *arg __rte_unused)
> > +{
> > +	opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
> > +	return 0;
> > +}
> > +
> > +static int
> > +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg)
> {
> > +	uint8_t mode;
> > +	int ret;
> > +
> > +	ret = parser_read_uint8(&mode, arg);
> > +	opt->crypto_adptr_mode = mode ?
> > RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
> > +
> > 	RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
> > +	return ret;
> > +}
> > +
> >  static int
> >  evt_parse_test_name(struct evt_options *opt, const char *arg)  { @@ -
> > 335,6 +355,7 @@ usage(char *program)
> >  		"\t--queue_priority   : enable queue priority\n"
> >  		"\t--deq_tmo_nsec     : global dequeue timeout\n"
> >  		"\t--prod_type_ethdev : use ethernet device as
> producer.\n"
> > +		"\t--prod_type_cryptodev : use crypto device as
> > producer.\n"
> >  		"\t--prod_type_timerdev : use event timer device as
> producer.\n"
> >  		"\t                     expity_nsec would be the timeout\n"
> >  		"\t                     in ns.\n"
> > @@ -345,6 +366,8 @@ usage(char *program)
> >  		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
> >  		"\t--max_tmo_nsec     : max timeout interval in ns.\n"
> >  		"\t--expiry_nsec      : event timer expiry ns.\n"
> > +		"\t--crypto_adptr_mode : 0 for OP_NEW mode (default)
> > and\n"
> > +		"\t                      1 for OP_FORWARD mode.\n"
> >  		"\t--mbuf_sz          : packet mbuf size.\n"
> >  		"\t--max_pkt_sz       : max packet size.\n"
> >  		"\t--prod_enq_burst_sz : producer enqueue burst size.\n"
> > @@ -415,8 +438,10 @@ static struct option lgopts[] = {
> >  	{ EVT_QUEUE_PRIORITY,      0, 0, 0 },
> >  	{ EVT_DEQ_TMO_NSEC,        1, 0, 0 },
> >  	{ EVT_PROD_ETHDEV,         0, 0, 0 },
> > +	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
> >  	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
> >  	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
> > +	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
> >  	{ EVT_NB_TIMERS,           1, 0, 0 },
> >  	{ EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
> >  	{ EVT_TIMER_TICK_NSEC,     1, 0, 0 },
> > @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct
> > evt_options
> > *opt)
> >  		{ EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
> >  		{ EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
> >  		{ EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
> > +		{ EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
> >  		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
> >  		{ EVT_PROD_TIMERDEV_BURST,
> > evt_parse_timer_prod_type_burst},
> > +		{ EVT_CRYPTO_ADPTR_MODE,
> > evt_parse_crypto_adptr_mode},
> >  		{ EVT_NB_TIMERS, evt_parse_nb_timers},
> >  		{ EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
> >  		{ EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec}, diff --
> git
> > a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
> > index 413d7092f0..2231c58801 100644
> > --- a/app/test-eventdev/evt_options.h
> > +++ b/app/test-eventdev/evt_options.h
> > @@ -9,6 +9,7 @@
> >  #include <stdbool.h>
> >
> >  #include <rte_common.h>
> > +#include <rte_cryptodev.h>
> >  #include <rte_ethdev.h>
> >  #include <rte_eventdev.h>
> >  #include <rte_lcore.h>
> > @@ -33,8 +34,10 @@
> >  #define EVT_QUEUE_PRIORITY       ("queue_priority")
> >  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
> >  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
> > +#define EVT_PROD_CRYPTODEV	 ("prod_type_cryptodev")
> >  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
> >  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
> > +#define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
> >  #define EVT_NB_TIMERS            ("nb_timers")
> >  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
> >  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
> > @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type
> > prod_type)
> >  		return "Ethdev Rx Adapter";
> >  	case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
> >  		return "Event timer adapter";
> > +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> > +		return "Event crypto adapter";
> >  	}
> >
> >  	return "";
> > @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options
> *opt)
> >  			evt_dump("timer_tick_nsec", "%"PRIu64"",
> >  					opt->timer_tick_nsec);
> >  		break;
> > +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> > +		snprintf(name, EVT_PROD_MAX_NAME_LEN,
> > +			 "Event crypto adapter producers");
> > +		evt_dump("crypto adapter mode", "%s",
> > +			 opt->crypto_adptr_mode ? "OP_FORWARD" :
> > "OP_NEW");
> > +		evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
> > +		break;
> >  	}
> >  	evt_dump("prod_type", "%s", name);
> >  }
> > diff --git a/app/test-eventdev/evt_test.h
> > b/app/test-eventdev/evt_test.h index f07d2c3336..50fa474ec2 100644
> > --- a/app/test-eventdev/evt_test.h
> > +++ b/app/test-eventdev/evt_test.h
> > @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
> >  		(struct evt_test *test, struct evt_options *opt);  typedef int
> > (*evt_test_ethdev_setup_t)
> >  		(struct evt_test *test, struct evt_options *opt);
> > +typedef int (*evt_test_cryptodev_setup_t)
> > +		(struct evt_test *test, struct evt_options *opt);
> >  typedef int (*evt_test_eventdev_setup_t)
> >  		(struct evt_test *test, struct evt_options *opt);  typedef int
> > (*evt_test_launch_lcores_t) @@ -39,6 +41,8 @@ typedef void
> > (*evt_test_eventdev_destroy_t)
> >  		(struct evt_test *test, struct evt_options *opt);  typedef void
> > (*evt_test_ethdev_destroy_t)
> >  		(struct evt_test *test, struct evt_options *opt);
> > +typedef void (*evt_test_cryptodev_destroy_t)
> > +		(struct evt_test *test, struct evt_options *opt);
> >  typedef void (*evt_test_mempool_destroy_t)
> >  		(struct evt_test *test, struct evt_options *opt);  typedef void
> > (*evt_test_destroy_t) @@ -52,10 +56,12 @@ struct evt_test_ops {
> >  	evt_test_mempool_setup_t mempool_setup;
> >  	evt_test_ethdev_setup_t ethdev_setup;
> >  	evt_test_eventdev_setup_t eventdev_setup;
> > +	evt_test_cryptodev_setup_t cryptodev_setup;
> >  	evt_test_launch_lcores_t launch_lcores;
> >  	evt_test_result_t test_result;
> >  	evt_test_eventdev_destroy_t eventdev_destroy;
> >  	evt_test_ethdev_destroy_t ethdev_destroy;
> > +	evt_test_cryptodev_destroy_t cryptodev_destroy;
> >  	evt_test_mempool_destroy_t mempool_destroy;
> >  	evt_test_destroy_t test_destroy;
> >  };
> > diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-
> > eventdev/test_perf_atq.c index 8fd51004ee..dbb1dc8c0c 100644
> > --- a/app/test-eventdev/test_perf_atq.c
> > +++ b/app/test-eventdev/test_perf_atq.c
> > @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int
> > enable_fwd_latency)
> >  			continue;
> >  		}
> >
> > +		if (prod_crypto_type &&
> > +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> > +			struct rte_crypto_op *op = ev.event_ptr;
> > +
> > +			if (op->status ==
> > RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +				if (op->sym->m_dst == NULL)
> > +					ev.event_ptr = op->sym->m_src;
> > +				else
> > +					ev.event_ptr = op->sym->m_dst;
> > +				rte_crypto_op_free(op);
> > +			} else {
> > +				rte_crypto_op_free(op);
> > +				continue;
> > +			}
> > +		}
> > +
> >  		if (enable_fwd_latency && !prod_timer_type)
> >  		/* first stage in pipeline, mark ts to compute fwd latency */
> >  			atq_mark_fwd_latency(&ev);
> > @@ -87,6 +103,25 @@ perf_atq_worker_burst(void *arg, const int
> > enable_fwd_latency)
> >  		}
> >
> >  		for (i = 0; i < nb_rx; i++) {
> > +			if (prod_crypto_type &&
> > +			    (ev[i].event_type ==
> > RTE_EVENT_TYPE_CRYPTODEV)) {
> > +				struct rte_crypto_op *op = ev[i].event_ptr;
> > +
> > +				if (op->status ==
> > +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +					if (op->sym->m_dst == NULL)
> > +						ev[i].event_ptr =
> > +							op->sym->m_src;
> > +					else
> > +						ev[i].event_ptr =
> > +							op->sym->m_dst;
> > +					rte_crypto_op_free(op);
> > +				} else {
> > +					rte_crypto_op_free(op);
> > +					continue;
> > +				}
> > +			}
> > +
> >  			if (enable_fwd_latency && !prod_timer_type) {
> >  				rte_prefetch0(ev[i+1].event_ptr);
> >  				/* first stage in pipeline.
> > @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test,
> > struct evt_options *opt)
> >  				return ret;
> >  			}
> >  		}
> > +	} else if (opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> > +		uint8_t cdev_id, cdev_count;
> > +
> > +		cdev_count = rte_cryptodev_count();
> > +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +			ret = rte_cryptodev_start(cdev_id);
> > +			if (ret) {
> > +				evt_err("Failed to start cryptodev %u",
> > +					cdev_id);
> > +				return ret;
> > +			}
> > +		}
> > +
> > +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
> >  	}
> >
> >  	return 0;
> > @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
> >  	.opt_dump           = perf_atq_opt_dump,
> >  	.test_setup         = perf_test_setup,
> >  	.ethdev_setup       = perf_ethdev_setup,
> > +	.cryptodev_setup    = perf_cryptodev_setup,
> >  	.mempool_setup      = perf_mempool_setup,
> >  	.eventdev_setup     = perf_atq_eventdev_setup,
> >  	.launch_lcores      = perf_atq_launch_lcores,
> >  	.eventdev_destroy   = perf_eventdev_destroy,
> >  	.mempool_destroy    = perf_mempool_destroy,
> >  	.ethdev_destroy     = perf_ethdev_destroy,
> > +	.cryptodev_destroy  = perf_cryptodev_destroy,
> >  	.test_result        = perf_test_result,
> >  	.test_destroy       = perf_test_destroy,
> >  };
> > diff --git a/app/test-eventdev/test_perf_common.c b/app/test-
> > eventdev/test_perf_common.c index 9b73874151..91cb6748ee 100644
> > --- a/app/test-eventdev/test_perf_common.c
> > +++ b/app/test-eventdev/test_perf_common.c
> > @@ -6,6 +6,8 @@
> >
> >  #include "test_perf_common.h"
> >
> > +#define NB_CRYPTODEV_DESCRIPTORS 128
> > +
> >  int
> >  perf_test_result(struct evt_test *test, struct evt_options *opt)  {
> > @@ -272,6
> > +274,125 @@ perf_event_timer_producer_burst(void *arg)
> >  	return 0;
> >  }
> >
> > +static inline void
> > +crypto_adapter_enq_op_new(struct prod_data *p) {
> > +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> > +	struct test_perf *t = p->t;
> > +	const uint32_t nb_flows = t->nb_flows;
> > +	const uint64_t nb_pkts = t->nb_pkts;
> > +	struct rte_mempool *pool = t->pool;
> > +	struct rte_crypto_sym_op *sym_op;
> > +	struct evt_options *opt = t->opt;
> > +	uint16_t qp_id = p->cdev_qp_id;
> > +	uint8_t cdev_id = p->cdev_id;
> > +	uint32_t flow_counter = 0;
> > +	struct rte_crypto_op *op;
> > +	struct rte_mbuf *m;
> > +	uint64_t count = 0;
> > +	uint16_t len;
> > +
> > +	if (opt->verbose_level > 1)
> > +		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id
> > %u\n",
> > +		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
> > +		       p->cdev_qp_id);
> > +
> > +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> > +
> > +	while (count < nb_pkts && t->done == false) {
> > +		m = rte_pktmbuf_alloc(pool);
> > +		if (m == NULL)
> > +			continue;
> > +
> > +		rte_pktmbuf_append(m, len);
> > +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
NULL check for op is missing
> > +
> > RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> > +		sym_op = op->sym;
> > +		sym_op->m_src = m;
> > +		sym_op->cipher.data.offset = 0;
> > +		sym_op->cipher.data.length = len;
> > +		rte_crypto_op_attach_sym_session(
> > +			op, crypto_sess[flow_counter++ % nb_flows]);
> > +		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op,
> > 1) !=
> > +		       1) {
> > +			if (t->done)
> > +				break;
> > +			rte_pause();
> > +		}
> > +		count++;
> > +	}
> > +}
> > +
> > +static inline void
> > +crypto_adapter_enq_op_fwd(struct prod_data *p) {
> > +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> > +	const uint8_t dev_id = p->dev_id;
> > +	const uint8_t port = p->port_id;
> > +	struct test_perf *t = p->t;
> > +	const uint32_t nb_flows = t->nb_flows;
> > +	const uint64_t nb_pkts = t->nb_pkts;
> > +	struct rte_mempool *pool = t->pool;
> > +	struct evt_options *opt = t->opt;
> > +	struct rte_crypto_sym_op *sym_op;
> > +	uint32_t flow_counter = 0;
> > +	struct rte_crypto_op *op;
> > +	struct rte_event ev;
> > +	struct rte_mbuf *m;
> > +	uint64_t count = 0;
> > +	uint16_t len;
> > +
> > +	if (opt->verbose_level > 1)
> > +		printf("%s(): lcore %d port %d queue %d cdev_id %u
> > cdev_qp_id %u\n",
> > +		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
> > +		       p->cdev_qp_id);
> > +
> > +	ev.event = 0;
> > +	ev.op = RTE_EVENT_OP_NEW;
So, this is an new event and adapter treats it as OP_FWD?
> > +	ev.queue_id = p->queue_id;
> > +	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
> > +	ev.event_type = RTE_EVENT_TYPE_CPU;
> > +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> > +
> > +	while (count < nb_pkts && t->done == false) {
> > +		m = rte_pktmbuf_alloc(pool);
> > +		if (m == NULL)
> > +			continue;
> > +
> > +		rte_pktmbuf_append(m, len);
> > +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> > +
> > RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> > +		sym_op = op->sym;
> > +		sym_op->m_src = m;
> > +		sym_op->cipher.data.offset = 0;
> > +		sym_op->cipher.data.length = len;
> > +		rte_crypto_op_attach_sym_session(
> > +			op, crypto_sess[flow_counter++ % nb_flows]);
> > +		ev.event_ptr = op;
> > +		while (rte_event_crypto_adapter_enqueue(dev_id, port,
> > &ev, 1) !=
> > +		       1) {
If the adapter OP_FWD is supported by rte_event_enqueue_burst(), then even that path has to be tested. Please add it.
> > +			if (t->done)
> > +				break;
> > +			rte_pause();
> > +		}
> > +		count++;
> > +	}
> > +}
> > +
> > +static inline int
> > +perf_event_crypto_producer(void *arg) {
> > +	struct prod_data *p = arg;
> > +	struct evt_options *opt = p->t->opt;
> > +
> > +	if (opt->crypto_adptr_mode ==
> > RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
> > +		crypto_adapter_enq_op_new(p);
> > +	else
> > +		crypto_adapter_enq_op_fwd(p);
> > +
> > +	return 0;
> > +}
> > +
> >  static int
> >  perf_producer_wrapper(void *arg)
> >  {
> > @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
> >  	else if (t->opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
> >  			t->opt->timdev_use_burst)
> >  		return perf_event_timer_producer_burst(arg);
> > +	else if (t->opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> > +		return perf_event_crypto_producer(arg);
> >  	return 0;
> >  }
> >
> > @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
> > evt_options *opt,
> >  			if (remaining <= 0) {
> >  				t->result = EVT_TEST_SUCCESS;
> >  				if (opt->prod_type ==
> > EVT_PROD_TYPE_SYNT ||
> > -					opt->prod_type ==
> > -
> > 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> > +				    opt->prod_type ==
> > +
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> > +				    opt->prod_type ==
> > +
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >  					t->done = true;
> >  					break;
> >  				}
> > @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
> > evt_options *opt,
> >
> >  		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
> >  		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -		     opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
> > +		     opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> > +		     opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
> >  			remaining = t->outstand_pkts - processed_pkts(t);
> >  			if (dead_lock_remaining == remaining) {
> >  				rte_event_dev_dump(opt->dev_id, stdout);
> @@ -537,6 +663,96 @@
> > perf_event_timer_adapter_setup(struct test_perf
> > *t)
> >  	return 0;
> >  }
> >
> > +static int
> > +perf_event_crypto_adapter_setup(struct test_perf *t,
> > +				struct rte_event_port_conf port_conf) {
> > +	struct evt_options *opt = t->opt;
> > +	uint8_t cdev_id, cdev_count;
> > +	int ret;
> > +
> > +	t->crypto_adptr.id = 0;
> > +	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
> > >dev_id,
> > +					      &port_conf, 0);
> > +	if (ret)
> > +		return ret;
> > +
> > +	cdev_count = rte_cryptodev_count();
> > +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +		uint32_t cap;
> > +
> > +		ret = rte_event_crypto_adapter_caps_get(opt->dev_id,
> > cdev_id,
> > +							&cap);
> > +		if (ret) {
> > +			evt_err("Failed to get crypto adapter capabilities");
> > +			return ret;
> > +		}
> > +
> > +		if (((opt->crypto_adptr_mode ==
> > +		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
> > +		     !(cap &
> > +
> > RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
> > +		    ((opt->crypto_adptr_mode ==
> > +		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
> > +		     !(cap &
> > +
> > RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
> > +			evt_err("crypto adapter %s mode unsupported\n",
> > +				opt->crypto_adptr_mode ? "OP_FORWARD"
> > :
> > +							 "OP_NEW");
> > +			return -EINVAL;
> > +		}
> > +
> > +		if (!(cap &
> > +
> > RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
> > +			evt_err("Storing crypto session not supported");
> > +			return -EINVAL;
> > +		}
> > +
> > +		if (cap &
> > +
> > RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
> > +			struct rte_event response_info;
> > +
> > +			response_info.event = 0;
It is good that you are covering even this case. Should not you fill event with valid values?
> > +			ret = rte_event_crypto_adapter_queue_pair_add(
> > +				t->crypto_adptr.id, cdev_id, -1,
> > +				&response_info);
> > +		} else {
> > +			ret = rte_event_crypto_adapter_queue_pair_add(
> > +				t->crypto_adptr.id, cdev_id, -1, NULL);
> > +		}
New line
> > +		if (ret)
> > +			return ret;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static struct rte_cryptodev_sym_session *
> > +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
> > +	struct rte_crypto_sym_xform cipher_xform;
> > +	struct rte_cryptodev_sym_session *sess;
> > +
> > +	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
> > +	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
> > +	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
> > +	cipher_xform.next = NULL;
> > +
> > +	sess = rte_cryptodev_sym_session_create(t-
> > >crypto_adptr.sess_pool);
> > +	if (sess == NULL) {
> > +		evt_err("Failed to create sym session");
> > +		return NULL;
> > +	}
> > +
> > +	if (rte_cryptodev_sym_session_init(p->cdev_id, sess,
> > &cipher_xform,
> > +					   t->crypto_adptr.sess_priv_pool)) {
> > +		evt_err("Failed to init session");
> > +		return NULL;
> > +	}
> > +
> > +	return sess;
> > +}
> > +
> >  int
> >  perf_event_dev_port_setup(struct evt_test *test, struct evt_options
> *opt,
> >  				uint8_t stride, uint8_t nb_queues, @@ -
> 598,6 +814,55 @@
> > perf_event_dev_port_setup(struct evt_test *test, struct evt_options
> > *opt,
> >  		ret = perf_event_timer_adapter_setup(t);
> >  		if (ret)
> >  			return ret;
> > +	} else if (opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> > +		uint8_t cdev_id = 0;
> > +		uint16_t qp_id = 0;
> > +
> > +		prod = 0;
> > +		for (; port < perf_nb_event_ports(opt); port++) {
> > +			struct rte_cryptodev_sym_session *crypto_sess;
> > +			union rte_event_crypto_metadata m_data;
> > +			struct prod_data *p = &t->prod[port];
> > +			uint32_t flow_id;
> > +
> > +			if (qp_id ==
> > rte_cryptodev_queue_pair_count(cdev_id)) {
> > +				cdev_id++;
> > +				qp_id = 0;
> > +			}
> > +
> > +			p->dev_id = opt->dev_id;
> > +			p->port_id = port;
> > +			p->queue_id = prod * stride;
> > +			p->cdev_id = cdev_id;
> > +			p->cdev_qp_id = qp_id;
> > +			p->crypto_sess = rte_zmalloc_socket(
> > +				NULL, sizeof(crypto_sess) * t->nb_flows,
> > +				RTE_CACHE_LINE_SIZE, opt->socket_id);
> > +
> > +			m_data.request_info.cdev_id = p->cdev_id;
> > +			m_data.request_info.queue_pair_id = p-
> > >cdev_qp_id;
> > +			m_data.response_info.op = RTE_EVENT_OP_NEW;
> > +			m_data.response_info.sched_type =
> > RTE_SCHED_TYPE_ATOMIC;
> > +			m_data.response_info.event_type =
> > RTE_EVENT_TYPE_CPU;
> > +			m_data.response_info.queue_id = p->queue_id;
> > +			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
> > +				crypto_sess =
> > cryptodev_sym_sess_create(p, t);
> > +				if (crypto_sess == NULL)
> > +					return -ENOMEM;
> > +
> > +				m_data.response_info.flow_id = flow_id;
> > +				rte_cryptodev_sym_session_set_user_data(
> > +					crypto_sess, &m_data,
> > sizeof(m_data));
> > +				p->crypto_sess[flow_id] = crypto_sess;
> > +			}
New line
> > +			p->t = t;
> > +			qp_id++;
> > +			prod++;
> > +		}
> > +
> > +		ret = perf_event_crypto_adapter_setup(t, *port_conf);
> > +		if (ret)
> > +			return ret;
> >  	} else {
> >  		prod = 0;
> >  		for ( ; port < perf_nb_event_ports(opt); port++) { @@ -659,7
> > +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
> >  	}
> >
> >  	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -			opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> > +	    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> > +	    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >  		/* Validate producer lcores */
> >  		if (evt_lcores_has_overlap(opt->plcores,
> >  					rte_get_main_lcore())) {
> > @@ -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct
> > evt_options *opt)
> >  		},
> >  	};
> >
> > -	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> > -			opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
> > +	if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
> >  		return 0;
> >
> >  	if (!rte_eth_dev_count_avail()) {
> > @@ -841,6 +1106,139 @@ void perf_ethdev_destroy(struct evt_test *test,
> > struct evt_options *opt)
> >  	}
> >  }
> >
> > +int
> > +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt) {
> > +	uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
> > +	struct test_perf *t = evt_test_priv(test);
> > +	unsigned int max_session_size;
> > +	uint32_t nb_sessions;
> > +	int ret;
> > +
> > +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> > +		return 0;
> How do you differentiate between this failed case as you are returning 0 in
> case of success?
> 
> > +
> > +	cdev_count = rte_cryptodev_count();
> > +	if (cdev_count == 0) {
> > +		evt_err("No crypto devices available\n");
> > +		return -ENODEV;
> > +	}
> > +
> > +	t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
> > +		"crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt-
> > >pool_sz,
> > +		128, 0, rte_socket_id());
> > +	if (t->crypto_adptr.op_pool == NULL) {
> > +		evt_err("Failed to create crypto op pool");
> > +		return -ENOMEM;
> > +	}
> > +
> > +	nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
> > +	t->crypto_adptr.sess_pool =
> > rte_cryptodev_sym_session_pool_create(
> > +		"ca_sess_pool", nb_sessions, 0, 0,
> > +		sizeof(union rte_event_crypto_metadata),
> > SOCKET_ID_ANY);
> > +	if (t->crypto_adptr.sess_pool == NULL) {
> > +		evt_err("Failed to create sym session pool");
> > +		ret = -ENOMEM;
> > +		goto err;
> > +	}
> > +
> > +	max_session_size = 0;
> > +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +		unsigned int session_size;
> > +
> > +		session_size =
> > +
> > 	rte_cryptodev_sym_get_private_session_size(cdev_id);
> > +		if (session_size > max_session_size)
> > +			max_session_size = session_size;
> > +	}
> New line required
> > +	max_session_size += sizeof(union rte_event_crypto_metadata);
> > +	t->crypto_adptr.sess_priv_pool = rte_mempool_create(
> > +		"ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0,
> > NULL,
> > +		NULL, NULL, NULL, SOCKET_ID_ANY, 0);
> > +	if (t->crypto_adptr.sess_priv_pool == NULL) {
> > +		evt_err("failed to create sym session private pool");
> > +		ret = -ENOMEM;
> > +		goto err;
> > +	}
> > +
> > +	nb_plcores = evt_nr_active_lcores(opt->plcores);
> > +	nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) +
> > 1 :
> > +					     nb_plcores / cdev_count;
> Let's take an example:
> Cdev1 -> 8 qps
> Cdev2 -> 2 qps
> Cdev_count = 2
> nb_plcores = 7
> As per above statement, nb_qps = ( 7 % 2 ) 7/2 + 1 = 4 qps So, this fails to
> setup qps for cdev2 as it supports only 2 qps and test exits! Am I missing
> anything?
> 
> > +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +		struct rte_cryptodev_qp_conf qp_conf;
> > +		struct rte_cryptodev_config conf;
> > +		struct rte_cryptodev_info info;
> > +		int qp_id;
> > +
> > +		rte_cryptodev_info_get(cdev_id, &info);
> > +		if (nb_qps > info.max_nb_queue_pairs) {
> > +			evt_err("Not enough queue pairs per cryptodev
> > (%u)",
> > +				nb_qps);
> > +			ret = -EINVAL;
> > +			goto err;
> > +		}
> > +
> > +		conf.nb_queue_pairs = nb_qps;
> > +		conf.socket_id = SOCKET_ID_ANY;
> > +		conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
> > +
> > +		ret = rte_cryptodev_configure(cdev_id, &conf);
> > +		if (ret) {
> > +			evt_err("Failed to configure cryptodev (%u)",
> > cdev_id);
> > +			goto err;
> > +		}
> > +
> > +		qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
> > +		qp_conf.mp_session = t->crypto_adptr.sess_pool;
> > +		qp_conf.mp_session_private = t-
> > >crypto_adptr.sess_priv_pool;
> > +
> > +		for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
> > +			ret = rte_cryptodev_queue_pair_setup(
> > +				cdev_id, qp_id, &qp_conf,
> > +				rte_cryptodev_socket_id(cdev_id));
> > +			if (ret) {
> > +				evt_err("Failed to setup queue pairs on
> > cryptodev %u\n",
> > +					cdev_id);
> > +				goto err;
> > +			}
> > +		}
> > +	}
> > +
> > +	return 0;
> > +err:
> > +	rte_mempool_free(t->crypto_adptr.op_pool);
> > +	rte_mempool_free(t->crypto_adptr.sess_pool);
> > +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> > +
> > +	return ret;
> > +}
> > +
> > +void
> > +perf_cryptodev_destroy(struct evt_test *test, struct evt_options
> > +*opt) {
> > +	uint8_t cdev_id, cdev_count = rte_cryptodev_count();
> > +	struct test_perf *t = evt_test_priv(test);
> > +
> > +	RTE_SET_USED(opt);
> > +
> > +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> > +		return;
> > +
> > +	rte_event_crypto_adapter_stop(t->crypto_adptr.id);
> > +
> > +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +		rte_cryptodev_stop(cdev_id);
> > +		rte_event_crypto_adapter_queue_pair_del(t-
> > >crypto_adptr.id,
> > +							cdev_id, -1);
> Any reason for passing -1? This can not ensure to cleanup all the
> preconfigured qps as per API.
> > +	}
> > +
> > +	rte_event_crypto_adapter_free(t->crypto_adptr.id);
> > +
> > +	rte_mempool_free(t->crypto_adptr.op_pool);
> > +	rte_mempool_free(t->crypto_adptr.sess_pool);
> > +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> > +}
> > +
> >  int
> >  perf_mempool_setup(struct evt_test *test, struct evt_options *opt)  {
> > diff - -git a/app/test-eventdev/test_perf_common.h b/app/test-
> > eventdev/test_perf_common.h index 14dcf80429..d9ad3a0b0d 100644
> > --- a/app/test-eventdev/test_perf_common.h
> > +++ b/app/test-eventdev/test_perf_common.h
> > @@ -9,9 +9,11 @@
> >  #include <stdbool.h>
> >  #include <unistd.h>
> >
> > +#include <rte_cryptodev.h>
> >  #include <rte_cycles.h>
> >  #include <rte_ethdev.h>
> >  #include <rte_eventdev.h>
> > +#include <rte_event_crypto_adapter.h>
> >  #include <rte_event_eth_rx_adapter.h>  #include
> > <rte_event_timer_adapter.h>  #include <rte_lcore.h> @@ -37,9 +39,18
> @@
> > struct prod_data {
> >  	uint8_t dev_id;
> >  	uint8_t port_id;
> >  	uint8_t queue_id;
> > +	uint8_t cdev_id;
> > +	uint16_t cdev_qp_id;
> > +	struct rte_cryptodev_sym_session **crypto_sess;
> >  	struct test_perf *t;
> >  } __rte_cache_aligned;
> >
> > +struct crypto_adptr_data {
> > +	uint8_t id;
> > +	struct rte_mempool *op_pool;
> > +	struct rte_mempool *sess_pool;
> > +	struct rte_mempool *sess_priv_pool;
> > +};
> >
> >  struct test_perf {
> >  	/* Don't change the offset of "done". Signal handler use this memory
> > @@ -58,6 +69,7 @@ struct test_perf {
> >  	uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
> >  	struct rte_event_timer_adapter *timer_adptr[
> >  		RTE_EVENT_TIMER_ADAPTER_NUM_MAX]
> > __rte_cache_aligned;
> > +	struct crypto_adptr_data crypto_adptr;
> >  } __rte_cache_aligned;
> >
> >  struct perf_elt {
> > @@ -81,6 +93,8 @@ struct perf_elt {
> >  	const uint8_t port = w->port_id;\
> >  	const uint8_t prod_timer_type = \
> >  		opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
> > +	const uint8_t prod_crypto_type = \
> > +		opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
> >  	uint8_t *const sched_type_list = &t->sched_type_list[0];\
> >  	struct rte_mempool *const pool = t->pool;\
> >  	const uint8_t nb_stages = t->opt->nb_stages;\ @@ -154,6 +168,7
> @@
> > int perf_test_result(struct evt_test *test, struct evt_options *opt);
> > int perf_opt_check(struct evt_options *opt, uint64_t nb_queues);  int
> > perf_test_setup(struct evt_test *test, struct evt_options *opt);  int
> > perf_ethdev_setup(struct evt_test *test, struct evt_options *opt);
> > +int perf_cryptodev_setup(struct evt_test *test, struct evt_options
> > +*opt);
> >  int perf_mempool_setup(struct evt_test *test, struct evt_options
> > *opt);  int perf_event_dev_port_setup(struct evt_test *test, struct
> evt_options *opt,
> >  				uint8_t stride, uint8_t nb_queues, @@ -
> 164,6 +179,7 @@ int
> > perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
> > void perf_opt_dump(struct evt_options *opt, uint8_t nb_queues);  void
> > perf_test_destroy(struct evt_test *test, struct evt_options *opt);
> > void perf_eventdev_destroy(struct evt_test *test, struct evt_options
> > *opt);
> > +void perf_cryptodev_destroy(struct evt_test *test, struct evt_options
> > +*opt);
> >  void perf_ethdev_destroy(struct evt_test *test, struct evt_options
> > *opt); void perf_mempool_destroy(struct evt_test *test, struct
> > evt_options *opt);
> >
> > diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-
> > eventdev/test_perf_queue.c index f4ea3a795f..5657c8b3cd 100644
> > --- a/app/test-eventdev/test_perf_queue.c
> > +++ b/app/test-eventdev/test_perf_queue.c
> > @@ -49,6 +49,23 @@ perf_queue_worker(void *arg, const int
> > enable_fwd_latency)
> >  			rte_pause();
> >  			continue;
> >  		}
> > +
> > +		if (prod_crypto_type &&
> > +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> > +			struct rte_crypto_op *op = ev.event_ptr;
> > +
> > +			if (op->status ==
> > RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +				if (op->sym->m_dst == NULL)
> > +					ev.event_ptr = op->sym->m_src;
> > +				else
> > +					ev.event_ptr = op->sym->m_dst;
> > +				rte_crypto_op_free(op);
> > +			} else {
> > +				rte_crypto_op_free(op);
> > +				continue;
> In case of failure, ops are freed and "ev.event_ptr" won't be set to mbuf.
> What would be the expected test result?
> > +			}
> > +		}
> > +
> >  		if (enable_fwd_latency && !prod_timer_type)
> >  		/* first q in pipeline, mark timestamp to compute fwd latency
> */
> >  			mark_fwd_latency(&ev, nb_stages);
> > @@ -88,6 +105,25 @@ perf_queue_worker_burst(void *arg, const int
> > enable_fwd_latency)
> >  		}
> >
> >  		for (i = 0; i < nb_rx; i++) {
> > +			if (prod_crypto_type &&
> > +			    (ev[i].event_type ==
> > RTE_EVENT_TYPE_CRYPTODEV)) {
> > +				struct rte_crypto_op *op = ev[i].event_ptr;
> > +
> > +				if (op->status ==
> > +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
> > +					if (op->sym->m_dst == NULL)
> > +						ev[i].event_ptr =
> > +							op->sym->m_src;
> > +					else
> > +						ev[i].event_ptr =
> > +							op->sym->m_dst;
> > +					rte_crypto_op_free(op);
> > +				} else {
> > +					rte_crypto_op_free(op);
> > +					continue;
> > +				}
> > +			}
> > +
> >  			if (enable_fwd_latency && !prod_timer_type) {
> >  				rte_prefetch0(ev[i+1].event_ptr);
> >  				/* first queue in pipeline.
> > @@ -269,6 +305,20 @@ perf_queue_eventdev_setup(struct evt_test
> *test,
> > struct evt_options *opt)
> >  				return ret;
> >  			}
> >  		}
> > +	} else if (opt->prod_type ==
> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> > +		uint8_t cdev_id, cdev_count;
> > +
> > +		cdev_count = rte_cryptodev_count();
> > +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> > +			ret = rte_cryptodev_start(cdev_id);
> > +			if (ret) {
> > +				evt_err("Failed to start cryptodev %u",
> > +					cdev_id);
> > +				return ret;
> > +			}
> > +		}
> > +
> > +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
> >  	}
> >
> >  	return 0;
> > @@ -311,11 +361,13 @@ static const struct evt_test_ops perf_queue =  {
> >  	.test_setup         = perf_test_setup,
> >  	.mempool_setup      = perf_mempool_setup,
> >  	.ethdev_setup	    = perf_ethdev_setup,
> > +	.cryptodev_setup    = perf_cryptodev_setup,
> >  	.eventdev_setup     = perf_queue_eventdev_setup,
> >  	.launch_lcores      = perf_queue_launch_lcores,
> >  	.eventdev_destroy   = perf_eventdev_destroy,
> >  	.mempool_destroy    = perf_mempool_destroy,
> >  	.ethdev_destroy	    = perf_ethdev_destroy,
> > +	.cryptodev_destroy  = perf_cryptodev_destroy,
> >  	.test_result        = perf_test_result,
> >  	.test_destroy       = perf_test_destroy,
> >  };
> > diff --git a/doc/guides/tools/testeventdev.rst
> > b/doc/guides/tools/testeventdev.rst
> > index 48efb9ea6e..f7d813226d 100644
> > --- a/doc/guides/tools/testeventdev.rst
> > +++ b/doc/guides/tools/testeventdev.rst
> > @@ -120,6 +120,10 @@ The following are the application command-line
> > options:
> >
> >         Use burst mode event timer adapter as producer.
> >
> > +* ``--prod_type_cryptodev``
> > +
> > +        Use crypto device as producer.
> > +
> >  * ``--timer_tick_nsec``
> >
> >         Used to dictate number of nano seconds between bucket
> > traversal of the @@ -148,6 +152,11 @@ The following are the
> > application command-line
> > options:
> >         timeout is out of the supported range of event device it will be
> >         adjusted to the highest/lowest supported dequeue timeout
> supported.
> >
> > +* ``--crypto_adptr_mode``
> > +
> > +        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
> > +        OP_FORWARD mode.
> > +
> >  * ``--mbuf_sz``
> >
> >         Set packet mbuf size. Can be used to configure Jumbo Frames.
> > Only @@
> > -420,6 +429,7 @@ Supported application command line options are
> > following::
> >          --prod_type_ethdev
> >          --prod_type_timerdev_burst
> >          --prod_type_timerdev
> > +        --prod_type_cryptodev
> >          --prod_enq_burst_sz
> >          --timer_tick_nsec
> >          --max_tmo_nsec
> > @@ -427,6 +437,7 @@ Supported application command line options are
> > following::
> >          --nb_timers
> >          --nb_timer_adptrs
> >          --deq_tmo_nsec
> > +        --crypto_adptr_mode
> >
> >  Example
> >  ^^^^^^^
> > @@ -529,12 +540,14 @@ Supported application command line options are
> > following::
> >          --prod_type_ethdev
> >          --prod_type_timerdev_burst
> >          --prod_type_timerdev
> > +        --prod_type_cryptodev
> >          --timer_tick_nsec
> >          --max_tmo_nsec
> >          --expiry_nsec
> >          --nb_timers
> >          --nb_timer_adptrs
> >          --deq_tmo_nsec
> > +        --crypto_adptr_mode
> >
> >  Example
> >  ^^^^^^^
> > --
> > 2.25.1
Gujjar, Abhinandan S Jan. 25, 2022, 2:15 p.m. UTC | #7
> -----Original Message-----
> From: Shijith Thotton <sthotton@marvell.com>
> Sent: Monday, January 24, 2022 12:29 PM
> To: Gujjar, Abhinandan S <abhinandan.gujjar@intel.com>; dev@dpdk.org;
> Jerin Jacob Kollanukkaran <jerinj@marvell.com>
> Cc: Anoob Joseph <anoobj@marvell.com>; Pavan Nikhilesh Bhagavatula
> <pbhagavatula@marvell.com>; Akhil Goyal <gakhil@marvell.com>
> Subject: RE: [PATCH v3] app/eventdev: add crypto producer mode
> 
> Missed some comments in last mail.
> 
> >>
> >> In crypto producer mode, producer core enqueues cryptodev with
> >> software generated crypto ops and worker core dequeues crypto
> >> completion events from the eventdev. Event crypto metadata used for
> >> above processing is pre- populated in each crypto session.
> >>
> >> Parameter --prod_type_cryptodev can be used to enable crypto producer
> >> mode. Parameter --crypto_adptr_mode can be set to select the crypto
> >> adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
> >>
> >> This mode can be used to measure the performance of crypto adapter.
> >>
> >> Example:
> >>   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
> >>   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
> >>   --stlist=a --wlcores 1 --plcores 2
> >>
> >> Signed-off-by: Shijith Thotton <sthotton@marvell.com>
> >> ---
> >> v3:
> >> * Reduce dereference inside loop.
> >>
> >> v2:
> >> * Fix RHEL compilation warning.
> >>
> >>  app/test-eventdev/evt_common.h       |   3 +
> >>  app/test-eventdev/evt_main.c         |  13 +-
> >>  app/test-eventdev/evt_options.c      |  27 ++
> >>  app/test-eventdev/evt_options.h      |  12 +
> >>  app/test-eventdev/evt_test.h         |   6 +
> >>  app/test-eventdev/test_perf_atq.c    |  51 ++++
> >>  app/test-eventdev/test_perf_common.c | 410
> >> ++++++++++++++++++++++++++-  app/test-
> >> eventdev/test_perf_common.h |  16 ++  app/test-
> >> eventdev/test_perf_queue.c  |  52 ++++
> >>  doc/guides/tools/testeventdev.rst    |  13 +
> >>  10 files changed, 596 insertions(+), 7 deletions(-)
> >>
> >> diff --git a/app/test-eventdev/evt_common.h b/app/test-
> >> eventdev/evt_common.h index f466434459..2f301a7e79 100644
> >> --- a/app/test-eventdev/evt_common.h
> >> +++ b/app/test-eventdev/evt_common.h
> >> @@ -7,6 +7,7 @@
> >>
> >>  #include <rte_common.h>
> >>  #include <rte_debug.h>
> >> +#include <rte_event_crypto_adapter.h>
> >>  #include <rte_eventdev.h>
> >>  #include <rte_service.h>
> >>
> >> @@ -39,6 +40,7 @@ enum evt_prod_type {
> >>  	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
> >>  	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter.
> >> */
> >>  	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer
> Adapter.
> >> */
> >> +	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto
> >> Adapter. */
> >>  	EVT_PROD_TYPE_MAX,
> >>  };
> >>
> >> @@ -77,6 +79,7 @@ struct evt_options {
> >>  	uint64_t timer_tick_nsec;
> >>  	uint64_t optm_timer_tick_nsec;
> >>  	enum evt_prod_type prod_type;
> >> +	enum rte_event_crypto_adapter_mode crypto_adptr_mode;
> >>  };
> >>
> >>  static inline bool
> >> diff --git a/app/test-eventdev/evt_main.c
> >> b/app/test-eventdev/evt_main.c index 194c980c7a..cef0fb1382 100644
> >> --- a/app/test-eventdev/evt_main.c
> >> +++ b/app/test-eventdev/evt_main.c
> >> @@ -161,12 +161,19 @@ main(int argc, char **argv)
> >>  			goto mempool_destroy;
> >>  		}
> >>  	}
> >New line required
> Will add.
> 
> >> +	/* Test specific cryptodev setup */
> >> +	if (test->ops.cryptodev_setup) {
> >> +		if (test->ops.cryptodev_setup(test, &opt)) {
> >> +			evt_err("%s: cryptodev setup failed",
> >> opt.test_name);
> >> +			goto ethdev_destroy;
> >> +		}
> >> +	}
> >>
> >>  	/* Test specific eventdev setup */
> >>  	if (test->ops.eventdev_setup) {
> >>  		if (test->ops.eventdev_setup(test, &opt)) {
> >>  			evt_err("%s: eventdev setup failed",
> opt.test_name);
> >> -			goto ethdev_destroy;
> >> +			goto cryptodev_destroy;
> >>  		}
> >>  	}
> >>
> >> @@ -197,6 +204,10 @@ main(int argc, char **argv)
> >>  	if (test->ops.eventdev_destroy)
> >>  		test->ops.eventdev_destroy(test, &opt);
> >>
> >> +cryptodev_destroy:
> >> +	if (test->ops.cryptodev_destroy)
> >> +		test->ops.cryptodev_destroy(test, &opt);
> >> +
> >>  ethdev_destroy:
> >>  	if (test->ops.ethdev_destroy)
> >>  		test->ops.ethdev_destroy(test, &opt); diff --git a/app/test-
> >> eventdev/evt_options.c b/app/test-eventdev/evt_options.c index
> >> 753a7dbd7d..5ad1491020 100644
> >> --- a/app/test-eventdev/evt_options.c
> >> +++ b/app/test-eventdev/evt_options.c
> >> @@ -122,6 +122,26 @@ evt_parse_timer_prod_type_burst(struct
> >> evt_options *opt,
> >>  	return 0;
> >>  }
> >>
> >> +static int
> >> +evt_parse_crypto_prod_type(struct evt_options *opt,
> >> +			   const char *arg __rte_unused)
> >> +{
> >> +	opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
> >> +	return 0;
> >> +}
> >> +
> >> +static int
> >> +evt_parse_crypto_adptr_mode(struct evt_options *opt, const char
> *arg) {
> >> +	uint8_t mode;
> >> +	int ret;
> >> +
> >> +	ret = parser_read_uint8(&mode, arg);
> >> +	opt->crypto_adptr_mode = mode ?
> >> RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
> >> +
> >> 	RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
> >> +	return ret;
> >> +}
> >> +
> >>  static int
> >>  evt_parse_test_name(struct evt_options *opt, const char *arg)  { @@
> >> -
> >> 335,6 +355,7 @@ usage(char *program)
> >>  		"\t--queue_priority   : enable queue priority\n"
> >>  		"\t--deq_tmo_nsec     : global dequeue timeout\n"
> >>  		"\t--prod_type_ethdev : use ethernet device as
> producer.\n"
> >> +		"\t--prod_type_cryptodev : use crypto device as
> >> producer.\n"
> >>  		"\t--prod_type_timerdev : use event timer device as
> producer.\n"
> >>  		"\t                     expity_nsec would be the timeout\n"
> >>  		"\t                     in ns.\n"
> >> @@ -345,6 +366,8 @@ usage(char *program)
> >>  		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
> >>  		"\t--max_tmo_nsec     : max timeout interval in ns.\n"
> >>  		"\t--expiry_nsec      : event timer expiry ns.\n"
> >> +		"\t--crypto_adptr_mode : 0 for OP_NEW mode (default)
> >> and\n"
> >> +		"\t                      1 for OP_FORWARD mode.\n"
> >>  		"\t--mbuf_sz          : packet mbuf size.\n"
> >>  		"\t--max_pkt_sz       : max packet size.\n"
> >>  		"\t--prod_enq_burst_sz : producer enqueue burst size.\n"
> >> @@ -415,8 +438,10 @@ static struct option lgopts[] = {
> >>  	{ EVT_QUEUE_PRIORITY,      0, 0, 0 },
> >>  	{ EVT_DEQ_TMO_NSEC,        1, 0, 0 },
> >>  	{ EVT_PROD_ETHDEV,         0, 0, 0 },
> >> +	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
> >>  	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
> >>  	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
> >> +	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
> >>  	{ EVT_NB_TIMERS,           1, 0, 0 },
> >>  	{ EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
> >>  	{ EVT_TIMER_TICK_NSEC,     1, 0, 0 },
> >> @@ -455,8 +480,10 @@ evt_opts_parse_long(int opt_idx, struct
> >> evt_options
> >> *opt)
> >>  		{ EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
> >>  		{ EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
> >>  		{ EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
> >> +		{ EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
> >>  		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
> >>  		{ EVT_PROD_TIMERDEV_BURST,
> >> evt_parse_timer_prod_type_burst},
> >> +		{ EVT_CRYPTO_ADPTR_MODE,
> >> evt_parse_crypto_adptr_mode},
> >>  		{ EVT_NB_TIMERS, evt_parse_nb_timers},
> >>  		{ EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
> >>  		{ EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec}, diff --
> git
> >> a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
> >> index 413d7092f0..2231c58801 100644
> >> --- a/app/test-eventdev/evt_options.h
> >> +++ b/app/test-eventdev/evt_options.h
> >> @@ -9,6 +9,7 @@
> >>  #include <stdbool.h>
> >>
> >>  #include <rte_common.h>
> >> +#include <rte_cryptodev.h>
> >>  #include <rte_ethdev.h>
> >>  #include <rte_eventdev.h>
> >>  #include <rte_lcore.h>
> >> @@ -33,8 +34,10 @@
> >>  #define EVT_QUEUE_PRIORITY       ("queue_priority")
> >>  #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
> >>  #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
> >> +#define EVT_PROD_CRYPTODEV	 ("prod_type_cryptodev")
> >>  #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
> >>  #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
> >> +#define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
> >>  #define EVT_NB_TIMERS            ("nb_timers")
> >>  #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
> >>  #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
> >> @@ -249,6 +252,8 @@ evt_prod_id_to_name(enum evt_prod_type
> >> prod_type)
> >>  		return "Ethdev Rx Adapter";
> >>  	case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
> >>  		return "Event timer adapter";
> >> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> >> +		return "Event crypto adapter";
> >>  	}
> >>
> >>  	return "";
> >> @@ -288,6 +293,13 @@ evt_dump_producer_type(struct evt_options
> *opt)
> >>  			evt_dump("timer_tick_nsec", "%"PRIu64"",
> >>  					opt->timer_tick_nsec);
> >>  		break;
> >> +	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
> >> +		snprintf(name, EVT_PROD_MAX_NAME_LEN,
> >> +			 "Event crypto adapter producers");
> >> +		evt_dump("crypto adapter mode", "%s",
> >> +			 opt->crypto_adptr_mode ? "OP_FORWARD" :
> >> "OP_NEW");
> >> +		evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
> >> +		break;
> >>  	}
> >>  	evt_dump("prod_type", "%s", name);
> >>  }
> >> diff --git a/app/test-eventdev/evt_test.h
> >> b/app/test-eventdev/evt_test.h index f07d2c3336..50fa474ec2 100644
> >> --- a/app/test-eventdev/evt_test.h
> >> +++ b/app/test-eventdev/evt_test.h
> >> @@ -29,6 +29,8 @@ typedef int (*evt_test_mempool_setup_t)
> >>  		(struct evt_test *test, struct evt_options *opt);  typedef int
> >> (*evt_test_ethdev_setup_t)
> >>  		(struct evt_test *test, struct evt_options *opt);
> >> +typedef int (*evt_test_cryptodev_setup_t)
> >> +		(struct evt_test *test, struct evt_options *opt);
> >>  typedef int (*evt_test_eventdev_setup_t)
> >>  		(struct evt_test *test, struct evt_options *opt);  typedef int
> >> (*evt_test_launch_lcores_t) @@ -39,6 +41,8 @@ typedef void
> >> (*evt_test_eventdev_destroy_t)
> >>  		(struct evt_test *test, struct evt_options *opt);  typedef void
> >> (*evt_test_ethdev_destroy_t)
> >>  		(struct evt_test *test, struct evt_options *opt);
> >> +typedef void (*evt_test_cryptodev_destroy_t)
> >> +		(struct evt_test *test, struct evt_options *opt);
> >>  typedef void (*evt_test_mempool_destroy_t)
> >>  		(struct evt_test *test, struct evt_options *opt);  typedef void
> >> (*evt_test_destroy_t) @@ -52,10 +56,12 @@ struct evt_test_ops {
> >>  	evt_test_mempool_setup_t mempool_setup;
> >>  	evt_test_ethdev_setup_t ethdev_setup;
> >>  	evt_test_eventdev_setup_t eventdev_setup;
> >> +	evt_test_cryptodev_setup_t cryptodev_setup;
> >>  	evt_test_launch_lcores_t launch_lcores;
> >>  	evt_test_result_t test_result;
> >>  	evt_test_eventdev_destroy_t eventdev_destroy;
> >>  	evt_test_ethdev_destroy_t ethdev_destroy;
> >> +	evt_test_cryptodev_destroy_t cryptodev_destroy;
> >>  	evt_test_mempool_destroy_t mempool_destroy;
> >>  	evt_test_destroy_t test_destroy;
> >>  };
> >> diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-
> >> eventdev/test_perf_atq.c index 8fd51004ee..dbb1dc8c0c 100644
> >> --- a/app/test-eventdev/test_perf_atq.c
> >> +++ b/app/test-eventdev/test_perf_atq.c
> >> @@ -48,6 +48,22 @@ perf_atq_worker(void *arg, const int
> >> enable_fwd_latency)
> >>  			continue;
> >>  		}
> >>
> >> +		if (prod_crypto_type &&
> >> +		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
> >> +			struct rte_crypto_op *op = ev.event_ptr;
> >> +
> >> +			if (op->status ==
> >> RTE_CRYPTO_OP_STATUS_SUCCESS) {
> >> +				if (op->sym->m_dst == NULL)
> >> +					ev.event_ptr = op->sym->m_src;
> >> +				else
> >> +					ev.event_ptr = op->sym->m_dst;
> >> +				rte_crypto_op_free(op);
> >> +			} else {
> >> +				rte_crypto_op_free(op);
> >> +				continue;
> >> +			}
> >> +		}
> >> +
> >>  		if (enable_fwd_latency && !prod_timer_type)
> >>  		/* first stage in pipeline, mark ts to compute fwd latency */
> >>  			atq_mark_fwd_latency(&ev);
> >> @@ -87,6 +103,25 @@ perf_atq_worker_burst(void *arg, const int
> >> enable_fwd_latency)
> >>  		}
> >>
> >>  		for (i = 0; i < nb_rx; i++) {
> >> +			if (prod_crypto_type &&
> >> +			    (ev[i].event_type ==
> >> RTE_EVENT_TYPE_CRYPTODEV)) {
> >> +				struct rte_crypto_op *op = ev[i].event_ptr;
> >> +
> >> +				if (op->status ==
> >> +				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
> >> +					if (op->sym->m_dst == NULL)
> >> +						ev[i].event_ptr =
> >> +							op->sym->m_src;
> >> +					else
> >> +						ev[i].event_ptr =
> >> +							op->sym->m_dst;
> >> +					rte_crypto_op_free(op);
> >> +				} else {
> >> +					rte_crypto_op_free(op);
> >> +					continue;
> >> +				}
> >> +			}
> >> +
> >>  			if (enable_fwd_latency && !prod_timer_type) {
> >>  				rte_prefetch0(ev[i+1].event_ptr);
> >>  				/* first stage in pipeline.
> >> @@ -254,6 +289,20 @@ perf_atq_eventdev_setup(struct evt_test *test,
> >> struct evt_options *opt)
> >>  				return ret;
> >>  			}
> >>  		}
> >> +	} else if (opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >> +		uint8_t cdev_id, cdev_count;
> >> +
> >> +		cdev_count = rte_cryptodev_count();
> >> +		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> >> +			ret = rte_cryptodev_start(cdev_id);
> >> +			if (ret) {
> >> +				evt_err("Failed to start cryptodev %u",
> >> +					cdev_id);
> >> +				return ret;
> >> +			}
> >> +		}
> >> +
> >> +		rte_event_crypto_adapter_start(t->crypto_adptr.id);
> >>  	}
> >>
> >>  	return 0;
> >> @@ -295,12 +344,14 @@ static const struct evt_test_ops perf_atq =  {
> >>  	.opt_dump           = perf_atq_opt_dump,
> >>  	.test_setup         = perf_test_setup,
> >>  	.ethdev_setup       = perf_ethdev_setup,
> >> +	.cryptodev_setup    = perf_cryptodev_setup,
> >>  	.mempool_setup      = perf_mempool_setup,
> >>  	.eventdev_setup     = perf_atq_eventdev_setup,
> >>  	.launch_lcores      = perf_atq_launch_lcores,
> >>  	.eventdev_destroy   = perf_eventdev_destroy,
> >>  	.mempool_destroy    = perf_mempool_destroy,
> >>  	.ethdev_destroy     = perf_ethdev_destroy,
> >> +	.cryptodev_destroy  = perf_cryptodev_destroy,
> >>  	.test_result        = perf_test_result,
> >>  	.test_destroy       = perf_test_destroy,
> >>  };
> >> diff --git a/app/test-eventdev/test_perf_common.c b/app/test-
> >> eventdev/test_perf_common.c index 9b73874151..91cb6748ee 100644
> >> --- a/app/test-eventdev/test_perf_common.c
> >> +++ b/app/test-eventdev/test_perf_common.c
> >> @@ -6,6 +6,8 @@
> >>
> >>  #include "test_perf_common.h"
> >>
> >> +#define NB_CRYPTODEV_DESCRIPTORS 128
> >> +
> >>  int
> >>  perf_test_result(struct evt_test *test, struct evt_options *opt)  {
> >> @@ -272,6
> >> +274,125 @@ perf_event_timer_producer_burst(void *arg)
> >>  	return 0;
> >>  }
> >>
> >> +static inline void
> >> +crypto_adapter_enq_op_new(struct prod_data *p) {
> >> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> >> +	struct test_perf *t = p->t;
> >> +	const uint32_t nb_flows = t->nb_flows;
> >> +	const uint64_t nb_pkts = t->nb_pkts;
> >> +	struct rte_mempool *pool = t->pool;
> >> +	struct rte_crypto_sym_op *sym_op;
> >> +	struct evt_options *opt = t->opt;
> >> +	uint16_t qp_id = p->cdev_qp_id;
> >> +	uint8_t cdev_id = p->cdev_id;
> >> +	uint32_t flow_counter = 0;
> >> +	struct rte_crypto_op *op;
> >> +	struct rte_mbuf *m;
> >> +	uint64_t count = 0;
> >> +	uint16_t len;
> >> +
> >> +	if (opt->verbose_level > 1)
> >> +		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id
> >> %u\n",
> >> +		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
> >> +		       p->cdev_qp_id);
> >> +
> >> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> >> +
> >> +	while (count < nb_pkts && t->done == false) {
> >> +		m = rte_pktmbuf_alloc(pool);
> >> +		if (m == NULL)
> >> +			continue;
> >> +
> >> +		rte_pktmbuf_append(m, len);
> >> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> >> +
> >> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> >> +		sym_op = op->sym;
> >> +		sym_op->m_src = m;
> >> +		sym_op->cipher.data.offset = 0;
> >> +		sym_op->cipher.data.length = len;
> >> +		rte_crypto_op_attach_sym_session(
> >> +			op, crypto_sess[flow_counter++ % nb_flows]);
> >> +		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op,
> >> 1) !=
> >> +		       1) {
> >> +			if (t->done)
> >> +				break;
> >> +			rte_pause();
> >> +		}
> >> +		count++;
> >> +	}
> >> +}
> >> +
> >> +static inline void
> >> +crypto_adapter_enq_op_fwd(struct prod_data *p) {
> >> +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
> >> +	const uint8_t dev_id = p->dev_id;
> >> +	const uint8_t port = p->port_id;
> >> +	struct test_perf *t = p->t;
> >> +	const uint32_t nb_flows = t->nb_flows;
> >> +	const uint64_t nb_pkts = t->nb_pkts;
> >> +	struct rte_mempool *pool = t->pool;
> >> +	struct evt_options *opt = t->opt;
> >> +	struct rte_crypto_sym_op *sym_op;
> >> +	uint32_t flow_counter = 0;
> >> +	struct rte_crypto_op *op;
> >> +	struct rte_event ev;
> >> +	struct rte_mbuf *m;
> >> +	uint64_t count = 0;
> >> +	uint16_t len;
> >> +
> >> +	if (opt->verbose_level > 1)
> >> +		printf("%s(): lcore %d port %d queue %d cdev_id %u
> >> cdev_qp_id %u\n",
> >> +		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
> >> +		       p->cdev_qp_id);
> >> +
> >> +	ev.event = 0;
> >> +	ev.op = RTE_EVENT_OP_NEW;
> >> +	ev.queue_id = p->queue_id;
> >> +	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
> >> +	ev.event_type = RTE_EVENT_TYPE_CPU;
> >> +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
> >> +
> >> +	while (count < nb_pkts && t->done == false) {
> >> +		m = rte_pktmbuf_alloc(pool);
> >> +		if (m == NULL)
> >> +			continue;
> >> +
> >> +		rte_pktmbuf_append(m, len);
> >> +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
> >> +
> >> RTE_CRYPTO_OP_TYPE_SYMMETRIC);
> >> +		sym_op = op->sym;
> >> +		sym_op->m_src = m;
> >> +		sym_op->cipher.data.offset = 0;
> >> +		sym_op->cipher.data.length = len;
> >> +		rte_crypto_op_attach_sym_session(
> >> +			op, crypto_sess[flow_counter++ % nb_flows]);
> >> +		ev.event_ptr = op;
> >> +		while (rte_event_crypto_adapter_enqueue(dev_id, port,
> >> &ev, 1) !=
> >> +		       1) {
> >> +			if (t->done)
> >> +				break;
> >> +			rte_pause();
> >> +		}
> >> +		count++;
> >> +	}
> >> +}
> >> +
> >> +static inline int
> >> +perf_event_crypto_producer(void *arg) {
> >> +	struct prod_data *p = arg;
> >> +	struct evt_options *opt = p->t->opt;
> >> +
> >> +	if (opt->crypto_adptr_mode ==
> >> RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
> >> +		crypto_adapter_enq_op_new(p);
> >> +	else
> >> +		crypto_adapter_enq_op_fwd(p);
> >> +
> >> +	return 0;
> >> +}
> >> +
> >>  static int
> >>  perf_producer_wrapper(void *arg)
> >>  {
> >> @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
> >>  	else if (t->opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
> >>  			t->opt->timdev_use_burst)
> >>  		return perf_event_timer_producer_burst(arg);
> >> +	else if (t->opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> >> +		return perf_event_crypto_producer(arg);
> >>  	return 0;
> >>  }
> >>
> >> @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
> >> evt_options *opt,
> >>  			if (remaining <= 0) {
> >>  				t->result = EVT_TEST_SUCCESS;
> >>  				if (opt->prod_type ==
> >> EVT_PROD_TYPE_SYNT ||
> >> -					opt->prod_type ==
> >> -
> >> 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> >> +				    opt->prod_type ==
> >> +
> >> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> >> +				    opt->prod_type ==
> >> +
> >> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >>  					t->done = true;
> >>  					break;
> >>  				}
> >> @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
> >> evt_options *opt,
> >>
> >>  		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
> >>  		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> >> -		     opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
> >> +		     opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> >> +		     opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
> >>  			remaining = t->outstand_pkts - processed_pkts(t);
> >>  			if (dead_lock_remaining == remaining) {
> >>  				rte_event_dev_dump(opt->dev_id, stdout);
> @@ -537,6 +663,96 @@
> >> perf_event_timer_adapter_setup(struct test_perf
> >> *t)
> >>  	return 0;
> >>  }
> >>
> >> +static int
> >> +perf_event_crypto_adapter_setup(struct test_perf *t,
> >> +				struct rte_event_port_conf port_conf) {
> >> +	struct evt_options *opt = t->opt;
> >> +	uint8_t cdev_id, cdev_count;
> >> +	int ret;
> >> +
> >> +	t->crypto_adptr.id = 0;
> >> +	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
> >> >dev_id,
> >> +					      &port_conf, 0);
> >> +	if (ret)
> >> +		return ret;
> >> +
> >> +	cdev_count = rte_cryptodev_count();
> >> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> >> +		uint32_t cap;
> >> +
> >> +		ret = rte_event_crypto_adapter_caps_get(opt->dev_id,
> >> cdev_id,
> >> +							&cap);
> >> +		if (ret) {
> >> +			evt_err("Failed to get crypto adapter capabilities");
> >> +			return ret;
> >> +		}
> >> +
> >> +		if (((opt->crypto_adptr_mode ==
> >> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
> >> +		     !(cap &
> >> +
> >> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
> >> +		    ((opt->crypto_adptr_mode ==
> >> +		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
> >> +		     !(cap &
> >> +
> >> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
> >> +			evt_err("crypto adapter %s mode unsupported\n",
> >> +				opt->crypto_adptr_mode ? "OP_FORWARD"
> >> :
> >> +							 "OP_NEW");
> >> +			return -EINVAL;
> >> +		}
> >> +
> >> +		if (!(cap &
> >> +
> >> RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
> >> +			evt_err("Storing crypto session not supported");
> >> +			return -EINVAL;
> >> +		}
> >> +
> >> +		if (cap &
> >> +
> >> RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
> >> +			struct rte_event response_info;
> >> +
> >> +			response_info.event = 0;
> >> +			ret = rte_event_crypto_adapter_queue_pair_add(
> >> +				t->crypto_adptr.id, cdev_id, -1,
> >> +				&response_info);
> >> +		} else {
> >> +			ret = rte_event_crypto_adapter_queue_pair_add(
> >> +				t->crypto_adptr.id, cdev_id, -1, NULL);
> >> +		}
> >> +		if (ret)
> >> +			return ret;
> >> +	}
> >> +
> >> +	return 0;
> >> +}
> >> +
> >> +static struct rte_cryptodev_sym_session *
> >> +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
> >> +	struct rte_crypto_sym_xform cipher_xform;
> >> +	struct rte_cryptodev_sym_session *sess;
> >> +
> >> +	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
> >> +	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
> >> +	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
> >> +	cipher_xform.next = NULL;
> >> +
> >> +	sess = rte_cryptodev_sym_session_create(t-
> >> >crypto_adptr.sess_pool);
> >> +	if (sess == NULL) {
> >> +		evt_err("Failed to create sym session");
> >> +		return NULL;
> >> +	}
> >> +
> >> +	if (rte_cryptodev_sym_session_init(p->cdev_id, sess,
> >> &cipher_xform,
> >> +					   t->crypto_adptr.sess_priv_pool)) {
> >> +		evt_err("Failed to init session");
> >> +		return NULL;
> >> +	}
> >> +
> >> +	return sess;
> >> +}
> >> +
> >>  int
> >>  perf_event_dev_port_setup(struct evt_test *test, struct evt_options
> *opt,
> >>  				uint8_t stride, uint8_t nb_queues, @@ -
> 598,6 +814,55 @@
> >> perf_event_dev_port_setup(struct evt_test *test, struct evt_options
> >> *opt,
> >>  		ret = perf_event_timer_adapter_setup(t);
> >>  		if (ret)
> >>  			return ret;
> >> +	} else if (opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >> +		uint8_t cdev_id = 0;
> >> +		uint16_t qp_id = 0;
> >> +
> >> +		prod = 0;
> >> +		for (; port < perf_nb_event_ports(opt); port++) {
> >> +			struct rte_cryptodev_sym_session *crypto_sess;
> >> +			union rte_event_crypto_metadata m_data;
> >> +			struct prod_data *p = &t->prod[port];
> >> +			uint32_t flow_id;
> >> +
> >> +			if (qp_id ==
> >> rte_cryptodev_queue_pair_count(cdev_id)) {
> >> +				cdev_id++;
> >> +				qp_id = 0;
> >> +			}
> >> +
> >> +			p->dev_id = opt->dev_id;
> >> +			p->port_id = port;
> >> +			p->queue_id = prod * stride;
> >> +			p->cdev_id = cdev_id;
> >> +			p->cdev_qp_id = qp_id;
> >> +			p->crypto_sess = rte_zmalloc_socket(
> >> +				NULL, sizeof(crypto_sess) * t->nb_flows,
> >> +				RTE_CACHE_LINE_SIZE, opt->socket_id);
> >> +
> >> +			m_data.request_info.cdev_id = p->cdev_id;
> >> +			m_data.request_info.queue_pair_id = p-
> >> >cdev_qp_id;
> >> +			m_data.response_info.op = RTE_EVENT_OP_NEW;
> >> +			m_data.response_info.sched_type =
> >> RTE_SCHED_TYPE_ATOMIC;
> >> +			m_data.response_info.event_type =
> >> RTE_EVENT_TYPE_CPU;
> >> +			m_data.response_info.queue_id = p->queue_id;
> >> +			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
> >> +				crypto_sess =
> >> cryptodev_sym_sess_create(p, t);
> >> +				if (crypto_sess == NULL)
> >> +					return -ENOMEM;
> >> +
> >> +				m_data.response_info.flow_id = flow_id;
> >> +				rte_cryptodev_sym_session_set_user_data(
> >> +					crypto_sess, &m_data,
> >> sizeof(m_data));
> >> +				p->crypto_sess[flow_id] = crypto_sess;
> >> +			}
> >> +			p->t = t;
> >> +			qp_id++;
> >> +			prod++;
> >> +		}
> >> +
> >> +		ret = perf_event_crypto_adapter_setup(t, *port_conf);
> >> +		if (ret)
> >> +			return ret;
> >>  	} else {
> >>  		prod = 0;
> >>  		for ( ; port < perf_nb_event_ports(opt); port++) { @@ -659,7
> >> +924,8 @@ perf_opt_check(struct evt_options *opt, uint64_t
> nb_queues)
> >>  	}
> >>
> >>  	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> >> -			opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
> >> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
> >> +	    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
> >>  		/* Validate producer lcores */
> >>  		if (evt_lcores_has_overlap(opt->plcores,
> >>  					rte_get_main_lcore())) {
> >> @@ -767,8 +1033,7 @@ perf_ethdev_setup(struct evt_test *test, struct
> >> evt_options *opt)
> >>  		},
> >>  	};
> >>
> >> -	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
> >> -			opt->prod_type ==
> >> EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
> >> +	if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
> >>  		return 0;
> >>
> >>  	if (!rte_eth_dev_count_avail()) {
> >> @@ -841,6 +1106,139 @@ void perf_ethdev_destroy(struct evt_test
> >> *test, struct evt_options *opt)
> >>  	}
> >>  }
> >>
> >> +int
> >> +perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt) {
> >> +	uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
> >> +	struct test_perf *t = evt_test_priv(test);
> >> +	unsigned int max_session_size;
> >> +	uint32_t nb_sessions;
> >> +	int ret;
> >> +
> >> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> >> +		return 0;
> >How do you differentiate between this failed case as you are returning
> >0 in case of success?
> 
> This is not a failed case. cryptodev setup is not needed in other modes and is
> ignored.
Ok
> 
> >> +
> >> +	cdev_count = rte_cryptodev_count();
> >> +	if (cdev_count == 0) {
> >> +		evt_err("No crypto devices available\n");
> >> +		return -ENODEV;
> >> +	}
> >> +
> >> +	t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
> >> +		"crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt-
> >> >pool_sz,
> >> +		128, 0, rte_socket_id());
> >> +	if (t->crypto_adptr.op_pool == NULL) {
> >> +		evt_err("Failed to create crypto op pool");
> >> +		return -ENOMEM;
> >> +	}
> >> +
> >> +	nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
> >> +	t->crypto_adptr.sess_pool =
> >> rte_cryptodev_sym_session_pool_create(
> >> +		"ca_sess_pool", nb_sessions, 0, 0,
> >> +		sizeof(union rte_event_crypto_metadata),
> >> SOCKET_ID_ANY);
> >> +	if (t->crypto_adptr.sess_pool == NULL) {
> >> +		evt_err("Failed to create sym session pool");
> >> +		ret = -ENOMEM;
> >> +		goto err;
> >> +	}
> >> +
> >> +	max_session_size = 0;
> >> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> >> +		unsigned int session_size;
> >> +
> >> +		session_size =
> >> +
> >> 	rte_cryptodev_sym_get_private_session_size(cdev_id);
> >> +		if (session_size > max_session_size)
> >> +			max_session_size = session_size;
> >> +	}
> >New line required
> Will add.
> 
> >> +	max_session_size += sizeof(union rte_event_crypto_metadata);
> >> +	t->crypto_adptr.sess_priv_pool = rte_mempool_create(
> >> +		"ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0,
> >> NULL,
> >> +		NULL, NULL, NULL, SOCKET_ID_ANY, 0);
> >> +	if (t->crypto_adptr.sess_priv_pool == NULL) {
> >> +		evt_err("failed to create sym session private pool");
> >> +		ret = -ENOMEM;
> >> +		goto err;
> >> +	}
> >> +
> >> +	nb_plcores = evt_nr_active_lcores(opt->plcores);
> >> +	nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) +
> >> 1 :
> >> +					     nb_plcores / cdev_count;
> >Let's take an example:
> >Cdev1 -> 8 qps
> >Cdev2 -> 2 qps
> >Cdev_count = 2
> >nb_plcores = 7
> >As per above statement, nb_qps = ( 7 % 2 ) 7/2 + 1 = 4 qps So, this
> >fails to setup qps for cdev2 as it supports only 2 qps and test exits!
> >Am I missing anything?
> >
> What you told is correct. But this is a simple logic to distribute qps across
> multiple cdev and doesn't consider the case you mentioned. You could see
> similar logic used in other apps. I will add a comment as below:
>         /*
>          * 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.
>          */
Sounds good.
> 
> >> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> >> +		struct rte_cryptodev_qp_conf qp_conf;
> >> +		struct rte_cryptodev_config conf;
> >> +		struct rte_cryptodev_info info;
> >> +		int qp_id;
> >> +
> >> +		rte_cryptodev_info_get(cdev_id, &info);
> >> +		if (nb_qps > info.max_nb_queue_pairs) {
> >> +			evt_err("Not enough queue pairs per cryptodev
> >> (%u)",
> >> +				nb_qps);
> >> +			ret = -EINVAL;
> >> +			goto err;
> >> +		}
> >> +
> >> +		conf.nb_queue_pairs = nb_qps;
> >> +		conf.socket_id = SOCKET_ID_ANY;
> >> +		conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
> >> +
> >> +		ret = rte_cryptodev_configure(cdev_id, &conf);
> >> +		if (ret) {
> >> +			evt_err("Failed to configure cryptodev (%u)",
> >> cdev_id);
> >> +			goto err;
> >> +		}
> >> +
> >> +		qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
> >> +		qp_conf.mp_session = t->crypto_adptr.sess_pool;
> >> +		qp_conf.mp_session_private = t-
> >> >crypto_adptr.sess_priv_pool;
> >> +
> >> +		for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
> >> +			ret = rte_cryptodev_queue_pair_setup(
> >> +				cdev_id, qp_id, &qp_conf,
> >> +				rte_cryptodev_socket_id(cdev_id));
> >> +			if (ret) {
> >> +				evt_err("Failed to setup queue pairs on
> >> cryptodev %u\n",
> >> +					cdev_id);
> >> +				goto err;
> >> +			}
> >> +		}
> >> +	}
> >> +
> >> +	return 0;
> >> +err:
> >> +	rte_mempool_free(t->crypto_adptr.op_pool);
> >> +	rte_mempool_free(t->crypto_adptr.sess_pool);
> >> +	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
> >> +
> >> +	return ret;
> >> +}
> >> +
> >> +void
> >> +perf_cryptodev_destroy(struct evt_test *test, struct evt_options
> >> +*opt) {
> >> +	uint8_t cdev_id, cdev_count = rte_cryptodev_count();
> >> +	struct test_perf *t = evt_test_priv(test);
> >> +
> >> +	RTE_SET_USED(opt);
> >> +
> >> +	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
> >> +		return;
> >> +
> >> +	rte_event_crypto_adapter_stop(t->crypto_adptr.id);
> >> +
> >> +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
> >> +		rte_cryptodev_stop(cdev_id);
> >> +		rte_event_crypto_adapter_queue_pair_del(t-
> >> >crypto_adptr.id,
> >> +							cdev_id, -1);
> >Any reason for passing -1? This can not ensure to cleanup all the
> >preconfigured qps as per API.
> Okay, I thought the behavior is like
> rte_event_crypto_adapter_queue_pair_add.
> Any reason, spec desn't consider -1 for
> rte_event_crypto_adapter_queue_pair_del ?
May be, there was no ask for it.
> 
<SNIPPED>
Shijith Thotton Feb. 8, 2022, 5 p.m. UTC | #8
Hi Abhinandan,

>> > Subject: [PATCH v3] app/eventdev: add crypto producer mode
>> >
>> > In crypto producer mode, producer core enqueues cryptodev with
>> > software generated crypto ops and worker core dequeues crypto
>> > completion events from the eventdev. Event crypto metadata used for
>> > above processing is pre- populated in each crypto session.
>> >
>> > Parameter --prod_type_cryptodev can be used to enable crypto producer
>> > mode. Parameter --crypto_adptr_mode can be set to select the crypto
>> > adapter mode, 0 for OP_NEW and 1 for OP_FORWARD.
>> >
>> > This mode can be used to measure the performance of crypto adapter.
>> >
>> > Example:
>> >   ./dpdk-test-eventdev -l 0-2 -w <EVENTDEV> -w <CRYPTODEV> -- \
>> >   --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_atq \
>> >   --stlist=a --wlcores 1 --plcores 2
>> >
>> > Signed-off-by: Shijith Thotton <sthotton@marvell.com>
>> > ---
>> > v3:
>> > * Reduce dereference inside loop.
>> >
>> > v2:
>> > * Fix RHEL compilation warning.
>> >
>> >  app/test-eventdev/evt_common.h       |   3 +
>> >  app/test-eventdev/evt_main.c         |  13 +-
>> >  app/test-eventdev/evt_options.c      |  27 ++
>> >  app/test-eventdev/evt_options.h      |  12 +
>> >  app/test-eventdev/evt_test.h         |   6 +
>> >  app/test-eventdev/test_perf_atq.c    |  51 ++++
>> >  app/test-eventdev/test_perf_common.c | 410
>> > ++++++++++++++++++++++++++-  app/test-
>> > eventdev/test_perf_common.h |  16 ++  app/test-
>> > eventdev/test_perf_queue.c  |  52 ++++
>> >  doc/guides/tools/testeventdev.rst    |  13 +
>> >  10 files changed, 596 insertions(+), 7 deletions(-)
>> >
>> > diff --git a/app/test-eventdev/evt_common.h b/app/test-
>> > eventdev/evt_common.h index f466434459..2f301a7e79 100644
>> > --- a/app/test-eventdev/evt_common.h
>> > +++ b/app/test-eventdev/evt_common.h
>> > @@ -7,6 +7,7 @@
>> >
>> >  #include <rte_common.h>
>> >  #include <rte_debug.h>
>> > +#include <rte_event_crypto_adapter.h>
>> >  #include <rte_eventdev.h>
>> >  #include <rte_service.h>

<SNIP>

>> >
>> > +	if (opt->verbose_level > 1)
>> > +		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id
>> > %u\n",
>> > +		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
>> > +		       p->cdev_qp_id);
>> > +
>> > +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
>> > +
>> > +	while (count < nb_pkts && t->done == false) {
>> > +		m = rte_pktmbuf_alloc(pool);
>> > +		if (m == NULL)
>> > +			continue;
>> > +
>> > +		rte_pktmbuf_append(m, len);
>> > +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
>NULL check for op is missing
 
Not added as it is fast path to avoid performance drop.

>> > +
>> > RTE_CRYPTO_OP_TYPE_SYMMETRIC);
>> > +		sym_op = op->sym;
>> > +		sym_op->m_src = m;
>> > +		sym_op->cipher.data.offset = 0;
>> > +		sym_op->cipher.data.length = len;
>> > +		rte_crypto_op_attach_sym_session(
>> > +			op, crypto_sess[flow_counter++ % nb_flows]);
>> > +		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op,
>> > 1) !=
>> > +		       1) {
>> > +			if (t->done)
>> > +				break;
>> > +			rte_pause();
>> > +		}
>> > +		count++;
>> > +	}
>> > +}
>> > +
>> > +static inline void
>> > +crypto_adapter_enq_op_fwd(struct prod_data *p) {
>> > +	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
>> > +	const uint8_t dev_id = p->dev_id;
>> > +	const uint8_t port = p->port_id;
>> > +	struct test_perf *t = p->t;
>> > +	const uint32_t nb_flows = t->nb_flows;
>> > +	const uint64_t nb_pkts = t->nb_pkts;
>> > +	struct rte_mempool *pool = t->pool;
>> > +	struct evt_options *opt = t->opt;
>> > +	struct rte_crypto_sym_op *sym_op;
>> > +	uint32_t flow_counter = 0;
>> > +	struct rte_crypto_op *op;
>> > +	struct rte_event ev;
>> > +	struct rte_mbuf *m;
>> > +	uint64_t count = 0;
>> > +	uint16_t len;
>> > +
>> > +	if (opt->verbose_level > 1)
>> > +		printf("%s(): lcore %d port %d queue %d cdev_id %u
>> > cdev_qp_id %u\n",
>> > +		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
>> > +		       p->cdev_qp_id);
>> > +
>> > +	ev.event = 0;
>> > +	ev.op = RTE_EVENT_OP_NEW;
>So, this is an new event and adapter treats it as OP_FWD?
>> > +	ev.queue_id = p->queue_id;
>> > +	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
>> > +	ev.event_type = RTE_EVENT_TYPE_CPU;
>> > +	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
>> > +
>> > +	while (count < nb_pkts && t->done == false) {
>> > +		m = rte_pktmbuf_alloc(pool);
>> > +		if (m == NULL)
>> > +			continue;
>> > +
>> > +		rte_pktmbuf_append(m, len);
>> > +		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
>> > +
>> > RTE_CRYPTO_OP_TYPE_SYMMETRIC);
>> > +		sym_op = op->sym;
>> > +		sym_op->m_src = m;
>> > +		sym_op->cipher.data.offset = 0;
>> > +		sym_op->cipher.data.length = len;
>> > +		rte_crypto_op_attach_sym_session(
>> > +			op, crypto_sess[flow_counter++ % nb_flows]);
>> > +		ev.event_ptr = op;
>> > +		while (rte_event_crypto_adapter_enqueue(dev_id, port,
>> > &ev, 1) !=
>> > +		       1) {
>If the adapter OP_FWD is supported by rte_event_enqueue_burst(), then even
>that path has to be tested. Please add it.
 
Added in patch to avoid software adapter.

>> > +			if (t->done)
>> > +				break;
>> > +			rte_pause();
>> > +		}
>> > +		count++;
>> > +	}
>> > +}
>> > +
>> > +static inline int
>> > +perf_event_crypto_producer(void *arg) {
>> > +	struct prod_data *p = arg;
>> > +	struct evt_options *opt = p->t->opt;
>> > +
>> > +	if (opt->crypto_adptr_mode ==
>> > RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
>> > +		crypto_adapter_enq_op_new(p);
>> > +	else
>> > +		crypto_adapter_enq_op_fwd(p);
>> > +
>> > +	return 0;
>> > +}
>> > +
>> >  static int
>> >  perf_producer_wrapper(void *arg)
>> >  {
>> > @@ -298,6 +419,8 @@ perf_producer_wrapper(void *arg)
>> >  	else if (t->opt->prod_type ==
>> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
>> >  			t->opt->timdev_use_burst)
>> >  		return perf_event_timer_producer_burst(arg);
>> > +	else if (t->opt->prod_type ==
>> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
>> > +		return perf_event_crypto_producer(arg);
>> >  	return 0;
>> >  }
>> >
>> > @@ -405,8 +528,10 @@ perf_launch_lcores(struct evt_test *test, struct
>> > evt_options *opt,
>> >  			if (remaining <= 0) {
>> >  				t->result = EVT_TEST_SUCCESS;
>> >  				if (opt->prod_type ==
>> > EVT_PROD_TYPE_SYNT ||
>> > -					opt->prod_type ==
>> > -
>> > 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
>> > +				    opt->prod_type ==
>> > +
>> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> > +				    opt->prod_type ==
>> > +
>> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> >  					t->done = true;
>> >  					break;
>> >  				}
>> > @@ -415,7 +540,8 @@ perf_launch_lcores(struct evt_test *test, struct
>> > evt_options *opt,
>> >
>> >  		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
>> >  		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
>> > -		     opt->prod_type ==
>> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
>> > +		     opt->prod_type ==
>> > EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
>> > +		     opt->prod_type ==
>> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
>> >  			remaining = t->outstand_pkts - processed_pkts(t);
>> >  			if (dead_lock_remaining == remaining) {
>> >  				rte_event_dev_dump(opt->dev_id, stdout);
>> @@ -537,6 +663,96 @@
>> > perf_event_timer_adapter_setup(struct test_perf
>> > *t)
>> >  	return 0;
>> >  }
>> >
>> > +static int
>> > +perf_event_crypto_adapter_setup(struct test_perf *t,
>> > +				struct rte_event_port_conf port_conf) {
>> > +	struct evt_options *opt = t->opt;
>> > +	uint8_t cdev_id, cdev_count;
>> > +	int ret;
>> > +
>> > +	t->crypto_adptr.id = 0;
>> > +	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt-
>> > >dev_id,
>> > +					      &port_conf, 0);
>> > +	if (ret)
>> > +		return ret;
>> > +
>> > +	cdev_count = rte_cryptodev_count();
>> > +	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
>> > +		uint32_t cap;
>> > +
>> > +		ret = rte_event_crypto_adapter_caps_get(opt->dev_id,
>> > cdev_id,
>> > +							&cap);
>> > +		if (ret) {
>> > +			evt_err("Failed to get crypto adapter capabilities");
>> > +			return ret;
>> > +		}
>> > +
>> > +		if (((opt->crypto_adptr_mode ==
>> > +		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
>> > +		     !(cap &
>> > +
>> > RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
>> > +		    ((opt->crypto_adptr_mode ==
>> > +		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
>> > +		     !(cap &
>> > +
>> > RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
>> > +			evt_err("crypto adapter %s mode unsupported\n",
>> > +				opt->crypto_adptr_mode ? "OP_FORWARD"
>> > :
>> > +							 "OP_NEW");
>> > +			return -EINVAL;
>> > +		}
>> > +
>> > +		if (!(cap &
>> > +
>> > RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
>> > +			evt_err("Storing crypto session not supported");
>> > +			return -EINVAL;
>> > +		}
>> > +
>> > +		if (cap &
>> > +
>> > RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
>> > +			struct rte_event response_info;
>> > +
>> > +			response_info.event = 0;
>It is good that you are covering even this case. Should not you fill event with valid
>values?
 
Done

>> > +			ret = rte_event_crypto_adapter_queue_pair_add(
>> > +				t->crypto_adptr.id, cdev_id, -1,
>> > +				&response_info);
>> > +		} else {
>> > +			ret = rte_event_crypto_adapter_queue_pair_add(
>> > +				t->crypto_adptr.id, cdev_id, -1, NULL);
>> > +		}
>New line
 
Done

>> > +		if (ret)
>> > +			return ret;
>> > +	}
>> > +
>> > +	return 0;
>> > +}
>> > +
>> > +static struct rte_cryptodev_sym_session *
>> > +cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t) {
>> > +	struct rte_crypto_sym_xform cipher_xform;
>> > +	struct rte_cryptodev_sym_session *sess;
>> > +
>> > +	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
>> > +	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
>> > +	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
>> > +	cipher_xform.next = NULL;
>> > +
>> > +	sess = rte_cryptodev_sym_session_create(t-
>> > >crypto_adptr.sess_pool);
>> > +	if (sess == NULL) {
>> > +		evt_err("Failed to create sym session");
>> > +		return NULL;
>> > +	}
>> > +
>> > +	if (rte_cryptodev_sym_session_init(p->cdev_id, sess,
>> > &cipher_xform,
>> > +					   t->crypto_adptr.sess_priv_pool)) {
>> > +		evt_err("Failed to init session");
>> > +		return NULL;
>> > +	}
>> > +
>> > +	return sess;
>> > +}
>> > +
>> >  int
>> >  perf_event_dev_port_setup(struct evt_test *test, struct evt_options
>> *opt,
>> >  				uint8_t stride, uint8_t nb_queues, @@ -
>> 598,6 +814,55 @@
>> > perf_event_dev_port_setup(struct evt_test *test, struct evt_options
>> > *opt,
>> >  		ret = perf_event_timer_adapter_setup(t);
>> >  		if (ret)
>> >  			return ret;
>> > +	} else if (opt->prod_type ==
>> > EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
>> > +		uint8_t cdev_id = 0;
>> > +		uint16_t qp_id = 0;
>> > +
>> > +		prod = 0;
>> > +		for (; port < perf_nb_event_ports(opt); port++) {
>> > +			struct rte_cryptodev_sym_session *crypto_sess;
>> > +			union rte_event_crypto_metadata m_data;
>> > +			struct prod_data *p = &t->prod[port];
>> > +			uint32_t flow_id;
>> > +
>> > +			if (qp_id ==
>> > rte_cryptodev_queue_pair_count(cdev_id)) {
>> > +				cdev_id++;
>> > +				qp_id = 0;
>> > +			}
>> > +
>> > +			p->dev_id = opt->dev_id;
>> > +			p->port_id = port;
>> > +			p->queue_id = prod * stride;
>> > +			p->cdev_id = cdev_id;
>> > +			p->cdev_qp_id = qp_id;
>> > +			p->crypto_sess = rte_zmalloc_socket(
>> > +				NULL, sizeof(crypto_sess) * t->nb_flows,
>> > +				RTE_CACHE_LINE_SIZE, opt->socket_id);
>> > +
>> > +			m_data.request_info.cdev_id = p->cdev_id;
>> > +			m_data.request_info.queue_pair_id = p-
>> > >cdev_qp_id;
>> > +			m_data.response_info.op = RTE_EVENT_OP_NEW;
>> > +			m_data.response_info.sched_type =
>> > RTE_SCHED_TYPE_ATOMIC;
>> > +			m_data.response_info.event_type =
>> > RTE_EVENT_TYPE_CPU;
>> > +			m_data.response_info.queue_id = p->queue_id;
>> > +			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
>> > +				crypto_sess =
>> > cryptodev_sym_sess_create(p, t);
>> > +				if (crypto_sess == NULL)
>> > +					return -ENOMEM;
>> > +
>> > +				m_data.response_info.flow_id = flow_id;
>> > +				rte_cryptodev_sym_session_set_user_data(
>> > +					crypto_sess, &m_data,
>> > sizeof(m_data));
>> > +				p->crypto_sess[flow_id] = crypto_sess;
>> > +			}
>New line
 
Done

<SNIP>
 
Please ack v4 if there are no more comments.

I tried adding support for software adapter implementation, but is getting a
crash in sw_event PMD after some packets. I have posted the respective changes
here: https://patchwork.dpdk.org/project/dpdk/patch/0677cbafa5145f1b9f64dd007594e033f2d9ab8a.1644337310.git.sthotton@marvell.com/
Please take it forward.

Command used to test is:
dpdk-test-eventdev -l 0-8 -s 0xf0 --vdev=event_sw0  --vdev="crypto_null" --    \
      --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_queue --stlist=a \
      --wlcores 1 --plcores 2
Jerin Jacob Feb. 14, 2022, 3:26 p.m. UTC | #9
On Tue, Feb 8, 2022 at 10:31 PM Shijith Thotton <sthotton@marvell.com> wrote:
>

> Please ack v4 if there are no more comments.

Hi @Gujjar, Abhinandan S

Any objection to merging the test application patch?



> I tried adding support for software adapter implementation, but is getting a
> crash in sw_event PMD after some packets. I have posted the respective changes
> here: https://patchwork.dpdk.org/project/dpdk/patch/0677cbafa5145f1b9f64dd007594e033f2d9ab8a.1644337310.git.sthotton@marvell.com/
> Please take it forward.
>
> Command used to test is:
> dpdk-test-eventdev -l 0-8 -s 0xf0 --vdev=event_sw0  --vdev="crypto_null" --    \
>       --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_queue --stlist=a \
>       --wlcores 1 --plcores 2
>
Gujjar, Abhinandan S Feb. 14, 2022, 3:31 p.m. UTC | #10
Hi Jerin,

I have some issues with my sandbox after the recent upgrade.
I am trying to get it working to test the patches.
Hopefully, by 1-2 days I will give you update.

Regards
Abhinandan

> -----Original Message-----
> From: Jerin Jacob <jerinjacobk@gmail.com>
> Sent: Monday, February 14, 2022 8:57 PM
> To: Shijith Thotton <sthotton@marvell.com>
> Cc: Gujjar, Abhinandan S <abhinandan.gujjar@intel.com>; dev@dpdk.org;
> Jerin Jacob Kollanukkaran <jerinj@marvell.com>; Anoob Joseph
> <anoobj@marvell.com>; Pavan Nikhilesh Bhagavatula
> <pbhagavatula@marvell.com>; Akhil Goyal <gakhil@marvell.com>
> Subject: Re: [PATCH v3] app/eventdev: add crypto producer mode
> 
> On Tue, Feb 8, 2022 at 10:31 PM Shijith Thotton <sthotton@marvell.com>
> wrote:
> >
> 
> > Please ack v4 if there are no more comments.
> 
> Hi @Gujjar, Abhinandan S
> 
> Any objection to merging the test application patch?
> 
> 
> 
> > I tried adding support for software adapter implementation, but is
> > getting a crash in sw_event PMD after some packets. I have posted the
> > respective changes
> > here:
> >
> https://patchwork.dpdk.org/project/dpdk/patch/0677cbafa5145f1b9f64dd0
> 0
> > 7594e033f2d9ab8a.1644337310.git.sthotton@marvell.com/
> > Please take it forward.
> >
> > Command used to test is:
> > dpdk-test-eventdev -l 0-8 -s 0xf0 --vdev=event_sw0  --vdev="crypto_null" --
> \
> >       --prod_type_cryptodev --crypto_adptr_mode 1 --test=perf_queue --
> stlist=a \
> >       --wlcores 1 --plcores 2
> >
diff mbox series

Patch

diff --git a/app/test-eventdev/evt_common.h b/app/test-eventdev/evt_common.h
index f466434459..2f301a7e79 100644
--- a/app/test-eventdev/evt_common.h
+++ b/app/test-eventdev/evt_common.h
@@ -7,6 +7,7 @@ 
 
 #include <rte_common.h>
 #include <rte_debug.h>
+#include <rte_event_crypto_adapter.h>
 #include <rte_eventdev.h>
 #include <rte_service.h>
 
@@ -39,6 +40,7 @@  enum evt_prod_type {
 	EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
 	EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter. */
 	EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer Adapter. */
+	EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR,  /* Producer type Crypto Adapter. */
 	EVT_PROD_TYPE_MAX,
 };
 
@@ -77,6 +79,7 @@  struct evt_options {
 	uint64_t timer_tick_nsec;
 	uint64_t optm_timer_tick_nsec;
 	enum evt_prod_type prod_type;
+	enum rte_event_crypto_adapter_mode crypto_adptr_mode;
 };
 
 static inline bool
diff --git a/app/test-eventdev/evt_main.c b/app/test-eventdev/evt_main.c
index 194c980c7a..cef0fb1382 100644
--- a/app/test-eventdev/evt_main.c
+++ b/app/test-eventdev/evt_main.c
@@ -161,12 +161,19 @@  main(int argc, char **argv)
 			goto mempool_destroy;
 		}
 	}
+	/* Test specific cryptodev setup */
+	if (test->ops.cryptodev_setup) {
+		if (test->ops.cryptodev_setup(test, &opt)) {
+			evt_err("%s: cryptodev setup failed", opt.test_name);
+			goto ethdev_destroy;
+		}
+	}
 
 	/* Test specific eventdev setup */
 	if (test->ops.eventdev_setup) {
 		if (test->ops.eventdev_setup(test, &opt)) {
 			evt_err("%s: eventdev setup failed", opt.test_name);
-			goto ethdev_destroy;
+			goto cryptodev_destroy;
 		}
 	}
 
@@ -197,6 +204,10 @@  main(int argc, char **argv)
 	if (test->ops.eventdev_destroy)
 		test->ops.eventdev_destroy(test, &opt);
 
+cryptodev_destroy:
+	if (test->ops.cryptodev_destroy)
+		test->ops.cryptodev_destroy(test, &opt);
+
 ethdev_destroy:
 	if (test->ops.ethdev_destroy)
 		test->ops.ethdev_destroy(test, &opt);
diff --git a/app/test-eventdev/evt_options.c b/app/test-eventdev/evt_options.c
index 753a7dbd7d..5ad1491020 100644
--- a/app/test-eventdev/evt_options.c
+++ b/app/test-eventdev/evt_options.c
@@ -122,6 +122,26 @@  evt_parse_timer_prod_type_burst(struct evt_options *opt,
 	return 0;
 }
 
+static int
+evt_parse_crypto_prod_type(struct evt_options *opt,
+			   const char *arg __rte_unused)
+{
+	opt->prod_type = EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;
+	return 0;
+}
+
+static int
+evt_parse_crypto_adptr_mode(struct evt_options *opt, const char *arg)
+{
+	uint8_t mode;
+	int ret;
+
+	ret = parser_read_uint8(&mode, arg);
+	opt->crypto_adptr_mode = mode ? RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD :
+					RTE_EVENT_CRYPTO_ADAPTER_OP_NEW;
+	return ret;
+}
+
 static int
 evt_parse_test_name(struct evt_options *opt, const char *arg)
 {
@@ -335,6 +355,7 @@  usage(char *program)
 		"\t--queue_priority   : enable queue priority\n"
 		"\t--deq_tmo_nsec     : global dequeue timeout\n"
 		"\t--prod_type_ethdev : use ethernet device as producer.\n"
+		"\t--prod_type_cryptodev : use crypto device as producer.\n"
 		"\t--prod_type_timerdev : use event timer device as producer.\n"
 		"\t                     expity_nsec would be the timeout\n"
 		"\t                     in ns.\n"
@@ -345,6 +366,8 @@  usage(char *program)
 		"\t--timer_tick_nsec  : timer tick interval in ns.\n"
 		"\t--max_tmo_nsec     : max timeout interval in ns.\n"
 		"\t--expiry_nsec      : event timer expiry ns.\n"
+		"\t--crypto_adptr_mode : 0 for OP_NEW mode (default) and\n"
+		"\t                      1 for OP_FORWARD mode.\n"
 		"\t--mbuf_sz          : packet mbuf size.\n"
 		"\t--max_pkt_sz       : max packet size.\n"
 		"\t--prod_enq_burst_sz : producer enqueue burst size.\n"
@@ -415,8 +438,10 @@  static struct option lgopts[] = {
 	{ EVT_QUEUE_PRIORITY,      0, 0, 0 },
 	{ EVT_DEQ_TMO_NSEC,        1, 0, 0 },
 	{ EVT_PROD_ETHDEV,         0, 0, 0 },
+	{ EVT_PROD_CRYPTODEV,      0, 0, 0 },
 	{ EVT_PROD_TIMERDEV,       0, 0, 0 },
 	{ EVT_PROD_TIMERDEV_BURST, 0, 0, 0 },
+	{ EVT_CRYPTO_ADPTR_MODE,   1, 0, 0 },
 	{ EVT_NB_TIMERS,           1, 0, 0 },
 	{ EVT_NB_TIMER_ADPTRS,     1, 0, 0 },
 	{ EVT_TIMER_TICK_NSEC,     1, 0, 0 },
@@ -455,8 +480,10 @@  evt_opts_parse_long(int opt_idx, struct evt_options *opt)
 		{ EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
 		{ EVT_DEQ_TMO_NSEC, evt_parse_deq_tmo_nsec},
 		{ EVT_PROD_ETHDEV, evt_parse_eth_prod_type},
+		{ EVT_PROD_CRYPTODEV, evt_parse_crypto_prod_type},
 		{ EVT_PROD_TIMERDEV, evt_parse_timer_prod_type},
 		{ EVT_PROD_TIMERDEV_BURST, evt_parse_timer_prod_type_burst},
+		{ EVT_CRYPTO_ADPTR_MODE, evt_parse_crypto_adptr_mode},
 		{ EVT_NB_TIMERS, evt_parse_nb_timers},
 		{ EVT_NB_TIMER_ADPTRS, evt_parse_nb_timer_adptrs},
 		{ EVT_TIMER_TICK_NSEC, evt_parse_timer_tick_nsec},
diff --git a/app/test-eventdev/evt_options.h b/app/test-eventdev/evt_options.h
index 413d7092f0..2231c58801 100644
--- a/app/test-eventdev/evt_options.h
+++ b/app/test-eventdev/evt_options.h
@@ -9,6 +9,7 @@ 
 #include <stdbool.h>
 
 #include <rte_common.h>
+#include <rte_cryptodev.h>
 #include <rte_ethdev.h>
 #include <rte_eventdev.h>
 #include <rte_lcore.h>
@@ -33,8 +34,10 @@ 
 #define EVT_QUEUE_PRIORITY       ("queue_priority")
 #define EVT_DEQ_TMO_NSEC         ("deq_tmo_nsec")
 #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
+#define EVT_PROD_CRYPTODEV	 ("prod_type_cryptodev")
 #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
 #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
+#define EVT_CRYPTO_ADPTR_MODE	 ("crypto_adptr_mode")
 #define EVT_NB_TIMERS            ("nb_timers")
 #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
 #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
@@ -249,6 +252,8 @@  evt_prod_id_to_name(enum evt_prod_type prod_type)
 		return "Ethdev Rx Adapter";
 	case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
 		return "Event timer adapter";
+	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
+		return "Event crypto adapter";
 	}
 
 	return "";
@@ -288,6 +293,13 @@  evt_dump_producer_type(struct evt_options *opt)
 			evt_dump("timer_tick_nsec", "%"PRIu64"",
 					opt->timer_tick_nsec);
 		break;
+	case EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR:
+		snprintf(name, EVT_PROD_MAX_NAME_LEN,
+			 "Event crypto adapter producers");
+		evt_dump("crypto adapter mode", "%s",
+			 opt->crypto_adptr_mode ? "OP_FORWARD" : "OP_NEW");
+		evt_dump("nb_cryptodev", "%u", rte_cryptodev_count());
+		break;
 	}
 	evt_dump("prod_type", "%s", name);
 }
diff --git a/app/test-eventdev/evt_test.h b/app/test-eventdev/evt_test.h
index f07d2c3336..50fa474ec2 100644
--- a/app/test-eventdev/evt_test.h
+++ b/app/test-eventdev/evt_test.h
@@ -29,6 +29,8 @@  typedef int (*evt_test_mempool_setup_t)
 		(struct evt_test *test, struct evt_options *opt);
 typedef int (*evt_test_ethdev_setup_t)
 		(struct evt_test *test, struct evt_options *opt);
+typedef int (*evt_test_cryptodev_setup_t)
+		(struct evt_test *test, struct evt_options *opt);
 typedef int (*evt_test_eventdev_setup_t)
 		(struct evt_test *test, struct evt_options *opt);
 typedef int (*evt_test_launch_lcores_t)
@@ -39,6 +41,8 @@  typedef void (*evt_test_eventdev_destroy_t)
 		(struct evt_test *test, struct evt_options *opt);
 typedef void (*evt_test_ethdev_destroy_t)
 		(struct evt_test *test, struct evt_options *opt);
+typedef void (*evt_test_cryptodev_destroy_t)
+		(struct evt_test *test, struct evt_options *opt);
 typedef void (*evt_test_mempool_destroy_t)
 		(struct evt_test *test, struct evt_options *opt);
 typedef void (*evt_test_destroy_t)
@@ -52,10 +56,12 @@  struct evt_test_ops {
 	evt_test_mempool_setup_t mempool_setup;
 	evt_test_ethdev_setup_t ethdev_setup;
 	evt_test_eventdev_setup_t eventdev_setup;
+	evt_test_cryptodev_setup_t cryptodev_setup;
 	evt_test_launch_lcores_t launch_lcores;
 	evt_test_result_t test_result;
 	evt_test_eventdev_destroy_t eventdev_destroy;
 	evt_test_ethdev_destroy_t ethdev_destroy;
+	evt_test_cryptodev_destroy_t cryptodev_destroy;
 	evt_test_mempool_destroy_t mempool_destroy;
 	evt_test_destroy_t test_destroy;
 };
diff --git a/app/test-eventdev/test_perf_atq.c b/app/test-eventdev/test_perf_atq.c
index 8fd51004ee..dbb1dc8c0c 100644
--- a/app/test-eventdev/test_perf_atq.c
+++ b/app/test-eventdev/test_perf_atq.c
@@ -48,6 +48,22 @@  perf_atq_worker(void *arg, const int enable_fwd_latency)
 			continue;
 		}
 
+		if (prod_crypto_type &&
+		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
+			struct rte_crypto_op *op = ev.event_ptr;
+
+			if (op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+				if (op->sym->m_dst == NULL)
+					ev.event_ptr = op->sym->m_src;
+				else
+					ev.event_ptr = op->sym->m_dst;
+				rte_crypto_op_free(op);
+			} else {
+				rte_crypto_op_free(op);
+				continue;
+			}
+		}
+
 		if (enable_fwd_latency && !prod_timer_type)
 		/* first stage in pipeline, mark ts to compute fwd latency */
 			atq_mark_fwd_latency(&ev);
@@ -87,6 +103,25 @@  perf_atq_worker_burst(void *arg, const int enable_fwd_latency)
 		}
 
 		for (i = 0; i < nb_rx; i++) {
+			if (prod_crypto_type &&
+			    (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
+				struct rte_crypto_op *op = ev[i].event_ptr;
+
+				if (op->status ==
+				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
+					if (op->sym->m_dst == NULL)
+						ev[i].event_ptr =
+							op->sym->m_src;
+					else
+						ev[i].event_ptr =
+							op->sym->m_dst;
+					rte_crypto_op_free(op);
+				} else {
+					rte_crypto_op_free(op);
+					continue;
+				}
+			}
+
 			if (enable_fwd_latency && !prod_timer_type) {
 				rte_prefetch0(ev[i+1].event_ptr);
 				/* first stage in pipeline.
@@ -254,6 +289,20 @@  perf_atq_eventdev_setup(struct evt_test *test, struct evt_options *opt)
 				return ret;
 			}
 		}
+	} else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
+		uint8_t cdev_id, cdev_count;
+
+		cdev_count = rte_cryptodev_count();
+		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+			ret = rte_cryptodev_start(cdev_id);
+			if (ret) {
+				evt_err("Failed to start cryptodev %u",
+					cdev_id);
+				return ret;
+			}
+		}
+
+		rte_event_crypto_adapter_start(t->crypto_adptr.id);
 	}
 
 	return 0;
@@ -295,12 +344,14 @@  static const struct evt_test_ops perf_atq =  {
 	.opt_dump           = perf_atq_opt_dump,
 	.test_setup         = perf_test_setup,
 	.ethdev_setup       = perf_ethdev_setup,
+	.cryptodev_setup    = perf_cryptodev_setup,
 	.mempool_setup      = perf_mempool_setup,
 	.eventdev_setup     = perf_atq_eventdev_setup,
 	.launch_lcores      = perf_atq_launch_lcores,
 	.eventdev_destroy   = perf_eventdev_destroy,
 	.mempool_destroy    = perf_mempool_destroy,
 	.ethdev_destroy     = perf_ethdev_destroy,
+	.cryptodev_destroy  = perf_cryptodev_destroy,
 	.test_result        = perf_test_result,
 	.test_destroy       = perf_test_destroy,
 };
diff --git a/app/test-eventdev/test_perf_common.c b/app/test-eventdev/test_perf_common.c
index 9b73874151..91cb6748ee 100644
--- a/app/test-eventdev/test_perf_common.c
+++ b/app/test-eventdev/test_perf_common.c
@@ -6,6 +6,8 @@ 
 
 #include "test_perf_common.h"
 
+#define NB_CRYPTODEV_DESCRIPTORS 128
+
 int
 perf_test_result(struct evt_test *test, struct evt_options *opt)
 {
@@ -272,6 +274,125 @@  perf_event_timer_producer_burst(void *arg)
 	return 0;
 }
 
+static inline void
+crypto_adapter_enq_op_new(struct prod_data *p)
+{
+	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
+	struct test_perf *t = p->t;
+	const uint32_t nb_flows = t->nb_flows;
+	const uint64_t nb_pkts = t->nb_pkts;
+	struct rte_mempool *pool = t->pool;
+	struct rte_crypto_sym_op *sym_op;
+	struct evt_options *opt = t->opt;
+	uint16_t qp_id = p->cdev_qp_id;
+	uint8_t cdev_id = p->cdev_id;
+	uint32_t flow_counter = 0;
+	struct rte_crypto_op *op;
+	struct rte_mbuf *m;
+	uint64_t count = 0;
+	uint16_t len;
+
+	if (opt->verbose_level > 1)
+		printf("%s(): lcore %d queue %d cdev_id %u cdev_qp_id %u\n",
+		       __func__, rte_lcore_id(), p->queue_id, p->cdev_id,
+		       p->cdev_qp_id);
+
+	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
+
+	while (count < nb_pkts && t->done == false) {
+		m = rte_pktmbuf_alloc(pool);
+		if (m == NULL)
+			continue;
+
+		rte_pktmbuf_append(m, len);
+		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
+					 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+		sym_op = op->sym;
+		sym_op->m_src = m;
+		sym_op->cipher.data.offset = 0;
+		sym_op->cipher.data.length = len;
+		rte_crypto_op_attach_sym_session(
+			op, crypto_sess[flow_counter++ % nb_flows]);
+		while (rte_cryptodev_enqueue_burst(cdev_id, qp_id, &op, 1) !=
+		       1) {
+			if (t->done)
+				break;
+			rte_pause();
+		}
+		count++;
+	}
+}
+
+static inline void
+crypto_adapter_enq_op_fwd(struct prod_data *p)
+{
+	struct rte_cryptodev_sym_session **crypto_sess = p->crypto_sess;
+	const uint8_t dev_id = p->dev_id;
+	const uint8_t port = p->port_id;
+	struct test_perf *t = p->t;
+	const uint32_t nb_flows = t->nb_flows;
+	const uint64_t nb_pkts = t->nb_pkts;
+	struct rte_mempool *pool = t->pool;
+	struct evt_options *opt = t->opt;
+	struct rte_crypto_sym_op *sym_op;
+	uint32_t flow_counter = 0;
+	struct rte_crypto_op *op;
+	struct rte_event ev;
+	struct rte_mbuf *m;
+	uint64_t count = 0;
+	uint16_t len;
+
+	if (opt->verbose_level > 1)
+		printf("%s(): lcore %d port %d queue %d cdev_id %u cdev_qp_id %u\n",
+		       __func__, rte_lcore_id(), port, p->queue_id, p->cdev_id,
+		       p->cdev_qp_id);
+
+	ev.event = 0;
+	ev.op = RTE_EVENT_OP_NEW;
+	ev.queue_id = p->queue_id;
+	ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
+	ev.event_type = RTE_EVENT_TYPE_CPU;
+	len = opt->mbuf_sz ? opt->mbuf_sz : RTE_ETHER_MIN_LEN;
+
+	while (count < nb_pkts && t->done == false) {
+		m = rte_pktmbuf_alloc(pool);
+		if (m == NULL)
+			continue;
+
+		rte_pktmbuf_append(m, len);
+		op = rte_crypto_op_alloc(t->crypto_adptr.op_pool,
+					 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
+		sym_op = op->sym;
+		sym_op->m_src = m;
+		sym_op->cipher.data.offset = 0;
+		sym_op->cipher.data.length = len;
+		rte_crypto_op_attach_sym_session(
+			op, crypto_sess[flow_counter++ % nb_flows]);
+		ev.event_ptr = op;
+		while (rte_event_crypto_adapter_enqueue(dev_id, port, &ev, 1) !=
+		       1) {
+			if (t->done)
+				break;
+			rte_pause();
+		}
+		count++;
+	}
+}
+
+static inline int
+perf_event_crypto_producer(void *arg)
+{
+	struct prod_data *p = arg;
+	struct evt_options *opt = p->t->opt;
+
+	if (opt->crypto_adptr_mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
+		crypto_adapter_enq_op_new(p);
+	else
+		crypto_adapter_enq_op_fwd(p);
+
+	return 0;
+}
+
 static int
 perf_producer_wrapper(void *arg)
 {
@@ -298,6 +419,8 @@  perf_producer_wrapper(void *arg)
 	else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR &&
 			t->opt->timdev_use_burst)
 		return perf_event_timer_producer_burst(arg);
+	else if (t->opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
+		return perf_event_crypto_producer(arg);
 	return 0;
 }
 
@@ -405,8 +528,10 @@  perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 			if (remaining <= 0) {
 				t->result = EVT_TEST_SUCCESS;
 				if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
-					opt->prod_type ==
-					EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
+				    opt->prod_type ==
+					    EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
+				    opt->prod_type ==
+					    EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
 					t->done = true;
 					break;
 				}
@@ -415,7 +540,8 @@  perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 
 		if (new_cycles - dead_lock_cycles > dead_lock_sample &&
 		    (opt->prod_type == EVT_PROD_TYPE_SYNT ||
-		     opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)) {
+		     opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
+		     opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)) {
 			remaining = t->outstand_pkts - processed_pkts(t);
 			if (dead_lock_remaining == remaining) {
 				rte_event_dev_dump(opt->dev_id, stdout);
@@ -537,6 +663,96 @@  perf_event_timer_adapter_setup(struct test_perf *t)
 	return 0;
 }
 
+static int
+perf_event_crypto_adapter_setup(struct test_perf *t,
+				struct rte_event_port_conf port_conf)
+{
+	struct evt_options *opt = t->opt;
+	uint8_t cdev_id, cdev_count;
+	int ret;
+
+	t->crypto_adptr.id = 0;
+	ret = rte_event_crypto_adapter_create(t->crypto_adptr.id, opt->dev_id,
+					      &port_conf, 0);
+	if (ret)
+		return ret;
+
+	cdev_count = rte_cryptodev_count();
+	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+		uint32_t cap;
+
+		ret = rte_event_crypto_adapter_caps_get(opt->dev_id, cdev_id,
+							&cap);
+		if (ret) {
+			evt_err("Failed to get crypto adapter capabilities");
+			return ret;
+		}
+
+		if (((opt->crypto_adptr_mode ==
+		      RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) &&
+		     !(cap &
+		       RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW)) ||
+		    ((opt->crypto_adptr_mode ==
+		      RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) &&
+		     !(cap &
+		       RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD))) {
+			evt_err("crypto adapter %s mode unsupported\n",
+				opt->crypto_adptr_mode ? "OP_FORWARD" :
+							 "OP_NEW");
+			return -EINVAL;
+		}
+
+		if (!(cap &
+		      RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA)) {
+			evt_err("Storing crypto session not supported");
+			return -EINVAL;
+		}
+
+		if (cap &
+		    RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
+			struct rte_event response_info;
+
+			response_info.event = 0;
+			ret = rte_event_crypto_adapter_queue_pair_add(
+				t->crypto_adptr.id, cdev_id, -1,
+				&response_info);
+		} else {
+			ret = rte_event_crypto_adapter_queue_pair_add(
+				t->crypto_adptr.id, cdev_id, -1, NULL);
+		}
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static struct rte_cryptodev_sym_session *
+cryptodev_sym_sess_create(struct prod_data *p, struct test_perf *t)
+{
+	struct rte_crypto_sym_xform cipher_xform;
+	struct rte_cryptodev_sym_session *sess;
+
+	cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+	cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
+	cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
+	cipher_xform.next = NULL;
+
+	sess = rte_cryptodev_sym_session_create(t->crypto_adptr.sess_pool);
+	if (sess == NULL) {
+		evt_err("Failed to create sym session");
+		return NULL;
+	}
+
+	if (rte_cryptodev_sym_session_init(p->cdev_id, sess, &cipher_xform,
+					   t->crypto_adptr.sess_priv_pool)) {
+		evt_err("Failed to init session");
+		return NULL;
+	}
+
+	return sess;
+}
+
 int
 perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
 				uint8_t stride, uint8_t nb_queues,
@@ -598,6 +814,55 @@  perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
 		ret = perf_event_timer_adapter_setup(t);
 		if (ret)
 			return ret;
+	} else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
+		uint8_t cdev_id = 0;
+		uint16_t qp_id = 0;
+
+		prod = 0;
+		for (; port < perf_nb_event_ports(opt); port++) {
+			struct rte_cryptodev_sym_session *crypto_sess;
+			union rte_event_crypto_metadata m_data;
+			struct prod_data *p = &t->prod[port];
+			uint32_t flow_id;
+
+			if (qp_id == rte_cryptodev_queue_pair_count(cdev_id)) {
+				cdev_id++;
+				qp_id = 0;
+			}
+
+			p->dev_id = opt->dev_id;
+			p->port_id = port;
+			p->queue_id = prod * stride;
+			p->cdev_id = cdev_id;
+			p->cdev_qp_id = qp_id;
+			p->crypto_sess = rte_zmalloc_socket(
+				NULL, sizeof(crypto_sess) * t->nb_flows,
+				RTE_CACHE_LINE_SIZE, opt->socket_id);
+
+			m_data.request_info.cdev_id = p->cdev_id;
+			m_data.request_info.queue_pair_id = p->cdev_qp_id;
+			m_data.response_info.op = RTE_EVENT_OP_NEW;
+			m_data.response_info.sched_type = RTE_SCHED_TYPE_ATOMIC;
+			m_data.response_info.event_type = RTE_EVENT_TYPE_CPU;
+			m_data.response_info.queue_id = p->queue_id;
+			for (flow_id = 0; flow_id < t->nb_flows; flow_id++) {
+				crypto_sess = cryptodev_sym_sess_create(p, t);
+				if (crypto_sess == NULL)
+					return -ENOMEM;
+
+				m_data.response_info.flow_id = flow_id;
+				rte_cryptodev_sym_session_set_user_data(
+					crypto_sess, &m_data, sizeof(m_data));
+				p->crypto_sess[flow_id] = crypto_sess;
+			}
+			p->t = t;
+			qp_id++;
+			prod++;
+		}
+
+		ret = perf_event_crypto_adapter_setup(t, *port_conf);
+		if (ret)
+			return ret;
 	} else {
 		prod = 0;
 		for ( ; port < perf_nb_event_ports(opt); port++) {
@@ -659,7 +924,8 @@  perf_opt_check(struct evt_options *opt, uint64_t nb_queues)
 	}
 
 	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
-			opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
+	    opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
+	    opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
 		/* Validate producer lcores */
 		if (evt_lcores_has_overlap(opt->plcores,
 					rte_get_main_lcore())) {
@@ -767,8 +1033,7 @@  perf_ethdev_setup(struct evt_test *test, struct evt_options *opt)
 		},
 	};
 
-	if (opt->prod_type == EVT_PROD_TYPE_SYNT ||
-			opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR)
+	if (opt->prod_type != EVT_PROD_TYPE_ETH_RX_ADPTR)
 		return 0;
 
 	if (!rte_eth_dev_count_avail()) {
@@ -841,6 +1106,139 @@  void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt)
 	}
 }
 
+int
+perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt)
+{
+	uint8_t cdev_count, cdev_id, nb_plcores, nb_qps;
+	struct test_perf *t = evt_test_priv(test);
+	unsigned int max_session_size;
+	uint32_t nb_sessions;
+	int ret;
+
+	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
+		return 0;
+
+	cdev_count = rte_cryptodev_count();
+	if (cdev_count == 0) {
+		evt_err("No crypto devices available\n");
+		return -ENODEV;
+	}
+
+	t->crypto_adptr.op_pool = rte_crypto_op_pool_create(
+		"crypto_op_pool", RTE_CRYPTO_OP_TYPE_SYMMETRIC, opt->pool_sz,
+		128, 0, rte_socket_id());
+	if (t->crypto_adptr.op_pool == NULL) {
+		evt_err("Failed to create crypto op pool");
+		return -ENOMEM;
+	}
+
+	nb_sessions = evt_nr_active_lcores(opt->plcores) * t->nb_flows;
+	t->crypto_adptr.sess_pool = rte_cryptodev_sym_session_pool_create(
+		"ca_sess_pool", nb_sessions, 0, 0,
+		sizeof(union rte_event_crypto_metadata), SOCKET_ID_ANY);
+	if (t->crypto_adptr.sess_pool == NULL) {
+		evt_err("Failed to create sym session pool");
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	max_session_size = 0;
+	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+		unsigned int session_size;
+
+		session_size =
+			rte_cryptodev_sym_get_private_session_size(cdev_id);
+		if (session_size > max_session_size)
+			max_session_size = session_size;
+	}
+	max_session_size += sizeof(union rte_event_crypto_metadata);
+	t->crypto_adptr.sess_priv_pool = rte_mempool_create(
+		"ca_sess_priv_pool", nb_sessions, max_session_size, 0, 0, NULL,
+		NULL, NULL, NULL, SOCKET_ID_ANY, 0);
+	if (t->crypto_adptr.sess_priv_pool == NULL) {
+		evt_err("failed to create sym session private pool");
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	nb_plcores = evt_nr_active_lcores(opt->plcores);
+	nb_qps = (nb_plcores % cdev_count) ? (nb_plcores / cdev_count) + 1 :
+					     nb_plcores / cdev_count;
+	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+		struct rte_cryptodev_qp_conf qp_conf;
+		struct rte_cryptodev_config conf;
+		struct rte_cryptodev_info info;
+		int qp_id;
+
+		rte_cryptodev_info_get(cdev_id, &info);
+		if (nb_qps > info.max_nb_queue_pairs) {
+			evt_err("Not enough queue pairs per cryptodev (%u)",
+				nb_qps);
+			ret = -EINVAL;
+			goto err;
+		}
+
+		conf.nb_queue_pairs = nb_qps;
+		conf.socket_id = SOCKET_ID_ANY;
+		conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
+
+		ret = rte_cryptodev_configure(cdev_id, &conf);
+		if (ret) {
+			evt_err("Failed to configure cryptodev (%u)", cdev_id);
+			goto err;
+		}
+
+		qp_conf.nb_descriptors = NB_CRYPTODEV_DESCRIPTORS;
+		qp_conf.mp_session = t->crypto_adptr.sess_pool;
+		qp_conf.mp_session_private = t->crypto_adptr.sess_priv_pool;
+
+		for (qp_id = 0; qp_id < conf.nb_queue_pairs; qp_id++) {
+			ret = rte_cryptodev_queue_pair_setup(
+				cdev_id, qp_id, &qp_conf,
+				rte_cryptodev_socket_id(cdev_id));
+			if (ret) {
+				evt_err("Failed to setup queue pairs on cryptodev %u\n",
+					cdev_id);
+				goto err;
+			}
+		}
+	}
+
+	return 0;
+err:
+	rte_mempool_free(t->crypto_adptr.op_pool);
+	rte_mempool_free(t->crypto_adptr.sess_pool);
+	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
+
+	return ret;
+}
+
+void
+perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt)
+{
+	uint8_t cdev_id, cdev_count = rte_cryptodev_count();
+	struct test_perf *t = evt_test_priv(test);
+
+	RTE_SET_USED(opt);
+
+	if (opt->prod_type != EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
+		return;
+
+	rte_event_crypto_adapter_stop(t->crypto_adptr.id);
+
+	for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+		rte_cryptodev_stop(cdev_id);
+		rte_event_crypto_adapter_queue_pair_del(t->crypto_adptr.id,
+							cdev_id, -1);
+	}
+
+	rte_event_crypto_adapter_free(t->crypto_adptr.id);
+
+	rte_mempool_free(t->crypto_adptr.op_pool);
+	rte_mempool_free(t->crypto_adptr.sess_pool);
+	rte_mempool_free(t->crypto_adptr.sess_priv_pool);
+}
+
 int
 perf_mempool_setup(struct evt_test *test, struct evt_options *opt)
 {
diff --git a/app/test-eventdev/test_perf_common.h b/app/test-eventdev/test_perf_common.h
index 14dcf80429..d9ad3a0b0d 100644
--- a/app/test-eventdev/test_perf_common.h
+++ b/app/test-eventdev/test_perf_common.h
@@ -9,9 +9,11 @@ 
 #include <stdbool.h>
 #include <unistd.h>
 
+#include <rte_cryptodev.h>
 #include <rte_cycles.h>
 #include <rte_ethdev.h>
 #include <rte_eventdev.h>
+#include <rte_event_crypto_adapter.h>
 #include <rte_event_eth_rx_adapter.h>
 #include <rte_event_timer_adapter.h>
 #include <rte_lcore.h>
@@ -37,9 +39,18 @@  struct prod_data {
 	uint8_t dev_id;
 	uint8_t port_id;
 	uint8_t queue_id;
+	uint8_t cdev_id;
+	uint16_t cdev_qp_id;
+	struct rte_cryptodev_sym_session **crypto_sess;
 	struct test_perf *t;
 } __rte_cache_aligned;
 
+struct crypto_adptr_data {
+	uint8_t id;
+	struct rte_mempool *op_pool;
+	struct rte_mempool *sess_pool;
+	struct rte_mempool *sess_priv_pool;
+};
 
 struct test_perf {
 	/* Don't change the offset of "done". Signal handler use this memory
@@ -58,6 +69,7 @@  struct test_perf {
 	uint8_t sched_type_list[EVT_MAX_STAGES] __rte_cache_aligned;
 	struct rte_event_timer_adapter *timer_adptr[
 		RTE_EVENT_TIMER_ADAPTER_NUM_MAX] __rte_cache_aligned;
+	struct crypto_adptr_data crypto_adptr;
 } __rte_cache_aligned;
 
 struct perf_elt {
@@ -81,6 +93,8 @@  struct perf_elt {
 	const uint8_t port = w->port_id;\
 	const uint8_t prod_timer_type = \
 		opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR;\
+	const uint8_t prod_crypto_type = \
+		opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR;\
 	uint8_t *const sched_type_list = &t->sched_type_list[0];\
 	struct rte_mempool *const pool = t->pool;\
 	const uint8_t nb_stages = t->opt->nb_stages;\
@@ -154,6 +168,7 @@  int perf_test_result(struct evt_test *test, struct evt_options *opt);
 int perf_opt_check(struct evt_options *opt, uint64_t nb_queues);
 int perf_test_setup(struct evt_test *test, struct evt_options *opt);
 int perf_ethdev_setup(struct evt_test *test, struct evt_options *opt);
+int perf_cryptodev_setup(struct evt_test *test, struct evt_options *opt);
 int perf_mempool_setup(struct evt_test *test, struct evt_options *opt);
 int perf_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
 				uint8_t stride, uint8_t nb_queues,
@@ -164,6 +179,7 @@  int perf_launch_lcores(struct evt_test *test, struct evt_options *opt,
 void perf_opt_dump(struct evt_options *opt, uint8_t nb_queues);
 void perf_test_destroy(struct evt_test *test, struct evt_options *opt);
 void perf_eventdev_destroy(struct evt_test *test, struct evt_options *opt);
+void perf_cryptodev_destroy(struct evt_test *test, struct evt_options *opt);
 void perf_ethdev_destroy(struct evt_test *test, struct evt_options *opt);
 void perf_mempool_destroy(struct evt_test *test, struct evt_options *opt);
 
diff --git a/app/test-eventdev/test_perf_queue.c b/app/test-eventdev/test_perf_queue.c
index f4ea3a795f..5657c8b3cd 100644
--- a/app/test-eventdev/test_perf_queue.c
+++ b/app/test-eventdev/test_perf_queue.c
@@ -49,6 +49,23 @@  perf_queue_worker(void *arg, const int enable_fwd_latency)
 			rte_pause();
 			continue;
 		}
+
+		if (prod_crypto_type &&
+		    (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
+			struct rte_crypto_op *op = ev.event_ptr;
+
+			if (op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
+				if (op->sym->m_dst == NULL)
+					ev.event_ptr = op->sym->m_src;
+				else
+					ev.event_ptr = op->sym->m_dst;
+				rte_crypto_op_free(op);
+			} else {
+				rte_crypto_op_free(op);
+				continue;
+			}
+		}
+
 		if (enable_fwd_latency && !prod_timer_type)
 		/* first q in pipeline, mark timestamp to compute fwd latency */
 			mark_fwd_latency(&ev, nb_stages);
@@ -88,6 +105,25 @@  perf_queue_worker_burst(void *arg, const int enable_fwd_latency)
 		}
 
 		for (i = 0; i < nb_rx; i++) {
+			if (prod_crypto_type &&
+			    (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
+				struct rte_crypto_op *op = ev[i].event_ptr;
+
+				if (op->status ==
+				    RTE_CRYPTO_OP_STATUS_SUCCESS) {
+					if (op->sym->m_dst == NULL)
+						ev[i].event_ptr =
+							op->sym->m_src;
+					else
+						ev[i].event_ptr =
+							op->sym->m_dst;
+					rte_crypto_op_free(op);
+				} else {
+					rte_crypto_op_free(op);
+					continue;
+				}
+			}
+
 			if (enable_fwd_latency && !prod_timer_type) {
 				rte_prefetch0(ev[i+1].event_ptr);
 				/* first queue in pipeline.
@@ -269,6 +305,20 @@  perf_queue_eventdev_setup(struct evt_test *test, struct evt_options *opt)
 				return ret;
 			}
 		}
+	} else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
+		uint8_t cdev_id, cdev_count;
+
+		cdev_count = rte_cryptodev_count();
+		for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
+			ret = rte_cryptodev_start(cdev_id);
+			if (ret) {
+				evt_err("Failed to start cryptodev %u",
+					cdev_id);
+				return ret;
+			}
+		}
+
+		rte_event_crypto_adapter_start(t->crypto_adptr.id);
 	}
 
 	return 0;
@@ -311,11 +361,13 @@  static const struct evt_test_ops perf_queue =  {
 	.test_setup         = perf_test_setup,
 	.mempool_setup      = perf_mempool_setup,
 	.ethdev_setup	    = perf_ethdev_setup,
+	.cryptodev_setup    = perf_cryptodev_setup,
 	.eventdev_setup     = perf_queue_eventdev_setup,
 	.launch_lcores      = perf_queue_launch_lcores,
 	.eventdev_destroy   = perf_eventdev_destroy,
 	.mempool_destroy    = perf_mempool_destroy,
 	.ethdev_destroy	    = perf_ethdev_destroy,
+	.cryptodev_destroy  = perf_cryptodev_destroy,
 	.test_result        = perf_test_result,
 	.test_destroy       = perf_test_destroy,
 };
diff --git a/doc/guides/tools/testeventdev.rst b/doc/guides/tools/testeventdev.rst
index 48efb9ea6e..f7d813226d 100644
--- a/doc/guides/tools/testeventdev.rst
+++ b/doc/guides/tools/testeventdev.rst
@@ -120,6 +120,10 @@  The following are the application command-line options:
 
        Use burst mode event timer adapter as producer.
 
+* ``--prod_type_cryptodev``
+
+        Use crypto device as producer.
+
 * ``--timer_tick_nsec``
 
        Used to dictate number of nano seconds between bucket traversal of the
@@ -148,6 +152,11 @@  The following are the application command-line options:
        timeout is out of the supported range of event device it will be
        adjusted to the highest/lowest supported dequeue timeout supported.
 
+* ``--crypto_adptr_mode``
+
+        Set crypto adapter mode. Use 0 for OP_NEW (default) and 1 for
+        OP_FORWARD mode.
+
 * ``--mbuf_sz``
 
        Set packet mbuf size. Can be used to configure Jumbo Frames. Only
@@ -420,6 +429,7 @@  Supported application command line options are following::
         --prod_type_ethdev
         --prod_type_timerdev_burst
         --prod_type_timerdev
+        --prod_type_cryptodev
         --prod_enq_burst_sz
         --timer_tick_nsec
         --max_tmo_nsec
@@ -427,6 +437,7 @@  Supported application command line options are following::
         --nb_timers
         --nb_timer_adptrs
         --deq_tmo_nsec
+        --crypto_adptr_mode
 
 Example
 ^^^^^^^
@@ -529,12 +540,14 @@  Supported application command line options are following::
         --prod_type_ethdev
         --prod_type_timerdev_burst
         --prod_type_timerdev
+        --prod_type_cryptodev
         --timer_tick_nsec
         --max_tmo_nsec
         --expiry_nsec
         --nb_timers
         --nb_timer_adptrs
         --deq_tmo_nsec
+        --crypto_adptr_mode
 
 Example
 ^^^^^^^