X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-crypto-perf%2Fcperf_test_throughput.c;h=61b27ea5f3b72ed60bdec4fd675307035b9966e0;hb=95908f52393da36c47905a777f64c0650585c12b;hp=32c5bad20303de09b2c34294aa1f004b12bb2ce1;hpb=da40ebd6d3836ed2c8827af93dcafeec6883ebdd;p=dpdk.git diff --git a/app/test-crypto-perf/cperf_test_throughput.c b/app/test-crypto-perf/cperf_test_throughput.c index 32c5bad203..61b27ea5f3 100644 --- a/app/test-crypto-perf/cperf_test_throughput.c +++ b/app/test-crypto-perf/cperf_test_throughput.c @@ -103,8 +103,8 @@ cperf_mbuf_create(struct rte_mempool *mempool, const struct cperf_test_vector *test_vector) { struct rte_mbuf *mbuf; - uint32_t segment_sz = options->buffer_sz / segments_nb; - uint32_t last_sz = options->buffer_sz % segments_nb; + uint32_t segment_sz = options->max_buffer_size / segments_nb; + uint32_t last_sz = options->max_buffer_size % segments_nb; uint8_t *mbuf_data; uint8_t *test_data = (options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ? @@ -206,8 +206,8 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id, options->pool_sz * options->segments_nb, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - (options->buffer_sz / options->segments_nb) + - (options->buffer_sz % options->segments_nb) + + (options->max_buffer_size / options->segments_nb) + + (options->max_buffer_size % options->segments_nb) + options->auth_digest_sz), rte_socket_id()); @@ -235,7 +235,7 @@ cperf_throughput_test_constructor(uint8_t dev_id, uint16_t qp_id, pool_name, options->pool_sz, 0, 0, RTE_PKTMBUF_HEADROOM + RTE_CACHE_LINE_ROUNDUP( - options->buffer_sz + + options->max_buffer_size + options->auth_digest_sz), rte_socket_id()); @@ -279,11 +279,13 @@ int cperf_throughput_test_runner(void *test_ctx) { struct cperf_throughput_ctx *ctx = test_ctx; + uint16_t test_burst_size; + uint8_t burst_size_idx = 0; static int only_once; - struct rte_crypto_op *ops[ctx->options->burst_sz]; - struct rte_crypto_op *ops_processed[ctx->options->burst_sz]; + struct rte_crypto_op *ops[ctx->options->max_burst_size]; + struct rte_crypto_op *ops_processed[ctx->options->max_burst_size]; uint64_t i; uint32_t lcore = rte_lcore_id(); @@ -307,164 +309,197 @@ cperf_throughput_test_runner(void *test_ctx) for (i = 0; i < ctx->options->total_ops; i++) rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); - uint64_t ops_enqd = 0, ops_enqd_total = 0, ops_enqd_failed = 0; - uint64_t ops_deqd = 0, ops_deqd_total = 0, ops_deqd_failed = 0; - uint64_t m_idx = 0, tsc_start, tsc_end, tsc_duration; + /* Get first size from range or list */ + if (ctx->options->inc_burst_size != 0) + test_burst_size = ctx->options->min_burst_size; + else + test_burst_size = ctx->options->burst_size_list[0]; - tsc_start = rte_rdtsc_precise(); - while (ops_enqd_total < ctx->options->total_ops) { + while (test_burst_size <= ctx->options->max_burst_size) { + uint64_t ops_enqd = 0, ops_enqd_total = 0, ops_enqd_failed = 0; + uint64_t ops_deqd = 0, ops_deqd_total = 0, ops_deqd_failed = 0; + + uint64_t m_idx = 0, tsc_start, tsc_end, tsc_duration; uint16_t ops_unused = 0; - uint16_t burst_size = ((ops_enqd_total + ctx->options->burst_sz) - <= ctx->options->total_ops) ? - ctx->options->burst_sz : - ctx->options->total_ops - - ops_enqd_total; + tsc_start = rte_rdtsc_precise(); - uint16_t ops_needed = burst_size - ops_unused; + while (ops_enqd_total < ctx->options->total_ops) { - /* Allocate crypto ops from pool */ - if (ops_needed != rte_crypto_op_bulk_alloc( - ctx->crypto_op_pool, - RTE_CRYPTO_OP_TYPE_SYMMETRIC, - ops, ops_needed)) - return -1; + uint16_t burst_size = ((ops_enqd_total + test_burst_size) + <= ctx->options->total_ops) ? + test_burst_size : + ctx->options->total_ops - + ops_enqd_total; - /* Setup crypto op, attach mbuf etc */ - (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx], - &ctx->mbufs_out[m_idx], - ops_needed, ctx->sess, ctx->options, - ctx->test_vector); + uint16_t ops_needed = burst_size - ops_unused; -#ifdef CPERF_LINEARIZATION_ENABLE - if (linearize) { - /* PMD doesn't support scatter-gather and source buffer - * is segmented. - * We need to linearize it before enqueuing. + /* Allocate crypto ops from pool */ + if (ops_needed != rte_crypto_op_bulk_alloc( + ctx->crypto_op_pool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC, + ops, ops_needed)) + return -1; + + /* Setup crypto op, attach mbuf etc */ + (ctx->populate_ops)(ops, &ctx->mbufs_in[m_idx], + &ctx->mbufs_out[m_idx], + ops_needed, ctx->sess, ctx->options, + ctx->test_vector); + + /** + * When ops_needed is smaller than ops_enqd, the + * unused ops need to be moved to the front for + * next round use. */ - for (i = 0; i < burst_size; i++) - rte_pktmbuf_linearize(ops[i]->sym->m_src); - } + if (unlikely(ops_enqd > ops_needed)) { + size_t nb_b_to_mov = ops_unused * sizeof( + struct rte_crypto_op *); + + memmove(&ops[ops_needed], &ops[ops_enqd], + nb_b_to_mov); + } + +#ifdef CPERF_LINEARIZATION_ENABLE + if (linearize) { + /* PMD doesn't support scatter-gather and source buffer + * is segmented. + * We need to linearize it before enqueuing. + */ + for (i = 0; i < burst_size; i++) + rte_pktmbuf_linearize(ops[i]->sym->m_src); + } #endif /* CPERF_LINEARIZATION_ENABLE */ - /* Enqueue burst of ops on crypto device */ - ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, - ops, burst_size); - if (ops_enqd < burst_size) - ops_enqd_failed++; - - /** - * Calculate number of ops not enqueued (mainly for hw - * accelerators whose ingress queue can fill up). - */ - ops_unused = burst_size - ops_enqd; - ops_enqd_total += ops_enqd; - - - /* Dequeue processed burst of ops from crypto device */ - ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); - - if (likely(ops_deqd)) { - /* free crypto ops so they can be reused. We don't free - * the mbufs here as we don't want to reuse them as - * the crypto operation will change the data and cause - * failures. - */ - for (i = 0; i < ops_deqd; i++) - rte_crypto_op_free(ops_processed[i]); + /* Enqueue burst of ops on crypto device */ + ops_enqd = rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, + ops, burst_size); + if (ops_enqd < burst_size) + ops_enqd_failed++; - ops_deqd_total += ops_deqd; - } else { /** - * Count dequeue polls which didn't return any - * processed operations. This statistic is mainly - * relevant to hw accelerators. + * Calculate number of ops not enqueued (mainly for hw + * accelerators whose ingress queue can fill up). */ - ops_deqd_failed++; + ops_unused = burst_size - ops_enqd; + ops_enqd_total += ops_enqd; + + + /* Dequeue processed burst of ops from crypto device */ + ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, + ops_processed, test_burst_size); + + if (likely(ops_deqd)) { + /* free crypto ops so they can be reused. We don't free + * the mbufs here as we don't want to reuse them as + * the crypto operation will change the data and cause + * failures. + */ + for (i = 0; i < ops_deqd; i++) + rte_crypto_op_free(ops_processed[i]); + + ops_deqd_total += ops_deqd; + } else { + /** + * Count dequeue polls which didn't return any + * processed operations. This statistic is mainly + * relevant to hw accelerators. + */ + ops_deqd_failed++; + } + + m_idx += ops_needed; + m_idx = m_idx + test_burst_size > ctx->options->pool_sz ? + 0 : m_idx; } - m_idx += ops_needed; - m_idx = m_idx + ctx->options->burst_sz > ctx->options->pool_sz ? - 0 : m_idx; - } + /* Dequeue any operations still in the crypto device */ - /* Dequeue any operations still in the crypto device */ + while (ops_deqd_total < ctx->options->total_ops) { + /* Sending 0 length burst to flush sw crypto device */ + rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); - while (ops_deqd_total < ctx->options->total_ops) { - /* Sending 0 length burst to flush sw crypto device */ - rte_cryptodev_enqueue_burst(ctx->dev_id, ctx->qp_id, NULL, 0); + /* dequeue burst */ + ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, + ops_processed, test_burst_size); + if (ops_deqd == 0) + ops_deqd_failed++; + else { + for (i = 0; i < ops_deqd; i++) + rte_crypto_op_free(ops_processed[i]); - /* dequeue burst */ - ops_deqd = rte_cryptodev_dequeue_burst(ctx->dev_id, ctx->qp_id, - ops_processed, ctx->options->burst_sz); - if (ops_deqd == 0) - ops_deqd_failed++; - else { - for (i = 0; i < ops_deqd; i++) - rte_crypto_op_free(ops_processed[i]); + ops_deqd_total += ops_deqd; + } + } - ops_deqd_total += ops_deqd; + tsc_end = rte_rdtsc_precise(); + tsc_duration = (tsc_end - tsc_start); + + /* Calculate average operations processed per second */ + double ops_per_second = ((double)ctx->options->total_ops / + tsc_duration) * rte_get_tsc_hz(); + + /* Calculate average throughput (Gbps) in bits per second */ + double throughput_gbps = ((ops_per_second * + ctx->options->test_buffer_size * 8) / 1000000000); + + /* Calculate average cycles per packet */ + double cycles_per_packet = ((double)tsc_duration / + ctx->options->total_ops); + + if (!ctx->options->csv) { + if (!only_once) + printf("%12s%12s%12s%12s%12s%12s%12s%12s%12s%12s\n\n", + "lcore id", "Buf Size", "Burst Size", + "Enqueued", "Dequeued", "Failed Enq", + "Failed Deq", "MOps", "Gbps", + "Cycles/Buf"); + only_once = 1; + + printf("%12u%12u%12u%12"PRIu64"%12"PRIu64"%12"PRIu64 + "%12"PRIu64"%12.4f%12.4f%12.2f\n", + ctx->lcore_id, + ctx->options->test_buffer_size, + test_burst_size, + ops_enqd_total, + ops_deqd_total, + ops_enqd_failed, + ops_deqd_failed, + ops_per_second/1000000, + throughput_gbps, + cycles_per_packet); + } else { + if (!only_once) + printf("# lcore id, Buffer Size(B)," + "Burst Size,Enqueued,Dequeued,Failed Enq," + "Failed Deq,Ops(Millions),Throughput(Gbps)," + "Cycles/Buf\n\n"); + only_once = 1; + + printf("%10u;%10u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";" + "%.f3;%.f3;%.f3\n", + ctx->lcore_id, + ctx->options->test_buffer_size, + test_burst_size, + ops_enqd_total, + ops_deqd_total, + ops_enqd_failed, + ops_deqd_failed, + ops_per_second/1000000, + throughput_gbps, + cycles_per_packet); + } + + /* Get next size from range or list */ + if (ctx->options->inc_burst_size != 0) + test_burst_size += ctx->options->inc_burst_size; + else { + if (++burst_size_idx == ctx->options->burst_size_count) + break; + test_burst_size = ctx->options->burst_size_list[burst_size_idx]; } - } - tsc_end = rte_rdtsc_precise(); - tsc_duration = (tsc_end - tsc_start); - - /* Calculate average operations processed per second */ - double ops_per_second = ((double)ctx->options->total_ops / - tsc_duration) * rte_get_tsc_hz(); - - /* Calculate average throughput (Gbps) in bits per second */ - double throughput_gbps = ((ops_per_second * - ctx->options->buffer_sz * 8) / 1000000000); - - /* Calculate average cycles per packet */ - double cycles_per_packet = ((double)tsc_duration / - ctx->options->total_ops); - - if (!ctx->options->csv) { - if (!only_once) - printf("%12s%12s%12s%12s%12s%12s%12s%12s%12s%12s\n\n", - "lcore id", "Buf Size", "Burst Size", - "Enqueued", "Dequeued", "Failed Enq", - "Failed Deq", "MOps", "Gbps", - "Cycles/Buf"); - only_once = 1; - - printf("%12u%12u%12u%12"PRIu64"%12"PRIu64"%12"PRIu64 - "%12"PRIu64"%12.4f%12.4f%12.2f\n", - ctx->lcore_id, - ctx->options->buffer_sz, - ctx->options->burst_sz, - ops_enqd_total, - ops_deqd_total, - ops_enqd_failed, - ops_deqd_failed, - ops_per_second/1000000, - throughput_gbps, - cycles_per_packet); - } else { - if (!only_once) - printf("# lcore id, Buffer Size(B)," - "Burst Size,Enqueued,Dequeued,Failed Enq," - "Failed Deq,Ops(Millions),Throughput(Gbps)," - "Cycles/Buf\n\n"); - only_once = 1; - - printf("%10u;%10u;%u;%"PRIu64";%"PRIu64";%"PRIu64";%"PRIu64";" - "%.f3;%.f3;%.f3\n", - ctx->lcore_id, - ctx->options->buffer_sz, - ctx->options->burst_sz, - ops_enqd_total, - ops_deqd_total, - ops_enqd_failed, - ops_deqd_failed, - ops_per_second/1000000, - throughput_gbps, - cycles_per_packet); } return 0;