added mbuf offset test to compressdev test suite, which tests compression/
decompression with a mbuf containing an offset spanning across mulitple segments
Signed-off-by: Lee Daly <lee.d...@intel.com>
---
test/test/test_compressdev.c | 241 ++++++++++++++++++++++++++++++++++---------
1 file changed, 193 insertions(+), 48 deletions(-)
diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c
index 5d5e519..91dd636 100644
--- a/test/test/test_compressdev.c
+++ b/test/test/test_compressdev.c
@@ -35,6 +35,7 @@
#define NUM_MAX_XFORMS 16
#define NUM_MAX_INFLIGHT_OPS 128
#define CACHE_SIZE 0
+#define OFFSET 800
const char *
huffman_type_strings[] = {
@@ -93,7 +94,7 @@ testsuite_setup(void)
for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
max_buf_size = RTE_MAX(max_buf_size,
- strlen(compress_test_bufs[i]) + 1);
+ (strlen(compress_test_bufs[i]) + OFFSET + 1));
/*
* Buffers to be used in compression and decompression.
@@ -347,8 +348,9 @@ compress_zlib(struct rte_comp_op *op,
RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
goto exit;
}
- if (rte_pktmbuf_read(op->m_src, 0,
- rte_pktmbuf_pkt_len(op->m_src),
+ if (rte_pktmbuf_read(op->m_src, op->src.offset,
+ rte_pktmbuf_pkt_len(op->m_src) -
+ op->src.offset,
single_src_buf) == NULL) {
RTE_LOG(ERR, USER1,
"Buffer could not be read entirely\n");
@@ -362,9 +364,11 @@ compress_zlib(struct rte_comp_op *op,
} else {
stream.avail_in = op->src.length;
- stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
+ stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
+ op->src.offset);
stream.avail_out = op->m_dst->data_len;
- stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
+ stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
+ op->dst.offset);
}
/* Stateless operation, all buffer will be compressed in one go */
zlib_flush = map_zlib_flush_flag(op->flush_flag);
@@ -384,9 +388,26 @@ compress_zlib(struct rte_comp_op *op,
uint8_t *src_data = single_dst_buf;
struct rte_mbuf *dst_buf = op->m_dst;
+ uint32_t remaining_offset = op->dst.offset;
+ while (remaining_offset >= dst_buf->data_len) {
+ remaining_offset -= dst_buf->data_len;
+ dst_buf = dst_buf->next;
+ }
+
+ /* First Segment */
+ uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, uint8_t *,
+ op->dst.offset % dst_buf->data_len);
+ memcpy(dst_data, src_data, dst_buf->data_len -
+ (op->dst.offset % dst_buf->data_len));
+ remaining_data -= dst_buf->data_len -
+ (op->dst.offset % dst_buf->data_len);
+ src_data += dst_buf->data_len -
+ (op->dst.offset % dst_buf->data_len);
+ dst_buf = dst_buf->next;
+
+
while (remaining_data > 0) {
- uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf,
- uint8_t *);
+ dst_data = rte_pktmbuf_mtod(dst_buf, uint8_t *);
/* Last segment */
if (remaining_data < dst_buf->data_len) {
memcpy(dst_data, src_data, remaining_data);
@@ -459,8 +480,9 @@ decompress_zlib(struct rte_comp_op *op,
RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
goto exit;
}
- if (rte_pktmbuf_read(op->m_src, 0,
- rte_pktmbuf_pkt_len(op->m_src),
+ if (rte_pktmbuf_read(op->m_src, op->src.offset,
+ rte_pktmbuf_pkt_len(op->m_src) -
+ op->src.offset,
single_src_buf) == NULL) {
RTE_LOG(ERR, USER1,
"Buffer could not be read entirely\n");
@@ -474,9 +496,11 @@ decompress_zlib(struct rte_comp_op *op,
} else {
stream.avail_in = op->src.length;
- stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
+ stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
+ op->src.offset);
stream.avail_out = op->m_dst->data_len;
- stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
+ stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
+ op->dst.offset);
}
/* Stateless operation, all buffer will be compressed in one go */
@@ -496,8 +520,25 @@ decompress_zlib(struct rte_comp_op *op,
uint8_t *src_data = single_dst_buf;
struct rte_mbuf *dst_buf = op->m_dst;
+ uint32_t remaining_offset = op->dst.offset;
+ while (remaining_offset >= dst_buf->data_len) {
+ remaining_offset -= dst_buf->data_len;
+ dst_buf = dst_buf->next;
+ }
+
+ uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, uint8_t *,
+ op->dst.offset % dst_buf->data_len);
+ memcpy(dst_data, src_data, dst_buf->data_len -
+ (op->dst.offset % dst_buf->data_len));
+ remaining_data -= dst_buf->data_len -
+ (op->dst.offset % dst_buf->data_len);
+ src_data += dst_buf->data_len -
+ (op->dst.offset % dst_buf->data_len);
+ dst_buf = dst_buf->next;
+
+
while (remaining_data > 0) {
- uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf,
+ dst_data = rte_pktmbuf_mtod(dst_buf,
uint8_t *);
/* Last segment */
if (remaining_data < dst_buf->data_len) {
@@ -530,17 +571,19 @@ 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 offset)
{
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 + offset,
+ SMALL_SEG_SIZE);
struct rte_mempool *pool;
struct rte_mbuf *next_seg;
uint32_t data_size;
char *buf_ptr;
const char *data_ptr = test_buf;
uint16_t i;
- int ret;
+ int ret, remaining_offset;
if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl)
num_remaining_segs = limit_segs_in_sgl - 1;
@@ -560,13 +603,14 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf
*head_buf,
return -1;
}
- if (data_ptr != NULL) {
+ if (data_ptr != NULL && offset < data_size) {
/* Copy characters without NULL terminator */
- strncpy(buf_ptr, data_ptr, data_size);
- data_ptr += data_size;
+ strncpy(buf_ptr + offset, data_ptr, data_size - offset);
+ data_ptr += data_size - offset;
+ remaining_data -= data_size - offset;
}
- remaining_data -= data_size;
num_remaining_segs--;
+ remaining_offset = offset - data_size;
/*
* Allocate the rest of the segments,
@@ -600,12 +644,21 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf
*head_buf,
rte_pktmbuf_free(next_seg);
return -1;
}
- if (data_ptr != NULL) {
+ if (data_ptr != NULL && remaining_offset < (int)data_size) {
/* Copy characters without NULL terminator */
- strncpy(buf_ptr, data_ptr, data_size);
- data_ptr += data_size;
+ if (remaining_data == total_data_size) {
+ strncpy(buf_ptr + remaining_offset, data_ptr,
+ data_size - remaining_offset);
+ data_ptr += data_size - remaining_offset;
+ remaining_data -= data_size - remaining_offset;
+ } else {
+ strncpy(buf_ptr, data_ptr, data_size);
+ data_ptr += data_size;
+ remaining_data -= data_size;
+ }
}
- remaining_data -= data_size;
+ if (remaining_data == total_data_size)
+ remaining_offset -= data_size;
ret = rte_pktmbuf_chain(head_buf, next_seg);
if (ret != 0) {
@@ -631,7 +684,8 @@ test_deflate_comp_decomp(const char * const test_bufs[],
unsigned int num_xforms,
enum rte_comp_op_type state,
unsigned int sgl,
- enum zlib_direction zlib_dir)
+ enum zlib_direction zlib_dir,
+ uint16_t offset)
{
struct comp_testsuite_params *ts_params = &testsuite_params;
int ret_status = -1;
@@ -682,14 +736,17 @@ test_deflate_comp_decomp(const char * const test_bufs[],
data_size,
ts_params->small_mbuf_pool,
ts_params->large_mbuf_pool,
- MAX_SEGS) < 0)
+ MAX_SEGS,
+ offset) < 0)
goto exit;
}
} else {
for (i = 0; i < num_bufs; i++) {
data_size = strlen(test_bufs[i]) + 1;
- buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
- snprintf(buf_ptr, data_size, "%s", test_bufs[i]);
+ buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
+ data_size + offset);
+ snprintf(buf_ptr + offset, data_size, "%s",
+ test_bufs[i]);
}
}
@@ -710,7 +767,8 @@ test_deflate_comp_decomp(const char * const test_bufs[],
data_size,
ts_params->small_mbuf_pool,
ts_params->large_mbuf_pool,
- MAX_SEGS) < 0)
+ MAX_SEGS,
+ offset) < 0)
goto exit;
}
@@ -718,7 +776,7 @@ test_deflate_comp_decomp(const char * const test_bufs[],
for (i = 0; i < num_bufs; i++) {
data_size = strlen(test_bufs[i]) *
COMPRESS_BUF_SIZE_RATIO;
- rte_pktmbuf_append(comp_bufs[i], data_size);
+ rte_pktmbuf_append(comp_bufs[i], data_size + offset);
}
}
@@ -734,9 +792,9 @@ test_deflate_comp_decomp(const char * const test_bufs[],
for (i = 0; i < num_bufs; i++) {
ops[i]->m_src = uncomp_bufs[i];
ops[i]->m_dst = comp_bufs[i];
- ops[i]->src.offset = 0;
- ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
- ops[i]->dst.offset = 0;
+ ops[i]->src.offset = offset;
+ ops[i]->src.length = strlen(test_bufs[i]) + 1;
+ ops[i]->dst.offset = offset;
if (state == RTE_COMP_OP_STATELESS) {
ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
} else {
@@ -906,10 +964,11 @@ test_deflate_comp_decomp(const char * const test_bufs[],
(ops_processed[i] + 1);
data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
- data_size,
+ data_size + offset,
ts_params->small_mbuf_pool,
ts_params->large_mbuf_pool,
- MAX_SEGS) < 0)
+ MAX_SEGS,
+ 0) < 0)
goto exit;
}
@@ -918,7 +977,7 @@ test_deflate_comp_decomp(const char * const test_bufs[],
priv_data = (struct priv_op_data *)
(ops_processed[i] + 1);
data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
- rte_pktmbuf_append(uncomp_bufs[i], data_size);
+ rte_pktmbuf_append(uncomp_bufs[i], data_size + offset);
}
}
@@ -935,13 +994,13 @@ test_deflate_comp_decomp(const char * const test_bufs[],
for (i = 0; i < num_bufs; i++) {
ops[i]->m_src = ops_processed[i]->m_dst;
ops[i]->m_dst = uncomp_bufs[i];
- ops[i]->src.offset = 0;
+ ops[i]->src.offset = offset;
/*
* Set the length of the compressed data to the
* number of bytes that were produced in the previous stage
*/
ops[i]->src.length = ops_processed[i]->produced;
- ops[i]->dst.offset = 0;
+ ops[i]->dst.offset = offset;
if (state == RTE_COMP_OP_STATELESS) {
ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
} else {
@@ -1108,7 +1167,8 @@ test_deflate_comp_decomp(const char * const test_bufs[],
goto exit;
}
- buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
+ buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst,
+ ops_processed[i]->dst.offset,
ops_processed[i]->produced, contig_buf);
if (compare_buffers(buf1, strlen(buf1) + 1,
@@ -1178,7 +1238,8 @@ test_compressdev_deflate_stateless_fixed(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_DECOMPRESS) < 0) {
+ ZLIB_DECOMPRESS,
+ 0) < 0) {
ret = TEST_FAILED;
goto exit;
}
@@ -1191,7 +1252,8 @@ test_compressdev_deflate_stateless_fixed(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_COMPRESS) < 0) {
+ ZLIB_COMPRESS,
+ 0) < 0) {
ret = TEST_FAILED;
goto exit;
}
@@ -1244,7 +1306,8 @@ test_compressdev_deflate_stateless_dynamic(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_DECOMPRESS) < 0) {
+ ZLIB_DECOMPRESS,
+ 0) < 0) {
ret = TEST_FAILED;
goto exit;
}
@@ -1257,7 +1320,8 @@ test_compressdev_deflate_stateless_dynamic(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_COMPRESS) < 0) {
+ ZLIB_COMPRESS,
+ 0) < 0) {
ret = TEST_FAILED;
goto exit;
}
@@ -1289,7 +1353,8 @@ test_compressdev_deflate_stateless_multi_op(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_DECOMPRESS) < 0)
+ ZLIB_DECOMPRESS,
+ 0) < 0)
return TEST_FAILED;
/* Compress with Zlib, decompress with compressdev */
@@ -1300,7 +1365,8 @@ test_compressdev_deflate_stateless_multi_op(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_COMPRESS) < 0)
+ ZLIB_COMPRESS,
+ 0) < 0)
return TEST_FAILED;
return TEST_SUCCESS;
@@ -1340,7 +1406,8 @@ test_compressdev_deflate_stateless_multi_level(void)
1,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_DECOMPRESS) < 0) {
+ ZLIB_DECOMPRESS,
+ 0) < 0) {
ret = TEST_FAILED;
goto exit;
}
@@ -1411,7 +1478,8 @@ test_compressdev_deflate_stateless_multi_xform(void)
NUM_XFORMS,
RTE_COMP_OP_STATELESS,
0,
- ZLIB_DECOMPRESS) < 0) {
+ ZLIB_DECOMPRESS,
+ 0) < 0) {
ret = TEST_FAILED;
goto exit;
}
@@ -1450,7 +1518,8 @@ test_compressdev_deflate_stateless_sgl(void)
1,
RTE_COMP_OP_STATELESS,
1,
- ZLIB_DECOMPRESS) < 0)
+ ZLIB_COMPRESS,
+ 0) < 0)
return TEST_FAILED;
/* Compress with Zlib, decompress with compressdev */
@@ -1461,7 +1530,81 @@ test_compressdev_deflate_stateless_sgl(void)
1,
RTE_COMP_OP_STATELESS,
1,
- ZLIB_COMPRESS) < 0)
+ ZLIB_DECOMPRESS,
+ 0) < 0)
+ return TEST_FAILED;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static int
+test_compressdev_deflate_stateless_offset(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ uint16_t i;
+ const char *test_buffer;
+ const struct rte_compressdev_capabilities *capab;
+
+ 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_OOP_SGL_IN_SGL_OUT)) {
+
+ /* Test SGL with offset, which spans across multiple segments */
+ for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
+ test_buffer = compress_test_bufs[i];
+ /* Compress with compressdev, decompress with Zlib */
+ if (test_deflate_comp_decomp(&test_buffer, 1,
+ &i,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1,
+ RTE_COMP_OP_STATELESS,
+ 1,
+ ZLIB_DECOMPRESS,
+ OFFSET) < 0)
+ return TEST_FAILED;
+
+ /* Compress with Zlib, decompress with compressdev */
+ if (test_deflate_comp_decomp(&test_buffer, 1,
+ &i,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1,
+ RTE_COMP_OP_STATELESS,
+ 1,
+ ZLIB_COMPRESS,
+ OFFSET) < 0)
+ return TEST_FAILED;
+ }
+ }
+
+ /* Test linear buffer with offset */
+ for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
+ test_buffer = compress_test_bufs[i];
+ /* Compress with compressdev, decompress with Zlib */
+ if (test_deflate_comp_decomp(&test_buffer, 1,
+ &i,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1,
+ RTE_COMP_OP_STATELESS,
+ 0,
+ ZLIB_DECOMPRESS,
+ OFFSET) < 0)
+ return TEST_FAILED;
+
+ /* Compress with Zlib, decompress with compressdev */
+ if (test_deflate_comp_decomp(&test_buffer, 1,
+ &i,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1,
+ RTE_COMP_OP_STATELESS,
+ 0,
+ ZLIB_COMPRESS,
+ OFFSET) < 0)
return TEST_FAILED;
}
@@ -1487,6 +1630,8 @@ static struct unit_test_suite compressdev_testsuite = {
test_compressdev_deflate_stateless_multi_xform),
TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
test_compressdev_deflate_stateless_sgl),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateless_offset),
TEST_CASES_END() /**< NULL terminate unit test array */
}
};
--
2.7.4
