This patch adds new test case in which max. size of
chain mbufs has been used to compress random data dynamically.
Signed-off-by: Tomasz Jozwiak <tomaszx.jozw...@intel.com>
---
test/test/test_compressdev.c | 157 +++++++++++++++++++++++++++++++++++++------
1 file changed, 136 insertions(+), 21 deletions(-)
diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c
index e8476ed..f59b3d2 100644
--- a/test/test/test_compressdev.c
+++ b/test/test/test_compressdev.c
@@ -1,9 +1,10 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2018 Intel Corporation
+ * Copyright(c) 2018 - 2019 Intel Corporation
*/
#include <string.h>
#include <zlib.h>
#include <math.h>
+#include <stdlib.h>
#include <rte_cycles.h>
#include <rte_malloc.h>
@@ -44,6 +45,11 @@
#define OUT_OF_SPACE_BUF 1
+#define MAX_MBUF_SEGMENT_SIZE 65535
+#define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM)
+#define NUM_BIG_MBUFS 4
+#define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * NUM_BIG_MBUFS / 2)
+
const char *
huffman_type_strings[] = {
[RTE_COMP_HUFFMAN_DEFAULT] = "PMD default",
@@ -72,6 +78,7 @@ struct priv_op_data {
struct comp_testsuite_params {
struct rte_mempool *large_mbuf_pool;
struct rte_mempool *small_mbuf_pool;
+ struct rte_mempool *big_mbuf_pool;
struct rte_mempool *op_pool;
struct rte_comp_xform *def_comp_xform;
struct rte_comp_xform *def_decomp_xform;
@@ -91,6 +98,7 @@ struct test_data_params {
enum varied_buff buff_type;
enum zlib_direction zlib_dir;
unsigned int out_of_space;
+ unsigned int big_data;
};
static struct comp_testsuite_params testsuite_params = { 0 };
@@ -104,11 +112,14 @@ testsuite_teardown(void)
RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n");
if (rte_mempool_in_use_count(ts_params->small_mbuf_pool))
RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n");
+ if (rte_mempool_in_use_count(ts_params->big_mbuf_pool))
+ RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n");
if (rte_mempool_in_use_count(ts_params->op_pool))
RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n");
rte_mempool_free(ts_params->large_mbuf_pool);
rte_mempool_free(ts_params->small_mbuf_pool);
+ rte_mempool_free(ts_params->big_mbuf_pool);
rte_mempool_free(ts_params->op_pool);
rte_free(ts_params->def_comp_xform);
rte_free(ts_params->def_decomp_xform);
@@ -161,6 +172,17 @@ testsuite_setup(void)
goto exit;
}
+ /* Create mempool with big buffers for SGL testing */
+ ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool",
+ NUM_BIG_MBUFS + 1,
+ CACHE_SIZE, 0,
+ MAX_MBUF_SEGMENT_SIZE,
+ rte_socket_id());
+ if (ts_params->big_mbuf_pool == NULL) {
+ RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n");
+ goto exit;
+ }
+
ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS,
0, sizeof(struct priv_op_data),
rte_socket_id());
@@ -597,10 +619,11 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf
*head_buf,
uint32_t total_data_size,
struct rte_mempool *small_mbuf_pool,
struct rte_mempool *large_mbuf_pool,
- uint8_t limit_segs_in_sgl)
+ uint8_t limit_segs_in_sgl,
+ uint16_t seg_size)
{
uint32_t remaining_data = total_data_size;
- uint16_t num_remaining_segs = DIV_CEIL(remaining_data, SMALL_SEG_SIZE);
+ uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size);
struct rte_mempool *pool;
struct rte_mbuf *next_seg;
uint32_t data_size;
@@ -616,10 +639,10 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf
*head_buf,
* Allocate data in the first segment (header) and
* copy data if test buffer is provided
*/
- if (remaining_data < SMALL_SEG_SIZE)
+ if (remaining_data < seg_size)
data_size = remaining_data;
else
- data_size = SMALL_SEG_SIZE;
+ data_size = seg_size;
buf_ptr = rte_pktmbuf_append(head_buf, data_size);
if (buf_ptr == NULL) {
RTE_LOG(ERR, USER1,
@@ -643,13 +666,13 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf
*head_buf,
if (i == (num_remaining_segs - 1)) {
/* last segment */
- if (remaining_data > SMALL_SEG_SIZE)
+ if (remaining_data > seg_size)
pool = large_mbuf_pool;
else
pool = small_mbuf_pool;
data_size = remaining_data;
} else {
- data_size = SMALL_SEG_SIZE;
+ data_size = seg_size;
pool = small_mbuf_pool;
}
@@ -703,6 +726,7 @@ test_deflate_comp_decomp(const struct interim_data_params
*int_data,
enum rte_comp_op_type state = test_data->state;
unsigned int buff_type = test_data->buff_type;
unsigned int out_of_space = test_data->out_of_space;
+ unsigned int big_data = test_data->big_data;
enum zlib_direction zlib_dir = test_data->zlib_dir;
int ret_status = -1;
int ret;
@@ -737,7 +761,9 @@ test_deflate_comp_decomp(const struct interim_data_params
*int_data,
memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
memset(priv_xforms, 0, sizeof(void *) * num_bufs);
- if (buff_type == SGL_BOTH)
+ if (big_data)
+ buf_pool = ts_params->big_mbuf_pool;
+ else if (buff_type == SGL_BOTH)
buf_pool = ts_params->small_mbuf_pool;
else
buf_pool = ts_params->large_mbuf_pool;
@@ -756,10 +782,11 @@ test_deflate_comp_decomp(const struct interim_data_params
*int_data,
for (i = 0; i < num_bufs; i++) {
data_size = strlen(test_bufs[i]) + 1;
if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
- data_size,
- ts_params->small_mbuf_pool,
- ts_params->large_mbuf_pool,
- MAX_SEGS) < 0)
+ data_size,
+ big_data ? buf_pool : ts_params->small_mbuf_pool,
+ big_data ? buf_pool : ts_params->large_mbuf_pool,
+ big_data ? 0 : MAX_SEGS,
+ big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
goto exit;
}
} else {
@@ -788,10 +815,12 @@ test_deflate_comp_decomp(const struct interim_data_params
*int_data,
COMPRESS_BUF_SIZE_RATIO);
if (prepare_sgl_bufs(NULL, comp_bufs[i],
- data_size,
- ts_params->small_mbuf_pool,
- ts_params->large_mbuf_pool,
- MAX_SEGS) < 0)
+ data_size,
+ big_data ? buf_pool : ts_params->small_mbuf_pool,
+ big_data ? buf_pool : ts_params->large_mbuf_pool,
+ big_data ? 0 : MAX_SEGS,
+ big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
+ < 0)
goto exit;
}
@@ -1016,10 +1045,12 @@ test_deflate_comp_decomp(const struct
interim_data_params *int_data,
strlen(test_bufs[priv_data->orig_idx]) + 1;
if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
- data_size,
- ts_params->small_mbuf_pool,
- ts_params->large_mbuf_pool,
- MAX_SEGS) < 0)
+ data_size,
+ big_data ? buf_pool : ts_params->small_mbuf_pool,
+ big_data ? buf_pool : ts_params->large_mbuf_pool,
+ big_data ? 0 : MAX_SEGS,
+ big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
+ < 0)
goto exit;
}
@@ -1319,6 +1350,7 @@ test_compressdev_deflate_stateless_fixed(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1389,6 +1421,7 @@ test_compressdev_deflate_stateless_dynamic(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1442,6 +1475,7 @@ test_compressdev_deflate_stateless_multi_op(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1491,6 +1525,7 @@ test_compressdev_deflate_stateless_multi_level(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1580,6 +1615,7 @@ test_compressdev_deflate_stateless_multi_xform(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1625,6 +1661,7 @@ test_compressdev_deflate_stateless_sgl(void)
RTE_COMP_OP_STATELESS,
SGL_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1732,6 +1769,7 @@ test_compressdev_deflate_stateless_checksum(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
+ 0,
0
};
@@ -1862,7 +1900,8 @@ test_compressdev_out_of_space_buffer(void)
RTE_COMP_OP_STATELESS,
LB_BOTH,
ZLIB_DECOMPRESS,
- 1
+ 1,
+ 0
};
/* Compress with compressdev, decompress with Zlib */
test_data.zlib_dir = ZLIB_DECOMPRESS;
@@ -1903,6 +1942,80 @@ test_compressdev_out_of_space_buffer(void)
return ret;
}
+static int
+test_compressdev_deflate_stateless_dynamic_big(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ uint16_t i = 0;
+ int ret = TEST_SUCCESS;
+ const struct rte_compressdev_capabilities *capab;
+ char *test_buffer = NULL;
+
+ capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+ TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
+
+ if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
+ return -ENOTSUP;
+
+ if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
+ return -ENOTSUP;
+
+ test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0);
+ if (test_buffer == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Can't allocate buffer for big-data\n");
+ return TEST_FAILED;
+ }
+
+ struct interim_data_params int_data = {
+ (const char * const *)&test_buffer,
+ 1,
+ NULL,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1
+ };
+
+ struct test_data_params test_data = {
+ RTE_COMP_OP_STATELESS,
+ SGL_BOTH,
+ ZLIB_DECOMPRESS,
+ 0,
+ 1
+ };
+
+ ts_params->def_comp_xform->compress.deflate.huffman =
+ RTE_COMP_HUFFMAN_DYNAMIC;
+
+ /* fill the buffer with data based on rand. data */
+ srand(BIG_DATA_TEST_SIZE);
+ for (uint32_t i = 0; i < BIG_DATA_TEST_SIZE - 1; ++i)
+ test_buffer[i] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
+
+ test_buffer[BIG_DATA_TEST_SIZE-1] = 0;
+ int_data.buf_idx = &i;
+
+ /* Compress with compressdev, decompress with Zlib */
+ test_data.zlib_dir = ZLIB_DECOMPRESS;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto end;
+ }
+
+ /* Compress with Zlib, decompress with compressdev */
+ test_data.zlib_dir = ZLIB_COMPRESS;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto end;
+ }
+
+end:
+ ts_params->def_comp_xform->compress.deflate.huffman =
+ RTE_COMP_HUFFMAN_DEFAULT;
+ rte_free(test_buffer);
+ return ret;
+}
+
static struct unit_test_suite compressdev_testsuite = {
.suite_name = "compressdev unit test suite",
@@ -1916,6 +2029,8 @@ static struct unit_test_suite compressdev_testsuite = {
TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
test_compressdev_deflate_stateless_dynamic),
TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateless_dynamic_big),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
test_compressdev_deflate_stateless_multi_op),
TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
test_compressdev_deflate_stateless_multi_level),
--
2.7.4
