app/compress-perf: add --external-mbufs option

This patch adds new performance measurement option --external-mbufs
that allocates and uses memzones as external buffers instead of
putting the data directly inside mbufs.

Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>

diff --git a/app/test-compress-perf/comp_perf_options.h b/app/test-compress-perf/comp_perf_options.h
index e98d93c..2c26511 100644 (file)
--- a/app/test-compress-perf/comp_perf_options.h
+++ b/app/test-compress-perf/comp_perf_options.h
@@ -56,12 +56,14 @@ struct comp_test_data {
        uint32_t pool_sz;
        uint32_t num_iter;
        uint16_t max_sgl_segs;
+       uint32_t total_segs;
 
        enum rte_comp_huffman huffman_enc;
        enum comp_operation test_op;
        int window_sz;
        struct range_list level_lst;
        uint8_t level;
+       int use_external_mbufs;
 
        double ratio;
        enum cleanup_st cleanup;

diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c
index fa4fd0b..12d0a6c 100644 (file)
--- a/app/test-compress-perf/comp_perf_options_parse.c
+++ b/app/test-compress-perf/comp_perf_options_parse.c
@@ -28,6 +28,7 @@
 #define CPERF_HUFFMAN_ENC      ("huffman-enc")
 #define CPERF_LEVEL            ("compress-level")
 #define CPERF_WINDOW_SIZE      ("window-sz")
+#define CPERF_EXTERNAL_MBUFS   ("external-mbufs")
 
 struct name_id_map {
        const char *name;
@@ -58,6 +59,8 @@ usage(char *progname)
                "               (default: range between 1 and 9)\n"
                " --window-sz N: base two log value of compression window size\n"
                "               (e.g.: 15 => 32k, default: max supported by PMD)\n"
+               " --external-mbufs: use memzones as external buffers instead of\n"
+               "               keeping the data directly in mbuf area\n"
                " -h: prints this help\n",
                progname);
 }
@@ -520,6 +523,14 @@ parse_level(struct comp_test_data *test_data, const char *arg)
        return 0;
 }
 
+static int
+parse_external_mbufs(struct comp_test_data *test_data,
+                    const char *arg __rte_unused)
+{
+       test_data->use_external_mbufs = 1;
+       return 0;
+}
+
 typedef int (*option_parser_t)(struct comp_test_data *test_data,
                const char *arg);
 
@@ -544,8 +555,10 @@ static struct option lgopts[] = {
        { CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
        { CPERF_LEVEL, required_argument, 0, 0 },
        { CPERF_WINDOW_SIZE, required_argument, 0, 0 },
+       { CPERF_EXTERNAL_MBUFS, 0, 0, 0 },
        { NULL, 0, 0, 0 }
 };
+
 static int
 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
 {
@@ -563,6 +576,7 @@ comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
                { CPERF_HUFFMAN_ENC,    parse_huffman_enc },
                { CPERF_LEVEL,          parse_level },
                { CPERF_WINDOW_SIZE,    parse_window_sz },
+               { CPERF_EXTERNAL_MBUFS, parse_external_mbufs },
        };
        unsigned int i;
 
@@ -618,6 +632,7 @@ comp_perf_options_default(struct comp_test_data *test_data)
        test_data->level_lst.max = RTE_COMP_LEVEL_MAX;
        test_data->level_lst.inc = 1;
        test_data->test = CPERF_TEST_TYPE_BENCHMARK;
+       test_data->use_external_mbufs = 0;
 }
 
 int

diff --git a/app/test-compress-perf/comp_perf_test_benchmark.c b/app/test-compress-perf/comp_perf_test_benchmark.c
index 8874594..0c6bb9b 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_benchmark.c
+++ b/app/test-compress-perf/comp_perf_test_benchmark.c
@@ -15,7 +15,8 @@ cperf_benchmark_test_destructor(void *arg)
 {
        if (arg) {
                comp_perf_free_memory(
-                               &((struct cperf_benchmark_ctx *)arg)->ver.mem);
+                       ((struct cperf_benchmark_ctx *)arg)->ver.options,
+                       &((struct cperf_benchmark_ctx *)arg)->ver.mem);
                rte_free(arg);
        }
 }

diff --git a/app/test-compress-perf/comp_perf_test_common.c b/app/test-compress-perf/comp_perf_test_common.c
index 7b26734..1b8985b 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_common.c
+++ b/app/test-compress-perf/comp_perf_test_common.c
@@ -77,7 +77,8 @@ find_buf_size(uint32_t input_size)
 }
 
 void
-comp_perf_free_memory(struct cperf_mem_resources *mem)
+comp_perf_free_memory(struct comp_test_data *test_data,
+                     struct cperf_mem_resources *mem)
 {
        uint32_t i;
 
@@ -96,26 +97,162 @@ comp_perf_free_memory(struct cperf_mem_resources *mem)
        rte_mempool_free(mem->op_pool);
        rte_mempool_free(mem->decomp_buf_pool);
        rte_mempool_free(mem->comp_buf_pool);
+
+       /* external mbuf support */
+       if (mem->decomp_memzones != NULL) {
+               for (i = 0; i < test_data->total_segs; i++)
+                       rte_memzone_free(mem->decomp_memzones[i]);
+               rte_free(mem->decomp_memzones);
+       }
+       if (mem->comp_memzones != NULL) {
+               for (i = 0; i < test_data->total_segs; i++)
+                       rte_memzone_free(mem->comp_memzones[i]);
+               rte_free(mem->comp_memzones);
+       }
+       rte_free(mem->decomp_buf_infos);
+       rte_free(mem->comp_buf_infos);
+}
+
+static void
+comp_perf_extbuf_free_cb(void *addr __rte_unused, void *opaque __rte_unused)
+{
+}
+
+static const struct rte_memzone *
+comp_perf_make_memzone(const char *name, struct cperf_mem_resources *mem,
+                      unsigned int number, size_t size)
+{
+       unsigned int socket_id = rte_socket_id();
+       char mz_name[RTE_MEMZONE_NAMESIZE];
+       const struct rte_memzone *memzone;
+
+       snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_s%u_d%u_q%u_%d", name,
+                socket_id, mem->dev_id, mem->qp_id, number);
+       memzone = rte_memzone_lookup(mz_name);
+       if (memzone != NULL && memzone->len != size) {
+               rte_memzone_free(memzone);
+               memzone = NULL;
+       }
+       if (memzone == NULL) {
+               memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
+                               RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
+               if (memzone == NULL)
+                       RTE_LOG(ERR, USER1, "Can't allocate memory zone %s\n",
+                               mz_name);
+       }
+       return memzone;
+}
+
+static int
+comp_perf_allocate_external_mbufs(struct comp_test_data *test_data,
+                                 struct cperf_mem_resources *mem)
+{
+       uint32_t i;
+
+       mem->comp_memzones = rte_zmalloc_socket(NULL,
+               test_data->total_segs * sizeof(struct rte_memzone *),
+               0, rte_socket_id());
+
+       if (mem->comp_memzones == NULL) {
+               RTE_LOG(ERR, USER1,
+                       "Memory to hold the compression memzones could not be allocated\n");
+               return -1;
+       }
+
+       mem->decomp_memzones = rte_zmalloc_socket(NULL,
+               test_data->total_segs * sizeof(struct rte_memzone *),
+               0, rte_socket_id());
+
+       if (mem->decomp_memzones == NULL) {
+               RTE_LOG(ERR, USER1,
+                       "Memory to hold the decompression memzones could not be allocated\n");
+               return -1;
+       }
+
+       mem->comp_buf_infos = rte_zmalloc_socket(NULL,
+               test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info),
+               0, rte_socket_id());
+
+       if (mem->comp_buf_infos == NULL) {
+               RTE_LOG(ERR, USER1,
+                       "Memory to hold the compression buf infos could not be allocated\n");
+               return -1;
+       }
+
+       mem->decomp_buf_infos = rte_zmalloc_socket(NULL,
+               test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info),
+               0, rte_socket_id());
+
+       if (mem->decomp_buf_infos == NULL) {
+               RTE_LOG(ERR, USER1,
+                       "Memory to hold the decompression buf infos could not be allocated\n");
+               return -1;
+       }
+
+       for (i = 0; i < test_data->total_segs; i++) {
+               mem->comp_memzones[i] = comp_perf_make_memzone("comp", mem,
+                               i, test_data->out_seg_sz);
+               if (mem->comp_memzones[i] == NULL) {
+                       RTE_LOG(ERR, USER1,
+                               "Memory to hold the compression memzone could not be allocated\n");
+                       return -1;
+               }
+
+               mem->decomp_memzones[i] = comp_perf_make_memzone("decomp", mem,
+                               i, test_data->seg_sz);
+               if (mem->decomp_memzones[i] == NULL) {
+                       RTE_LOG(ERR, USER1,
+                               "Memory to hold the decompression memzone could not be allocated\n");
+                       return -1;
+               }
+
+               mem->comp_buf_infos[i].free_cb =
+                               comp_perf_extbuf_free_cb;
+               mem->comp_buf_infos[i].fcb_opaque = NULL;
+               rte_mbuf_ext_refcnt_set(&mem->comp_buf_infos[i], 1);
+
+               mem->decomp_buf_infos[i].free_cb =
+                               comp_perf_extbuf_free_cb;
+               mem->decomp_buf_infos[i].fcb_opaque = NULL;
+               rte_mbuf_ext_refcnt_set(&mem->decomp_buf_infos[i], 1);
+       }
+
+       return 0;
 }
 
 int
 comp_perf_allocate_memory(struct comp_test_data *test_data,
                          struct cperf_mem_resources *mem)
 {
+       uint16_t comp_mbuf_size;
+       uint16_t decomp_mbuf_size;
+
        test_data->out_seg_sz = find_buf_size(test_data->seg_sz);
+
        /* Number of segments for input and output
         * (compression and decompression)
         */
-       uint32_t total_segs = DIV_CEIL(test_data->input_data_sz,
+       test_data->total_segs = DIV_CEIL(test_data->input_data_sz,
                        test_data->seg_sz);
+
+       if (test_data->use_external_mbufs != 0) {
+               if (comp_perf_allocate_external_mbufs(test_data, mem) < 0)
+                       return -1;
+               comp_mbuf_size = 0;
+               decomp_mbuf_size = 0;
+       } else {
+               comp_mbuf_size = test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM;
+               decomp_mbuf_size = test_data->seg_sz + RTE_PKTMBUF_HEADROOM;
+       }
+
        char pool_name[32] = "";
 
        snprintf(pool_name, sizeof(pool_name), "comp_buf_pool_%u_qp_%u",
                        mem->dev_id, mem->qp_id);
        mem->comp_buf_pool = rte_pktmbuf_pool_create(pool_name,
-                               total_segs,
+                               test_data->total_segs,
                                0, 0,
-                               test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM,
+                               comp_mbuf_size,
                                rte_socket_id());
        if (mem->comp_buf_pool == NULL) {
                RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n");
@@ -125,15 +262,17 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
        snprintf(pool_name, sizeof(pool_name), "decomp_buf_pool_%u_qp_%u",
                        mem->dev_id, mem->qp_id);
        mem->decomp_buf_pool = rte_pktmbuf_pool_create(pool_name,
-                               total_segs,
-                               0, 0, test_data->seg_sz + RTE_PKTMBUF_HEADROOM,
+                               test_data->total_segs,
+                               0, 0,
+                               decomp_mbuf_size,
                                rte_socket_id());
        if (mem->decomp_buf_pool == NULL) {
                RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n");
                return -1;
        }
 
-       mem->total_bufs = DIV_CEIL(total_segs, test_data->max_sgl_segs);
+       mem->total_bufs = DIV_CEIL(test_data->total_segs,
+                                  test_data->max_sgl_segs);
 
        snprintf(pool_name, sizeof(pool_name), "op_pool_%u_qp_%u",
                        mem->dev_id, mem->qp_id);
@@ -151,7 +290,8 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
         */
        mem->compressed_data = rte_zmalloc_socket(NULL,
                                RTE_MAX(
-                                   (size_t) test_data->out_seg_sz * total_segs,
+                                   (size_t) test_data->out_seg_sz *
+                                                         test_data->total_segs,
                                    (size_t) MIN_COMPRESSED_BUF_SIZE),
                                0,
                                rte_socket_id());
@@ -188,7 +328,7 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
                return -1;
        }
 
-       buffer_info.total_segments = total_segs;
+       buffer_info.total_segments = test_data->total_segs;
        buffer_info.segment_sz = test_data->seg_sz;
        buffer_info.total_buffs = mem->total_bufs;
        buffer_info.segments_per_buff = test_data->max_sgl_segs;
@@ -206,6 +346,8 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
        uint8_t *data_addr;
        uint32_t i, j;
        uint16_t segs_per_mbuf = 0;
+       uint32_t cmz = 0;
+       uint32_t dmz = 0;
 
        for (i = 0; i < mem->total_bufs; i++) {
                /* Allocate data in input mbuf and copy data from input file */
@@ -217,6 +359,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
                }
 
                data_sz = RTE_MIN(remaining_data, test_data->seg_sz);
+
+               if (test_data->use_external_mbufs != 0) {
+                       rte_pktmbuf_attach_extbuf(mem->decomp_bufs[i],
+                                       mem->decomp_memzones[dmz]->addr,
+                                       mem->decomp_memzones[dmz]->iova,
+                                       test_data->seg_sz,
+                                       &mem->decomp_buf_infos[dmz]);
+                       dmz++;
+               }
+
                data_addr = (uint8_t *) rte_pktmbuf_append(
                                        mem->decomp_bufs[i], data_sz);
                if (data_addr == NULL) {
@@ -244,6 +396,17 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
                        }
 
                        data_sz = RTE_MIN(remaining_data, test_data->seg_sz);
+
+                       if (test_data->use_external_mbufs != 0) {
+                               rte_pktmbuf_attach_extbuf(
+                                       next_seg,
+                                       mem->decomp_memzones[dmz]->addr,
+                                       mem->decomp_memzones[dmz]->iova,
+                                       test_data->seg_sz,
+                                       &mem->decomp_buf_infos[dmz]);
+                               dmz++;
+                       }
+
                        data_addr = (uint8_t *)rte_pktmbuf_append(next_seg,
                                data_sz);
 
@@ -271,6 +434,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
                        RTE_LOG(ERR, USER1, "Could not allocate mbuf\n");
                        return -1;
                }
+
+               if (test_data->use_external_mbufs != 0) {
+                       rte_pktmbuf_attach_extbuf(mem->comp_bufs[i],
+                                       mem->comp_memzones[cmz]->addr,
+                                       mem->comp_memzones[cmz]->iova,
+                                       test_data->out_seg_sz,
+                                       &mem->comp_buf_infos[cmz]);
+                       cmz++;
+               }
+
                data_addr = (uint8_t *) rte_pktmbuf_append(
                                        mem->comp_bufs[i],
                                        test_data->out_seg_sz);
@@ -290,6 +463,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
                                return -1;
                        }
 
+                       if (test_data->use_external_mbufs != 0) {
+                               rte_pktmbuf_attach_extbuf(
+                                       next_seg,
+                                       mem->comp_memzones[cmz]->addr,
+                                       mem->comp_memzones[cmz]->iova,
+                                       test_data->out_seg_sz,
+                                       &mem->comp_buf_infos[cmz]);
+                               cmz++;
+                       }
+
                        data_addr = (uint8_t *)rte_pktmbuf_append(next_seg,
                                test_data->out_seg_sz);
                        if (data_addr == NULL) {

diff --git a/app/test-compress-perf/comp_perf_test_common.h b/app/test-compress-perf/comp_perf_test_common.h
index c9e0c90..9206428 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_common.h
+++ b/app/test-compress-perf/comp_perf_test_common.h
@@ -26,13 +26,20 @@ struct cperf_mem_resources {
        struct rte_mempool *comp_buf_pool;
        struct rte_mempool *decomp_buf_pool;
        struct rte_mempool *op_pool;
+
+       /* external mbuf support */
+       const struct rte_memzone **comp_memzones;
+       const struct rte_memzone **decomp_memzones;
+       struct rte_mbuf_ext_shared_info *comp_buf_infos;
+       struct rte_mbuf_ext_shared_info *decomp_buf_infos;
 };
 
 int
 param_range_check(uint16_t size, const struct rte_param_log2_range *range);
 
 void
-comp_perf_free_memory(struct cperf_mem_resources *mem);
+comp_perf_free_memory(struct comp_test_data *test_data,
+                     struct cperf_mem_resources *mem);
 
 int
 comp_perf_allocate_memory(struct comp_test_data *test_data,

diff --git a/app/test-compress-perf/comp_perf_test_verify.c b/app/test-compress-perf/comp_perf_test_verify.c
index f66f95f..758a22f 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_verify.c
+++ b/app/test-compress-perf/comp_perf_test_verify.c
@@ -14,7 +14,9 @@ void
 cperf_verify_test_destructor(void *arg)
 {
        if (arg) {
-               comp_perf_free_memory(&((struct cperf_verify_ctx *)arg)->mem);
+               comp_perf_free_memory(
+                               ((struct cperf_verify_ctx *)arg)->options,
+                               &((struct cperf_verify_ctx *)arg)->mem);
                rte_free(arg);
        }
 }