LCOV - code coverage report
Current view: top level - app/test-crypto-perf - cperf_test_latency.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 129 0.0 %
Date: 2024-04-01 19:00:53 Functions: 0 4 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2016-2017 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <rte_malloc.h>
       6                 :            : #include <rte_cycles.h>
       7                 :            : #include <rte_crypto.h>
       8                 :            : #include <rte_cryptodev.h>
       9                 :            : 
      10                 :            : #include "cperf_test_latency.h"
      11                 :            : #include "cperf_ops.h"
      12                 :            : #include "cperf_test_common.h"
      13                 :            : 
      14                 :            : struct cperf_op_result {
      15                 :            :         uint64_t tsc_start;
      16                 :            :         uint64_t tsc_end;
      17                 :            :         enum rte_crypto_op_status status;
      18                 :            : };
      19                 :            : 
      20                 :            : struct cperf_latency_ctx {
      21                 :            :         uint8_t dev_id;
      22                 :            :         uint16_t qp_id;
      23                 :            :         uint8_t lcore_id;
      24                 :            : 
      25                 :            :         struct rte_mempool *pool;
      26                 :            : 
      27                 :            :         void *sess;
      28                 :            : 
      29                 :            :         cperf_populate_ops_t populate_ops;
      30                 :            : 
      31                 :            :         uint32_t src_buf_offset;
      32                 :            :         uint32_t dst_buf_offset;
      33                 :            : 
      34                 :            :         const struct cperf_options *options;
      35                 :            :         const struct cperf_test_vector *test_vector;
      36                 :            :         struct cperf_op_result *res;
      37                 :            : };
      38                 :            : 
      39                 :            : struct priv_op_data {
      40                 :            :         struct cperf_op_result *result;
      41                 :            : };
      42                 :            : 
      43                 :            : static void
      44                 :          0 : cperf_latency_test_free(struct cperf_latency_ctx *ctx)
      45                 :            : {
      46                 :          0 :         if (ctx == NULL)
      47                 :            :                 return;
      48                 :            : 
      49                 :          0 :         if (ctx->sess != NULL) {
      50                 :          0 :                 if (ctx->options->op_type == CPERF_ASYM_MODEX)
      51                 :          0 :                         rte_cryptodev_asym_session_free(ctx->dev_id, ctx->sess);
      52                 :            : #ifdef RTE_LIB_SECURITY
      53                 :          0 :                 else if (ctx->options->op_type == CPERF_PDCP ||
      54                 :          0 :                          ctx->options->op_type == CPERF_DOCSIS ||
      55                 :          0 :                          ctx->options->op_type == CPERF_TLS ||
      56                 :          0 :                          ctx->options->op_type == CPERF_IPSEC) {
      57                 :          0 :                         void *sec_ctx = rte_cryptodev_get_sec_ctx(ctx->dev_id);
      58                 :          0 :                         rte_security_session_destroy(sec_ctx, ctx->sess);
      59                 :            :                 }
      60                 :            : #endif
      61                 :            :                 else
      62                 :          0 :                         rte_cryptodev_sym_session_free(ctx->dev_id, ctx->sess);
      63                 :            :         }
      64                 :            : 
      65                 :          0 :         rte_mempool_free(ctx->pool);
      66                 :          0 :         rte_free(ctx->res);
      67                 :          0 :         rte_free(ctx);
      68                 :            : }
      69                 :            : 
      70                 :            : void *
      71                 :          0 : cperf_latency_test_constructor(struct rte_mempool *sess_mp,
      72                 :            :                 uint8_t dev_id, uint16_t qp_id,
      73                 :            :                 const struct cperf_options *options,
      74                 :            :                 const struct cperf_test_vector *test_vector,
      75                 :            :                 const struct cperf_op_fns *op_fns)
      76                 :            : {
      77                 :            :         struct cperf_latency_ctx *ctx = NULL;
      78                 :            :         size_t extra_op_priv_size = sizeof(struct priv_op_data);
      79                 :            : 
      80                 :          0 :         ctx = rte_malloc(NULL, sizeof(struct cperf_latency_ctx), 0);
      81                 :          0 :         if (ctx == NULL)
      82                 :          0 :                 goto err;
      83                 :            : 
      84                 :          0 :         ctx->dev_id = dev_id;
      85                 :          0 :         ctx->qp_id = qp_id;
      86                 :            : 
      87                 :          0 :         ctx->populate_ops = op_fns->populate_ops;
      88                 :          0 :         ctx->options = options;
      89                 :          0 :         ctx->test_vector = test_vector;
      90                 :            : 
      91                 :            :         /* IV goes at the end of the crypto operation */
      92                 :            :         uint16_t iv_offset = sizeof(struct rte_crypto_op) +
      93                 :            :                 sizeof(struct rte_crypto_sym_op) +
      94                 :            :                 sizeof(struct cperf_op_result *);
      95                 :            : 
      96                 :          0 :         ctx->sess = op_fns->sess_create(sess_mp, dev_id, options,
      97                 :            :                         test_vector, iv_offset);
      98                 :          0 :         if (ctx->sess == NULL)
      99                 :          0 :                 goto err;
     100                 :            : 
     101                 :          0 :         if (cperf_alloc_common_memory(options, test_vector, dev_id, qp_id,
     102                 :            :                         extra_op_priv_size,
     103                 :            :                         &ctx->src_buf_offset, &ctx->dst_buf_offset,
     104                 :            :                         &ctx->pool) < 0)
     105                 :          0 :                 goto err;
     106                 :            : 
     107                 :          0 :         ctx->res = rte_malloc(NULL, sizeof(struct cperf_op_result) *
     108                 :          0 :                         ctx->options->total_ops, 0);
     109                 :            : 
     110                 :          0 :         if (ctx->res == NULL)
     111                 :          0 :                 goto err;
     112                 :            : 
     113                 :            :         return ctx;
     114                 :          0 : err:
     115                 :          0 :         cperf_latency_test_free(ctx);
     116                 :            : 
     117                 :          0 :         return NULL;
     118                 :            : }
     119                 :            : 
     120                 :            : static inline void
     121                 :            : store_timestamp(struct rte_crypto_op *op, uint64_t timestamp)
     122                 :            : {
     123                 :            :         struct priv_op_data *priv_data;
     124                 :            : 
     125                 :            :         priv_data = (struct priv_op_data *) (op->sym + 1);
     126                 :          0 :         priv_data->result->status = op->status;
     127                 :          0 :         priv_data->result->tsc_end = timestamp;
     128                 :            : }
     129                 :            : 
     130                 :            : int
     131                 :          0 : cperf_latency_test_runner(void *arg)
     132                 :          0 : {
     133                 :            :         struct cperf_latency_ctx *ctx = arg;
     134                 :            :         uint16_t test_burst_size;
     135                 :            :         uint8_t burst_size_idx = 0;
     136                 :          0 :         uint32_t imix_idx = 0;
     137                 :            :         int ret = 0;
     138                 :            : 
     139                 :            :         static uint16_t display_once;
     140                 :            : 
     141                 :          0 :         if (ctx == NULL)
     142                 :            :                 return 0;
     143                 :            : 
     144                 :          0 :         struct rte_crypto_op *ops[ctx->options->max_burst_size];
     145                 :          0 :         struct rte_crypto_op *ops_processed[ctx->options->max_burst_size];
     146                 :            :         uint64_t i;
     147                 :            :         struct priv_op_data *priv_data;
     148                 :            : 
     149                 :            :         uint32_t lcore = rte_lcore_id();
     150                 :            : 
     151                 :            : #ifdef CPERF_LINEARIZATION_ENABLE
     152                 :            :         struct rte_cryptodev_info dev_info;
     153                 :            :         int linearize = 0;
     154                 :            : 
     155                 :            :         /* Check if source mbufs require coalescing */
     156                 :            :         if (ctx->options->segment_sz < ctx->options->max_buffer_size) {
     157                 :            :                 rte_cryptodev_info_get(ctx->dev_id, &dev_info);
     158                 :            :                 if ((dev_info.feature_flags &
     159                 :            :                                 RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER) == 0)
     160                 :            :                         linearize = 1;
     161                 :            :         }
     162                 :            : #endif /* CPERF_LINEARIZATION_ENABLE */
     163                 :            : 
     164                 :          0 :         ctx->lcore_id = lcore;
     165                 :            : 
     166                 :            :         /* Warm up the host CPU before starting the test */
     167                 :          0 :         for (i = 0; i < ctx->options->total_ops; i++)
     168                 :          0 :                 rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0);
     169                 :            : 
     170                 :            :         /* Get first size from range or list */
     171                 :          0 :         if (ctx->options->inc_burst_size != 0)
     172                 :          0 :                 test_burst_size = ctx->options->min_burst_size;
     173                 :            :         else
     174                 :          0 :                 test_burst_size = ctx->options->burst_size_list[0];
     175                 :            : 
     176                 :            :         uint16_t iv_offset = sizeof(struct rte_crypto_op) +
     177                 :            :                 sizeof(struct rte_crypto_sym_op) +
     178                 :            :                 sizeof(struct cperf_op_result *);
     179                 :            : 
     180                 :          0 :         while (test_burst_size <= ctx->options->max_burst_size) {
     181                 :            :                 uint64_t ops_enqd = 0, ops_deqd = 0;
     182                 :            :                 uint64_t b_idx = 0;
     183                 :            : 
     184                 :            :                 uint64_t tsc_val, tsc_end, tsc_start;
     185                 :            :                 uint64_t tsc_max = 0, tsc_min = ~0UL, tsc_tot = 0, tsc_idx = 0;
     186                 :            :                 uint64_t enqd_max = 0, enqd_min = ~0UL, enqd_tot = 0;
     187                 :            :                 uint64_t deqd_max = 0, deqd_min = ~0UL, deqd_tot = 0;
     188                 :            : 
     189                 :          0 :                 while (enqd_tot < ctx->options->total_ops) {
     190                 :            : 
     191                 :          0 :                         uint16_t burst_size = ((enqd_tot + test_burst_size)
     192                 :            :                                         <= ctx->options->total_ops) ?
     193                 :            :                                                         test_burst_size :
     194                 :          0 :                                                         ctx->options->total_ops -
     195                 :            :                                                         enqd_tot;
     196                 :            : 
     197                 :            :                         /* Allocate objects containing crypto operations and mbufs */
     198                 :          0 :                         if (rte_mempool_get_bulk(ctx->pool, (void **)ops,
     199                 :            :                                                 burst_size) != 0) {
     200                 :          0 :                                 RTE_LOG(ERR, USER1,
     201                 :            :                                         "Failed to allocate more crypto operations "
     202                 :            :                                         "from the crypto operation pool.\n"
     203                 :            :                                         "Consider increasing the pool size "
     204                 :            :                                         "with --pool-sz\n");
     205                 :          0 :                                 return -1;
     206                 :            :                         }
     207                 :            : 
     208                 :            :                         /* Setup crypto op, attach mbuf etc */
     209                 :          0 :                         (ctx->populate_ops)(ops, ctx->src_buf_offset,
     210                 :            :                                         ctx->dst_buf_offset,
     211                 :            :                                         burst_size, ctx->sess, ctx->options,
     212                 :            :                                         ctx->test_vector, iv_offset,
     213                 :            :                                         &imix_idx, &tsc_start);
     214                 :            : 
     215                 :            :                         /* Populate the mbuf with the test vector */
     216                 :          0 :                         for (i = 0; i < burst_size; i++)
     217                 :          0 :                                 cperf_mbuf_set(ops[i]->sym->m_src,
     218                 :            :                                                 ctx->options,
     219                 :            :                                                 ctx->test_vector);
     220                 :            : 
     221                 :          0 :                         tsc_start = rte_rdtsc_precise();
     222                 :            : 
     223                 :            : #ifdef CPERF_LINEARIZATION_ENABLE
     224                 :            :                         if (linearize) {
     225                 :            :                                 /* PMD doesn't support scatter-gather and source buffer
     226                 :            :                                  * is segmented.
     227                 :            :                                  * We need to linearize it before enqueuing.
     228                 :            :                                  */
     229                 :            :                                 for (i = 0; i < burst_size; i++)
     230                 :            :                                         rte_pktmbuf_linearize(ops[i]->sym->m_src);
     231                 :            :                         }
     232                 :            : #endif /* CPERF_LINEARIZATION_ENABLE */
     233                 :            : 
     234                 :            :                         /* Enqueue burst of ops on crypto device */
     235                 :          0 :                         ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id,
     236                 :            :                                         ops, burst_size);
     237                 :            : 
     238                 :            :                         /* Dequeue processed burst of ops from crypto device */
     239                 :          0 :                         ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
     240                 :            :                                         ops_processed, test_burst_size);
     241                 :            : 
     242                 :            :                         tsc_end = rte_rdtsc_precise();
     243                 :            : 
     244                 :            :                         /* Free memory for not enqueued operations */
     245                 :          0 :                         if (ops_enqd != burst_size)
     246                 :          0 :                                 rte_mempool_put_bulk(ctx->pool,
     247                 :          0 :                                                 (void **)&ops[ops_enqd],
     248                 :            :                                                 burst_size - ops_enqd);
     249                 :            : 
     250                 :          0 :                         for (i = 0; i < ops_enqd; i++) {
     251                 :          0 :                                 ctx->res[tsc_idx].tsc_start = tsc_start;
     252                 :            :                                 /*
     253                 :            :                                  * Private data structure starts after the end of the
     254                 :            :                                  * rte_crypto_sym_op structure.
     255                 :            :                                  */
     256                 :          0 :                                 priv_data = (struct priv_op_data *) (ops[i]->sym + 1);
     257                 :          0 :                                 priv_data->result = (void *)&ctx->res[tsc_idx];
     258                 :          0 :                                 tsc_idx++;
     259                 :            :                         }
     260                 :            : 
     261                 :          0 :                         if (likely(ops_deqd))  {
     262                 :          0 :                                 for (i = 0; i < ops_deqd; i++) {
     263                 :          0 :                                         struct rte_crypto_op *op = ops_processed[i];
     264                 :            : 
     265                 :          0 :                                         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
     266                 :            :                                                 ret = -1;
     267                 :            : 
     268                 :            :                                         store_timestamp(ops_processed[i], tsc_end);
     269                 :            :                                 }
     270                 :            : 
     271                 :            :                                 /* Free crypto ops so they can be reused. */
     272                 :          0 :                                 rte_mempool_put_bulk(ctx->pool,
     273                 :            :                                                 (void **)ops_processed, ops_deqd);
     274                 :            : 
     275                 :          0 :                                 deqd_tot += ops_deqd;
     276                 :          0 :                                 deqd_max = RTE_MAX(ops_deqd, deqd_max);
     277                 :          0 :                                 deqd_min = RTE_MIN(ops_deqd, deqd_min);
     278                 :            :                         }
     279                 :            : 
     280                 :          0 :                         enqd_tot += ops_enqd;
     281                 :          0 :                         enqd_max = RTE_MAX(ops_enqd, enqd_max);
     282                 :          0 :                         enqd_min = RTE_MIN(ops_enqd, enqd_min);
     283                 :            : 
     284                 :          0 :                         b_idx++;
     285                 :            :                 }
     286                 :            : 
     287                 :            :                 /* Dequeue any operations still in the crypto device */
     288                 :          0 :                 while (deqd_tot < ctx->options->total_ops) {
     289                 :            :                         /* Sending 0 length burst to flush sw crypto device */
     290                 :          0 :                         rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0);
     291                 :            : 
     292                 :            :                         /* dequeue burst */
     293                 :          0 :                         ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id,
     294                 :            :                                         ops_processed, test_burst_size);
     295                 :            : 
     296                 :            :                         tsc_end = rte_rdtsc_precise();
     297                 :            : 
     298                 :          0 :                         if (ops_deqd != 0) {
     299                 :          0 :                                 for (i = 0; i < ops_deqd; i++) {
     300                 :          0 :                                         struct rte_crypto_op *op = ops_processed[i];
     301                 :            : 
     302                 :          0 :                                         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
     303                 :            :                                                 ret = -1;
     304                 :            : 
     305                 :            :                                         store_timestamp(ops_processed[i], tsc_end);
     306                 :            :                                 }
     307                 :            : 
     308                 :          0 :                                 rte_mempool_put_bulk(ctx->pool,
     309                 :            :                                                 (void **)ops_processed, ops_deqd);
     310                 :            : 
     311                 :          0 :                                 deqd_tot += ops_deqd;
     312                 :          0 :                                 deqd_max = RTE_MAX(ops_deqd, deqd_max);
     313                 :          0 :                                 deqd_min = RTE_MIN(ops_deqd, deqd_min);
     314                 :            :                         }
     315                 :            :                 }
     316                 :            : 
     317                 :            :                 /* If there was any failure in crypto op, exit */
     318                 :          0 :                 if (ret)
     319                 :          0 :                         return ret;
     320                 :            : 
     321                 :          0 :                 for (i = 0; i < tsc_idx; i++) {
     322                 :          0 :                         tsc_val = ctx->res[i].tsc_end - ctx->res[i].tsc_start;
     323                 :          0 :                         tsc_max = RTE_MAX(tsc_val, tsc_max);
     324                 :          0 :                         tsc_min = RTE_MIN(tsc_val, tsc_min);
     325                 :          0 :                         tsc_tot += tsc_val;
     326                 :            :                 }
     327                 :            : 
     328                 :            :                 double time_tot, time_avg, time_max, time_min;
     329                 :            : 
     330                 :            :                 const uint64_t tunit = 1000000; /* us */
     331                 :          0 :                 const uint64_t tsc_hz = rte_get_tsc_hz();
     332                 :            : 
     333                 :          0 :                 uint64_t enqd_avg = enqd_tot / b_idx;
     334                 :          0 :                 uint64_t deqd_avg = deqd_tot / b_idx;
     335                 :          0 :                 uint64_t tsc_avg = tsc_tot / tsc_idx;
     336                 :            : 
     337                 :          0 :                 time_tot = tunit*(double)(tsc_tot) / tsc_hz;
     338                 :          0 :                 time_avg = tunit*(double)(tsc_avg) / tsc_hz;
     339                 :          0 :                 time_max = tunit*(double)(tsc_max) / tsc_hz;
     340                 :          0 :                 time_min = tunit*(double)(tsc_min) / tsc_hz;
     341                 :            : 
     342                 :            :                 uint16_t exp = 0;
     343                 :          0 :                 if (ctx->options->csv) {
     344                 :          0 :                         if (__atomic_compare_exchange_n(&display_once, &exp, 1, 0,
     345                 :            :                                         __ATOMIC_RELAXED, __ATOMIC_RELAXED))
     346                 :            :                                 printf("\n# lcore, Buffer Size, Burst Size, Pakt Seq #, "
     347                 :            :                                                 "cycles, time (us)");
     348                 :            : 
     349                 :          0 :                         for (i = 0; i < ctx->options->total_ops; i++) {
     350                 :            : 
     351                 :          0 :                                 printf("\n%u,%u,%u,%"PRIu64",%"PRIu64",%.3f",
     352                 :          0 :                                         ctx->lcore_id, ctx->options->test_buffer_size,
     353                 :            :                                         test_burst_size, i + 1,
     354                 :            :                                         ctx->res[i].tsc_end - ctx->res[i].tsc_start,
     355                 :          0 :                                         tunit * (double) (ctx->res[i].tsc_end
     356                 :          0 :                                                         - ctx->res[i].tsc_start)
     357                 :            :                                                 / tsc_hz);
     358                 :            : 
     359                 :            :                         }
     360                 :            :                 } else {
     361                 :          0 :                         printf("\n# Device %d on lcore %u\n", ctx->dev_id,
     362                 :          0 :                                 ctx->lcore_id);
     363                 :          0 :                         printf("\n# total operations: %u", ctx->options->total_ops);
     364                 :          0 :                         printf("\n# Buffer size: %u", ctx->options->test_buffer_size);
     365                 :          0 :                         printf("\n# Burst size: %u", test_burst_size);
     366                 :            :                         printf("\n#     Number of bursts: %"PRIu64,
     367                 :            :                                         b_idx);
     368                 :            : 
     369                 :            :                         printf("\n#");
     370                 :            :                         printf("\n#          \t       Total\t   Average\t   "
     371                 :            :                                         "Maximum\t   Minimum");
     372                 :            :                         printf("\n#  enqueued\t%12"PRIu64"\t%10"PRIu64"\t"
     373                 :            :                                         "%10"PRIu64"\t%10"PRIu64, enqd_tot,
     374                 :            :                                         enqd_avg, enqd_max, enqd_min);
     375                 :            :                         printf("\n#  dequeued\t%12"PRIu64"\t%10"PRIu64"\t"
     376                 :            :                                         "%10"PRIu64"\t%10"PRIu64, deqd_tot,
     377                 :            :                                         deqd_avg, deqd_max, deqd_min);
     378                 :            :                         printf("\n#    cycles\t%12"PRIu64"\t%10"PRIu64"\t"
     379                 :            :                                         "%10"PRIu64"\t%10"PRIu64, tsc_tot,
     380                 :            :                                         tsc_avg, tsc_max, tsc_min);
     381                 :            :                         printf("\n# time [us]\t%12.0f\t%10.3f\t%10.3f\t%10.3f",
     382                 :            :                                         time_tot, time_avg, time_max, time_min);
     383                 :            :                         printf("\n\n");
     384                 :            : 
     385                 :            :                 }
     386                 :            : 
     387                 :            :                 /* Get next size from range or list */
     388                 :          0 :                 if (ctx->options->inc_burst_size != 0)
     389                 :          0 :                         test_burst_size += ctx->options->inc_burst_size;
     390                 :            :                 else {
     391                 :          0 :                         if (++burst_size_idx == ctx->options->burst_size_count)
     392                 :            :                                 break;
     393                 :          0 :                         test_burst_size =
     394                 :          0 :                                 ctx->options->burst_size_list[burst_size_idx];
     395                 :            :                 }
     396                 :            :         }
     397                 :            : 
     398                 :            :         return 0;
     399                 :            : }
     400                 :            : 
     401                 :            : void
     402                 :          0 : cperf_latency_test_destructor(void *arg)
     403                 :            : {
     404                 :            :         struct cperf_latency_ctx *ctx = arg;
     405                 :            : 
     406                 :          0 :         if (ctx == NULL)
     407                 :            :                 return;
     408                 :            : 
     409                 :          0 :         cperf_latency_test_free(ctx);
     410                 :            : }

Generated by: LCOV version 1.14