cryptodev: add auth IV

[dpdk.git] / app / test-crypto-perf / cperf_test_latency.c

diff --git a/app/test-crypto-perf/cperf_test_latency.c b/app/test-crypto-perf/cperf_test_latency.c
index e61ac97..9ac932a 100644 (file)
--- a/app/test-crypto-perf/cperf_test_latency.c
+++ b/app/test-crypto-perf/cperf_test_latency.c
@@ -66,6 +66,10 @@ struct cperf_latency_ctx {
        struct cperf_op_result *res;
 };
 
+struct priv_op_data {
+       struct cperf_op_result *result;
+};
+
 #define max(a, b) (a > b ? (uint64_t)a : (uint64_t)b)
 #define min(a, b) (a < b ? (uint64_t)a : (uint64_t)b)
 
@@ -207,7 +211,12 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id,
        ctx->options = options;
        ctx->test_vector = test_vector;
 
-       ctx->sess = op_fns->sess_create(dev_id, options, test_vector);
+       /* IV goes at the end of the crypto operation */
+       uint16_t iv_offset = sizeof(struct rte_crypto_op) +
+               sizeof(struct rte_crypto_sym_op) +
+               sizeof(struct cperf_op_result *);
+
+       ctx->sess = op_fns->sess_create(dev_id, options, test_vector, iv_offset);
        if (ctx->sess == NULL)
                goto err;
 
@@ -276,9 +285,13 @@ cperf_latency_test_constructor(uint8_t dev_id, uint16_t qp_id,
        snprintf(pool_name, sizeof(pool_name), "cperf_op_pool_cdev_%d",
                        dev_id);
 
+       uint16_t priv_size = sizeof(struct priv_op_data) +
+                       test_vector->cipher_iv.length +
+                       test_vector->auth_iv.length;
        ctx->crypto_op_pool = rte_crypto_op_pool_create(pool_name,
-                       RTE_CRYPTO_OP_TYPE_SYMMETRIC, options->pool_sz, 0, 0,
-                       rte_socket_id());
+                       RTE_CRYPTO_OP_TYPE_SYMMETRIC, options->pool_sz,
+                       512, priv_size, rte_socket_id());
+
        if (ctx->crypto_op_pool == NULL)
                goto err;
 
@@ -295,11 +308,20 @@ err:
        return NULL;
 }
 
+static inline void
+store_timestamp(struct rte_crypto_op *op, uint64_t timestamp)
+{
+       struct priv_op_data *priv_data;
+
+       priv_data = (struct priv_op_data *) (op->sym + 1);
+       priv_data->result->status = op->status;
+       priv_data->result->tsc_end = timestamp;
+}
+
 int
 cperf_latency_test_runner(void *arg)
 {
        struct cperf_latency_ctx *ctx = arg;
-       struct cperf_op_result *pres;
        uint16_t test_burst_size;
        uint8_t burst_size_idx = 0;
 
@@ -311,6 +333,7 @@ cperf_latency_test_runner(void *arg)
        struct rte_crypto_op *ops[ctx->options->max_burst_size];
        struct rte_crypto_op *ops_processed[ctx->options->max_burst_size];
        uint64_t i;
+       struct priv_op_data *priv_data;
 
        uint32_t lcore = rte_lcore_id();
 
@@ -339,6 +362,10 @@ cperf_latency_test_runner(void *arg)
        else
                test_burst_size = ctx->options->burst_size_list[0];
 
+       uint16_t iv_offset = sizeof(struct rte_crypto_op) +
+               sizeof(struct rte_crypto_sym_op) +
+               sizeof(struct cperf_op_result *);
+
        while (test_burst_size <= ctx->options->max_burst_size) {
                uint64_t ops_enqd = 0, ops_deqd = 0;
                uint64_t m_idx = 0, b_idx = 0;
@@ -367,7 +394,7 @@ cperf_latency_test_runner(void *arg)
                        (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx],
                                        &ctx->mbufs_out[m_idx],
                                        burst_size, ctx->sess, ctx->options,
-                                       ctx->test_vector);
+                                       ctx->test_vector, iv_offset);
 
                        tsc_start = rte_rdtsc_precise();
 
@@ -393,12 +420,19 @@ cperf_latency_test_runner(void *arg)
                        tsc_end = rte_rdtsc_precise();
 
                        /* Free memory for not enqueued operations */
-                       for (i = ops_enqd; i < burst_size; i++)
-                               rte_crypto_op_free(ops[i]);
+                       if (ops_enqd != burst_size)
+                               rte_mempool_put_bulk(ctx->crypto_op_pool,
+                                               (void **)&ops_processed[ops_enqd],
+                                               burst_size - ops_enqd);
 
                        for (i = 0; i < ops_enqd; i++) {
                                ctx->res[tsc_idx].tsc_start = tsc_start;
-                               ops[i]->opaque_data = (void *)&ctx->res[tsc_idx];
+                               /*
+                                * Private data structure starts after the end of the
+                                * rte_crypto_sym_op structure.
+                                */
+                               priv_data = (struct priv_op_data *) (ops[i]->sym + 1);
+                               priv_data->result = (void *)&ctx->res[tsc_idx];
                                tsc_idx++;
                        }
 
@@ -409,14 +443,11 @@ cperf_latency_test_runner(void *arg)
                                 * the crypto operation will change the data and cause
                                 * failures.
                                 */
-                               for (i = 0; i < ops_deqd; i++) {
-                                       pres = (struct cperf_op_result *)
-                                                       (ops_processed[i]->opaque_data);
-                                       pres->status = ops_processed[i]->status;
-                                       pres->tsc_end = tsc_end;
+                               for (i = 0; i < ops_deqd; i++)
+                                       store_timestamp(ops_processed[i], tsc_end);
 
-                                       rte_crypto_op_free(ops_processed[i]);
-                               }
+                               rte_mempool_put_bulk(ctx->crypto_op_pool,
+                                               (void **)ops_processed, ops_deqd);
 
                                deqd_tot += ops_deqd;
                                deqd_max = max(ops_deqd, deqd_max);
@@ -445,14 +476,11 @@ cperf_latency_test_runner(void *arg)
                        tsc_end = rte_rdtsc_precise();
 
                        if (ops_deqd != 0) {
-                               for (i = 0; i < ops_deqd; i++) {
-                                       pres = (struct cperf_op_result *)
-                                                       (ops_processed[i]->opaque_data);
-                                       pres->status = ops_processed[i]->status;
-                                       pres->tsc_end = tsc_end;
-
-                                       rte_crypto_op_free(ops_processed[i]);
-                               }
+                               for (i = 0; i < ops_deqd; i++)
+                                       store_timestamp(ops_processed[i], tsc_end);
+
+                               rte_mempool_put_bulk(ctx->crypto_op_pool,
+                                               (void **)ops_processed, ops_deqd);
 
                                deqd_tot += ops_deqd;
                                deqd_max = max(ops_deqd, deqd_max);