X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-crypto-perf%2Fcperf_test_common.c;h=46e4a46eca8ae26b41522054a4a80bc0918d222f;hb=7df074333930f84a0d7f855c5a9f97524a6606c5;hp=65f0be7172281f95ea6f95acf528c0027388e2b0;hpb=c4f916e33226d308cb292568ea98b88376aea5f0;p=dpdk.git diff --git a/app/test-crypto-perf/cperf_test_common.c b/app/test-crypto-perf/cperf_test_common.c index 65f0be7172..46e4a46eca 100644 --- a/app/test-crypto-perf/cperf_test_common.c +++ b/app/test-crypto-perf/cperf_test_common.c @@ -34,75 +34,111 @@ #include "cperf_test_common.h" -static struct rte_mbuf * -cperf_mbuf_create(struct rte_mempool *mempool, - uint32_t segment_sz, - uint32_t segments_nb, - const struct cperf_options *options) +struct obj_params { + uint32_t src_buf_offset; + uint32_t dst_buf_offset; + uint16_t segment_sz; + uint16_t segments_nb; +}; + +static void +fill_single_seg_mbuf(struct rte_mbuf *m, struct rte_mempool *mp, + void *obj, uint32_t mbuf_offset, uint16_t segment_sz) { - struct rte_mbuf *mbuf; - uint8_t *mbuf_data; - uint32_t remaining_bytes = options->max_buffer_size; - - mbuf = rte_pktmbuf_alloc(mempool); - if (mbuf == NULL) - goto error; + uint32_t mbuf_hdr_size = sizeof(struct rte_mbuf); + + /* start of buffer is after mbuf structure and priv data */ + m->priv_size = 0; + m->buf_addr = (char *)m + mbuf_hdr_size; + m->buf_physaddr = rte_mempool_virt2phy(mp, obj) + + mbuf_offset + mbuf_hdr_size; + m->buf_len = segment_sz; + m->data_len = segment_sz; + + /* No headroom needed for the buffer */ + m->data_off = 0; + + /* init some constant fields */ + m->pool = mp; + m->nb_segs = 1; + m->port = 0xff; + rte_mbuf_refcnt_set(m, 1); + m->next = NULL; +} - mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, segment_sz); - if (mbuf_data == NULL) - goto error; +static void +fill_multi_seg_mbuf(struct rte_mbuf *m, struct rte_mempool *mp, + void *obj, uint32_t mbuf_offset, uint16_t segment_sz, + uint16_t segments_nb) +{ + uint16_t mbuf_hdr_size = sizeof(struct rte_mbuf); + uint16_t remaining_segments = segments_nb; + struct rte_mbuf *next_mbuf; + phys_addr_t next_seg_phys_addr = rte_mempool_virt2phy(mp, obj) + + mbuf_offset + mbuf_hdr_size; + + do { + /* start of buffer is after mbuf structure and priv data */ + m->priv_size = 0; + m->buf_addr = (char *)m + mbuf_hdr_size; + m->buf_physaddr = next_seg_phys_addr; + next_seg_phys_addr += mbuf_hdr_size + segment_sz; + m->buf_len = segment_sz; + m->data_len = segment_sz; + + /* No headroom needed for the buffer */ + m->data_off = 0; + + /* init some constant fields */ + m->pool = mp; + m->nb_segs = segments_nb; + m->port = 0xff; + rte_mbuf_refcnt_set(m, 1); + next_mbuf = (struct rte_mbuf *) ((uint8_t *) m + + mbuf_hdr_size + segment_sz); + m->next = next_mbuf; + m = next_mbuf; + remaining_segments--; + + } while (remaining_segments > 0); + + m->next = NULL; +} - if (options->max_buffer_size <= segment_sz) - remaining_bytes = 0; +static void +mempool_obj_init(struct rte_mempool *mp, + void *opaque_arg, + void *obj, + __attribute__((unused)) unsigned int i) +{ + struct obj_params *params = opaque_arg; + struct rte_crypto_op *op = obj; + struct rte_mbuf *m = (struct rte_mbuf *) ((uint8_t *) obj + + params->src_buf_offset); + /* Set crypto operation */ + op->type = RTE_CRYPTO_OP_TYPE_SYMMETRIC; + op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; + op->sess_type = RTE_CRYPTO_OP_WITH_SESSION; + + /* Set source buffer */ + op->sym->m_src = m; + if (params->segments_nb == 1) + fill_single_seg_mbuf(m, mp, obj, params->src_buf_offset, + params->segment_sz); else - remaining_bytes -= segment_sz; - - segments_nb--; - - while (remaining_bytes) { - struct rte_mbuf *m; - - m = rte_pktmbuf_alloc(mempool); - if (m == NULL) - goto error; - - rte_pktmbuf_chain(mbuf, m); - - mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, segment_sz); - if (mbuf_data == NULL) - goto error; - - if (remaining_bytes <= segment_sz) - remaining_bytes = 0; - else - remaining_bytes -= segment_sz; - - segments_nb--; - } - - /* - * If there was not enough room for the digest at the end - * of the last segment, allocate a new one - */ - if (segments_nb != 0) { - struct rte_mbuf *m; - m = rte_pktmbuf_alloc(mempool); - - if (m == NULL) - goto error; - - rte_pktmbuf_chain(mbuf, m); - mbuf_data = (uint8_t *)rte_pktmbuf_append(mbuf, segment_sz); - if (mbuf_data == NULL) - goto error; - } - - return mbuf; -error: - if (mbuf != NULL) - rte_pktmbuf_free(mbuf); - - return NULL; + fill_multi_seg_mbuf(m, mp, obj, params->src_buf_offset, + params->segment_sz, params->segments_nb); + + + /* Set destination buffer */ + if (params->dst_buf_offset) { + m = (struct rte_mbuf *) ((uint8_t *) obj + + params->dst_buf_offset); + fill_single_seg_mbuf(m, mp, obj, params->dst_buf_offset, + params->segment_sz); + op->sym->m_dst = m; + } else + op->sym->m_dst = NULL; } int @@ -110,120 +146,97 @@ cperf_alloc_common_memory(const struct cperf_options *options, const struct cperf_test_vector *test_vector, uint8_t dev_id, uint16_t qp_id, size_t extra_op_priv_size, - struct rte_mempool **pkt_mbuf_pool_in, - struct rte_mempool **pkt_mbuf_pool_out, - struct rte_mbuf ***mbufs_in, - struct rte_mbuf ***mbufs_out, - struct rte_mempool **crypto_op_pool) + uint32_t *src_buf_offset, + uint32_t *dst_buf_offset, + struct rte_mempool **pool) { - unsigned int mbuf_idx = 0; char pool_name[32] = ""; + int ret; - snprintf(pool_name, sizeof(pool_name), "cperf_pool_in_cdev_%u_qp_%u", - dev_id, qp_id); + /* Calculate the object size */ + uint16_t crypto_op_size = sizeof(struct rte_crypto_op) + + sizeof(struct rte_crypto_sym_op); + uint16_t crypto_op_private_size; + /* + * If doing AES-CCM, IV field needs to be 16 bytes long, + * and AAD field needs to be long enough to have 18 bytes, + * plus the length of the AAD, and all rounded to a + * multiple of 16 bytes. + */ + if (options->aead_algo == RTE_CRYPTO_AEAD_AES_CCM) { + crypto_op_private_size = extra_op_priv_size + + test_vector->cipher_iv.length + + test_vector->auth_iv.length + + RTE_ALIGN_CEIL(test_vector->aead_iv.length, 16) + + RTE_ALIGN_CEIL(options->aead_aad_sz + 18, 16); + } else { + crypto_op_private_size = extra_op_priv_size + + test_vector->cipher_iv.length + + test_vector->auth_iv.length + + test_vector->aead_iv.length + + options->aead_aad_sz; + } + uint16_t crypto_op_total_size = crypto_op_size + + crypto_op_private_size; + uint16_t crypto_op_total_size_padded = + RTE_CACHE_LINE_ROUNDUP(crypto_op_total_size); + uint32_t mbuf_size = sizeof(struct rte_mbuf) + options->segment_sz; uint32_t max_size = options->max_buffer_size + options->digest_sz; uint16_t segments_nb = (max_size % options->segment_sz) ? (max_size / options->segment_sz) + 1 : max_size / options->segment_sz; + uint32_t obj_size = crypto_op_total_size_padded + + (mbuf_size * segments_nb); - *pkt_mbuf_pool_in = rte_pktmbuf_pool_create(pool_name, - options->pool_sz * segments_nb, 0, 0, - RTE_PKTMBUF_HEADROOM + options->segment_sz, - rte_socket_id()); - - if (*pkt_mbuf_pool_in == NULL) - return -1; + snprintf(pool_name, sizeof(pool_name), "pool_cdev_%u_qp_%u", + dev_id, qp_id); - /* Generate mbufs_in with plaintext populated for test */ - *mbufs_in = (struct rte_mbuf **)rte_malloc(NULL, - (sizeof(struct rte_mbuf *) * options->pool_sz), 0); - - for (mbuf_idx = 0; mbuf_idx < options->pool_sz; mbuf_idx++) { - (*mbufs_in)[mbuf_idx] = cperf_mbuf_create( - *pkt_mbuf_pool_in, - options->segment_sz, - segments_nb, - options); - if ((*mbufs_in)[mbuf_idx] == NULL) - return -1; + *src_buf_offset = crypto_op_total_size_padded; + + struct obj_params params = { + .segment_sz = options->segment_sz, + .segments_nb = segments_nb, + .src_buf_offset = crypto_op_total_size_padded, + .dst_buf_offset = 0 + }; + + if (options->out_of_place) { + *dst_buf_offset = *src_buf_offset + + (mbuf_size * segments_nb); + params.dst_buf_offset = *dst_buf_offset; + /* Destination buffer will be one segment only */ + obj_size += max_size; } - *mbufs_out = (struct rte_mbuf **)rte_zmalloc(NULL, - (sizeof(struct rte_mbuf *) * - options->pool_sz), 0); - - if (options->out_of_place == 1) { - snprintf(pool_name, sizeof(pool_name), "cperf_pool_out_cdev_%u_qp_%u", - dev_id, qp_id); - - *pkt_mbuf_pool_out = rte_pktmbuf_pool_create( - pool_name, options->pool_sz, 0, 0, - RTE_PKTMBUF_HEADROOM + max_size, - rte_socket_id()); - - if (*pkt_mbuf_pool_out == NULL) - return -1; - - for (mbuf_idx = 0; mbuf_idx < options->pool_sz; mbuf_idx++) { - (*mbufs_out)[mbuf_idx] = cperf_mbuf_create( - *pkt_mbuf_pool_out, max_size, - 1, options); - if ((*mbufs_out)[mbuf_idx] == NULL) - return -1; - } + *pool = rte_mempool_create_empty(pool_name, + options->pool_sz, obj_size, 512, 0, + rte_socket_id(), 0); + if (*pool == NULL) { + RTE_LOG(ERR, USER1, + "Cannot allocate mempool for device %u\n", + dev_id); + return -1; } - snprintf(pool_name, sizeof(pool_name), "cperf_op_pool_cdev_%u_qp_%u", - dev_id, qp_id); - - uint16_t priv_size = RTE_ALIGN_CEIL(test_vector->cipher_iv.length + - test_vector->auth_iv.length + test_vector->aead_iv.length + - extra_op_priv_size, 16) + - RTE_ALIGN_CEIL(options->aead_aad_sz, 16); - - *crypto_op_pool = rte_crypto_op_pool_create(pool_name, - RTE_CRYPTO_OP_TYPE_SYMMETRIC, options->pool_sz, - 512, priv_size, rte_socket_id()); - if (*crypto_op_pool == NULL) + ret = rte_mempool_set_ops_byname(*pool, + RTE_MBUF_DEFAULT_MEMPOOL_OPS, NULL); + if (ret != 0) { + RTE_LOG(ERR, USER1, + "Error setting mempool handler for device %u\n", + dev_id); return -1; - - return 0; -} - -void -cperf_free_common_memory(const struct cperf_options *options, - struct rte_mempool *pkt_mbuf_pool_in, - struct rte_mempool *pkt_mbuf_pool_out, - struct rte_mbuf **mbufs_in, - struct rte_mbuf **mbufs_out, - struct rte_mempool *crypto_op_pool) -{ - uint32_t i = 0; - - if (mbufs_in) { - while (mbufs_in[i] != NULL && - i < options->pool_sz) - rte_pktmbuf_free(mbufs_in[i++]); - - rte_free(mbufs_in); } - if (mbufs_out) { - i = 0; - while (mbufs_out[i] != NULL - && i < options->pool_sz) - rte_pktmbuf_free(mbufs_out[i++]); - - rte_free(mbufs_out); + ret = rte_mempool_populate_default(*pool); + if (ret < 0) { + RTE_LOG(ERR, USER1, + "Error populating mempool for device %u\n", + dev_id); + return -1; } - if (pkt_mbuf_pool_in) - rte_mempool_free(pkt_mbuf_pool_in); + rte_mempool_obj_iter(*pool, mempool_obj_init, (void *)¶ms); - if (pkt_mbuf_pool_out) - rte_mempool_free(pkt_mbuf_pool_out); - - if (crypto_op_pool) - rte_mempool_free(crypto_op_pool); + return 0; }