app/compress-perf: improve results report

This patch adds extra features to the compress performance
test. Some important parameters (memory allocation,
number of ops, number of segments) are calculated and
printed out.
Information about threads, cores, devices and queue-pairs
is also printed.

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
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_test_benchmark.c b/app/test-compress-perf/comp_perf_test_benchmark.c
index aa1f8eea2f6aaad3c088983895c3ae0636efbbe4..8874594498f7e4b3eade28d2eff4efcc30bdb2da 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_benchmark.c
+++ b/app/test-compress-perf/comp_perf_test_benchmark.c
@@ -329,9 +329,26 @@ cperf_benchmark_test_runner(void *test_ctx)
        struct comp_test_data *test_data = ctx->ver.options;
        uint32_t lcore = rte_lcore_id();
        static rte_atomic16_t display_once = RTE_ATOMIC16_INIT(0);
+       int i, ret = EXIT_SUCCESS;
 
        ctx->ver.mem.lcore_id = lcore;
-       int i, ret = EXIT_SUCCESS;
+
+       /*
+        * printing information about current compression thread
+        */
+       if (rte_atomic16_test_and_set(&ctx->ver.mem.print_info_once))
+               printf("    lcore: %u,"
+                               " driver name: %s,"
+                               " device name: %s,"
+                               " device id: %u,"
+                               " socket id: %u,"
+                               " queue pair id: %u\n",
+                       lcore,
+                       ctx->ver.options->driver_name,
+                       rte_compressdev_name_get(ctx->ver.mem.dev_id),
+                       ctx->ver.mem.dev_id,
+                       rte_compressdev_socket_id(ctx->ver.mem.dev_id),
+                       ctx->ver.mem.qp_id);
 
        /*
         * First the verification part is needed
@@ -374,7 +391,7 @@ cperf_benchmark_test_runner(void *test_ctx)
                        1000000000;
 
        if (rte_atomic16_test_and_set(&display_once)) {
-               printf("%12s%6s%12s%17s%15s%16s\n",
+               printf("\n%12s%6s%12s%17s%15s%16s\n",
                        "lcore id", "Level", "Comp size", "Comp ratio [%]",
                        "Comp [Gbps]", "Decomp [Gbps]");
        }

diff --git a/app/test-compress-perf/comp_perf_test_common.c b/app/test-compress-perf/comp_perf_test_common.c
index 472c766867cfd1c779af69bced74a3373b0bf46a..28be9f257d304a1c6f1ca20e96502c3c8ba4cd4a 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_common.c
+++ b/app/test-compress-perf/comp_perf_test_common.c
@@ -16,6 +16,18 @@
 
 #define DIV_CEIL(a, b)  ((a) / (b) + ((a) % (b) != 0))
 
+struct cperf_buffer_info {
+       uint16_t total_segments;
+       uint16_t segment_sz;
+       uint16_t last_segment_sz;
+       uint32_t total_buffs;         /*number of buffers = number of ops*/
+       uint16_t segments_per_buff;
+       uint16_t segments_per_last_buff;
+       size_t input_data_sz;
+};
+
+static struct cperf_buffer_info buffer_info;
+
 int
 param_range_check(uint16_t size, const struct rte_param_log2_range *range)
 {
@@ -170,6 +182,13 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
                                " could not be allocated\n");
                return -1;
        }
+
+       buffer_info.total_segments = 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;
+       buffer_info.input_data_sz = test_data->input_data_sz;
+
        return 0;
 }
 
@@ -178,9 +197,10 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 {
        uint32_t remaining_data = test_data->input_data_sz;
        uint8_t *input_data_ptr = test_data->input_data;
-       size_t data_sz;
+       size_t data_sz = 0;
        uint8_t *data_addr;
        uint32_t i, j;
+       uint16_t segs_per_mbuf = 0;
 
        for (i = 0; i < mem->total_bufs; i++) {
                /* Allocate data in input mbuf and copy data from input file */
@@ -204,7 +224,7 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
                remaining_data -= data_sz;
 
                /* Already one segment in the mbuf */
-               uint16_t segs_per_mbuf = 1;
+               segs_per_mbuf = 1;
 
                /* Chain mbufs if needed for input mbufs */
                while (segs_per_mbuf < test_data->max_sgl_segs
@@ -281,5 +301,75 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
                }
        }
 
+       buffer_info.segments_per_last_buff = segs_per_mbuf;
+       buffer_info.last_segment_sz = data_sz;
+
        return 0;
 }
+
+void
+print_test_dynamics(void)
+{
+       uint32_t opt_total_segs = DIV_CEIL(buffer_info.input_data_sz,
+                       MAX_SEG_SIZE);
+
+       if (buffer_info.total_buffs > 1) {
+               printf("\nWarning: for the current input parameters, number"
+                               " of ops is higher than one, which may result"
+                               " in sub-optimal performance.\n");
+               printf("To improve the performance (for the current"
+                               " input data) following parameters are"
+                               " suggested:\n");
+               printf("        * Segment size: %d\n", MAX_SEG_SIZE);
+               printf("        * Number of segments: %u\n", opt_total_segs);
+       } else if (buffer_info.total_buffs == 1) {
+               printf("\nInfo: there is only one op with %u segments -"
+                               " the compression ratio is the best.\n",
+                       buffer_info.segments_per_last_buff);
+               if (buffer_info.segment_sz < MAX_SEG_SIZE)
+                       printf("To reduce compression time, please use"
+                                       " bigger segment size: %d.\n",
+                               MAX_SEG_SIZE);
+               else if (buffer_info.segment_sz == MAX_SEG_SIZE)
+                       printf("Segment size is optimal for the best"
+                                       " performance.\n");
+       } else
+               printf("Warning: something wrong happened!!\n");
+
+       printf("\nFor the current input parameters (segment size = %u,"
+                       " maximum segments per SGL = %u):\n",
+               buffer_info.segment_sz,
+               buffer_info.segments_per_buff);
+       printf("        * Total number of buffers: %d\n",
+               buffer_info.total_segments);
+       printf("        * %u buffer(s) %u bytes long, last buffer %u"
+                       " byte(s) long\n",
+               buffer_info.total_segments - 1,
+               buffer_info.segment_sz,
+               buffer_info.last_segment_sz);
+       printf("        * Number of ops: %u\n", buffer_info.total_buffs);
+       printf("        * Total memory allocation: %u\n",
+               (buffer_info.total_segments - 1) * buffer_info.segment_sz
+               + buffer_info.last_segment_sz);
+       if (buffer_info.total_buffs > 1)
+               printf("        * %u ops: %u segment(s) in each,"
+                               " segment size %u\n",
+                       buffer_info.total_buffs - 1,
+                       buffer_info.segments_per_buff,
+                       buffer_info.segment_sz);
+       if (buffer_info.segments_per_last_buff > 1) {
+               printf("        * 1 op %u segments:\n",
+                               buffer_info.segments_per_last_buff);
+               printf("                o %u segment size %u\n",
+                       buffer_info.segments_per_last_buff - 1,
+                       buffer_info.segment_sz);
+               printf("                o last segment size %u\n",
+                       buffer_info.last_segment_sz);
+       } else if (buffer_info.segments_per_last_buff == 1) {
+               printf("        * 1 op (the last one): %u segment %u"
+                               " byte(s) long\n\n",
+                       buffer_info.segments_per_last_buff,
+                       buffer_info.last_segment_sz);
+       }
+       printf("\n");
+}

diff --git a/app/test-compress-perf/comp_perf_test_common.h b/app/test-compress-perf/comp_perf_test_common.h
index 9c11e3a0049df76ba3202325593b43020fb47a4b..c9e0c90818bcf3f3428085de3afe80550880d0bb 100644 (file)
--- a/app/test-compress-perf/comp_perf_test_common.h
+++ b/app/test-compress-perf/comp_perf_test_common.h
@@ -13,6 +13,9 @@ struct cperf_mem_resources {
        uint8_t dev_id;
        uint16_t qp_id;
        uint8_t lcore_id;
+
+       rte_atomic16_t print_info_once;
+
        uint32_t total_bufs;
        uint8_t *compressed_data;
        uint8_t *decompressed_data;
@@ -38,4 +41,7 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 int
 prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem);
 
+void
+print_test_dynamics(void);
+
 #endif /* _COMP_PERF_TEST_COMMON_H_ */

diff --git a/app/test-compress-perf/main.c b/app/test-compress-perf/main.c
index e746e4708a1f5f1a44adbac14acb1c600a60a384..e7ac412e6a15b105549d224ce6c5f04c3d6b11c7 100644 (file)
--- a/app/test-compress-perf/main.c
+++ b/app/test-compress-perf/main.c
@@ -363,7 +363,7 @@ main(int argc, char **argv)
 
        printf("App uses socket: %u\n", rte_socket_id());
        printf("Burst size = %u\n", test_data->burst_sz);
-       printf("File size = %zu\n", test_data->input_data_sz);
+       printf("Input data size = %zu\n", test_data->input_data_sz);
 
        test_data->cleanup = ST_DURING_TEST;
        total_nb_qps = nb_compressdevs * test_data->nb_qps;
@@ -390,6 +390,8 @@ main(int argc, char **argv)
                i++;
        }
 
+       print_test_dynamics(); /* constructors must be executed first */
+
        while (test_data->level <= test_data->level_lst.max) {
 
                i = 0;