};
struct test_data_params {
- enum rte_comp_op_type state;
+ enum rte_comp_op_type compress_state;
+ enum rte_comp_op_type decompress_state;
enum varied_buff buff_type;
enum zlib_direction zlib_dir;
unsigned int out_of_space;
unsigned int big_data;
+ /* stateful decompression specific parameters */
+ unsigned int decompress_output_block_size;
+ unsigned int decompress_steps_max;
+ /* external mbufs specific parameters */
+ unsigned int use_external_mbufs;
+ unsigned int inbuf_data_size;
+ const struct rte_memzone *inbuf_memzone;
+ const struct rte_memzone *compbuf_memzone;
+ const struct rte_memzone *uncompbuf_memzone;
};
static struct comp_testsuite_params testsuite_params = { 0 };
.socket_id = rte_socket_id(),
.nb_queue_pairs = 1,
.max_nb_priv_xforms = NUM_MAX_XFORMS,
- .max_nb_streams = 0
+ .max_nb_streams = 1
};
if (rte_compressdev_configure(0, &config) < 0) {
.socket_id = rte_socket_id(),
.nb_queue_pairs = 1,
.max_nb_priv_xforms = NUM_MAX_XFORMS,
- .max_nb_streams = 0
+ .max_nb_streams = 1
};
struct rte_compressdev_info dev_info;
return 0;
}
+static void
+extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
+{
+}
+
/*
* Compresses and decompresses buffer with compressdev API and Zlib API
*/
struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
unsigned int num_xforms = int_data->num_xforms;
- enum rte_comp_op_type state = test_data->state;
+ enum rte_comp_op_type compress_state = test_data->compress_state;
+ enum rte_comp_op_type decompress_state = test_data->decompress_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_status = TEST_FAILED;
+ struct rte_mbuf_ext_shared_info inbuf_info;
+ struct rte_mbuf_ext_shared_info compbuf_info;
+ struct rte_mbuf_ext_shared_info decompbuf_info;
int ret;
struct rte_mbuf *uncomp_bufs[num_bufs];
struct rte_mbuf *comp_bufs[num_bufs];
rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
char *contig_buf = NULL;
uint64_t compress_checksum[num_bufs];
+ void *stream = NULL;
+ char *all_decomp_data = NULL;
+ unsigned int decomp_produced_data_size = 0;
+ unsigned int step = 0;
+
+ TEST_ASSERT(decompress_state == RTE_COMP_OP_STATELESS || num_bufs == 1,
+ "Number of stateful operations in a step should be 1");
if (capa == NULL) {
RTE_LOG(ERR, USER1,
"Compress device does not support DEFLATE\n");
- return -1;
+ return -ENOTSUP;
}
/* Initialize all arrays to NULL */
memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
memset(priv_xforms, 0, sizeof(void *) * num_bufs);
+ if (decompress_state == RTE_COMP_OP_STATEFUL) {
+ data_size = strlen(test_bufs[0]) + 1;
+ all_decomp_data = rte_malloc(NULL, data_size,
+ RTE_CACHE_LINE_SIZE);
+ }
+
if (big_data)
buf_pool = ts_params->big_mbuf_pool;
else if (buff_type == SGL_BOTH)
goto exit;
}
- if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
+ if (test_data->use_external_mbufs) {
+ inbuf_info.free_cb = extbuf_free_callback;
+ inbuf_info.fcb_opaque = NULL;
+ rte_mbuf_ext_refcnt_set(&inbuf_info, 1);
+ for (i = 0; i < num_bufs; i++) {
+ rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
+ test_data->inbuf_memzone->addr,
+ test_data->inbuf_memzone->iova,
+ test_data->inbuf_data_size,
+ &inbuf_info);
+ rte_pktmbuf_append(uncomp_bufs[i],
+ test_data->inbuf_data_size);
+ }
+ } else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
for (i = 0; i < num_bufs; i++) {
data_size = strlen(test_bufs[i]) + 1;
if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
goto exit;
}
- if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+ if (test_data->use_external_mbufs) {
+ compbuf_info.free_cb = extbuf_free_callback;
+ compbuf_info.fcb_opaque = NULL;
+ rte_mbuf_ext_refcnt_set(&compbuf_info, 1);
+ for (i = 0; i < num_bufs; i++) {
+ rte_pktmbuf_attach_extbuf(comp_bufs[i],
+ test_data->compbuf_memzone->addr,
+ test_data->compbuf_memzone->iova,
+ test_data->compbuf_memzone->len,
+ &compbuf_info);
+ rte_pktmbuf_append(comp_bufs[i],
+ test_data->compbuf_memzone->len);
+ }
+ } else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
for (i = 0; i < num_bufs; i++) {
if (out_of_space == 1 && oos_zlib_decompress)
data_size = OUT_OF_SPACE_BUF;
ops[i]->src.offset = 0;
ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
ops[i]->dst.offset = 0;
- if (state == RTE_COMP_OP_STATELESS) {
+ if (compress_state == RTE_COMP_OP_STATELESS)
ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
- } else {
+ else {
RTE_LOG(ERR, USER1,
"Stateful operations are not supported "
"in these tests yet\n");
if (out_of_space && oos_zlib_decompress) {
if (ops_processed[i]->status !=
RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
- ret_status = -1;
-
+ ret_status = TEST_FAILED;
RTE_LOG(ERR, USER1,
"Operation without expected out of "
"space status error\n");
}
if (out_of_space && oos_zlib_decompress) {
- ret_status = 0;
+ ret_status = TEST_SUCCESS;
goto exit;
}
goto exit;
}
- if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+ if (test_data->use_external_mbufs) {
+ decompbuf_info.free_cb = extbuf_free_callback;
+ decompbuf_info.fcb_opaque = NULL;
+ rte_mbuf_ext_refcnt_set(&decompbuf_info, 1);
+ for (i = 0; i < num_bufs; i++) {
+ rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
+ test_data->uncompbuf_memzone->addr,
+ test_data->uncompbuf_memzone->iova,
+ test_data->uncompbuf_memzone->len,
+ &decompbuf_info);
+ rte_pktmbuf_append(uncomp_bufs[i],
+ test_data->uncompbuf_memzone->len);
+ }
+ } else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
for (i = 0; i < num_bufs; i++) {
priv_data = (struct priv_op_data *)
(ops_processed[i] + 1);
if (out_of_space == 1 && oos_zlib_compress)
data_size = OUT_OF_SPACE_BUF;
+ else if (test_data->decompress_output_block_size != 0)
+ data_size =
+ test_data->decompress_output_block_size;
else
data_size =
strlen(test_bufs[priv_data->orig_idx]) + 1;
(ops_processed[i] + 1);
if (out_of_space == 1 && oos_zlib_compress)
data_size = OUT_OF_SPACE_BUF;
+ else if (test_data->decompress_output_block_size != 0)
+ data_size =
+ test_data->decompress_output_block_size;
else
data_size =
strlen(test_bufs[priv_data->orig_idx]) + 1;
* number of bytes that were produced in the previous stage
*/
ops[i]->src.length = ops_processed[i]->produced;
+
ops[i]->dst.offset = 0;
- if (state == RTE_COMP_OP_STATELESS) {
+ if (decompress_state == RTE_COMP_OP_STATELESS) {
ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
+ ops[i]->op_type = RTE_COMP_OP_STATELESS;
+ } else if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_NONE) {
+ ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
+ ops[i]->op_type = RTE_COMP_OP_STATEFUL;
} else {
RTE_LOG(ERR, USER1,
"Stateful operations are not supported "
ops_processed[i] = ops[i];
}
} else {
- /* Create decompress private xform data */
- for (i = 0; i < num_xforms; i++) {
- ret = rte_compressdev_private_xform_create(0,
- (const struct rte_comp_xform *)decompress_xforms[i],
- &priv_xforms[i]);
- if (ret < 0) {
- RTE_LOG(ERR, USER1,
- "Decompression private xform "
- "could not be created\n");
- goto exit;
- }
- num_priv_xforms++;
- }
-
- if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
- /* Attach shareable private xform data to ops */
- for (i = 0; i < num_bufs; i++) {
- priv_data = (struct priv_op_data *)(ops[i] + 1);
- uint16_t xform_idx = priv_data->orig_idx %
- num_xforms;
- ops[i]->private_xform = priv_xforms[xform_idx];
- }
- } else {
- /* Create rest of the private xforms for the other ops */
- for (i = num_xforms; i < num_bufs; i++) {
+ if (decompress_state == RTE_COMP_OP_STATELESS) {
+ /* Create decompress private xform data */
+ for (i = 0; i < num_xforms; i++) {
ret = rte_compressdev_private_xform_create(0,
- decompress_xforms[i % num_xforms],
+ (const struct rte_comp_xform *)
+ decompress_xforms[i],
&priv_xforms[i]);
if (ret < 0) {
RTE_LOG(ERR, USER1,
num_priv_xforms++;
}
- /* Attach non shareable private xform data to ops */
- for (i = 0; i < num_bufs; i++) {
- priv_data = (struct priv_op_data *)(ops[i] + 1);
- uint16_t xform_idx = priv_data->orig_idx;
- ops[i]->private_xform = priv_xforms[xform_idx];
+ if (capa->comp_feature_flags &
+ RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
+ /* Attach shareable private xform data to ops */
+ for (i = 0; i < num_bufs; i++) {
+ priv_data = (struct priv_op_data *)
+ (ops[i] + 1);
+ uint16_t xform_idx =
+ priv_data->orig_idx % num_xforms;
+ ops[i]->private_xform =
+ priv_xforms[xform_idx];
+ }
+ } else {
+ /* Create rest of the private xforms */
+ /* for the other ops */
+ for (i = num_xforms; i < num_bufs; i++) {
+ ret =
+ rte_compressdev_private_xform_create(0,
+ decompress_xforms[i % num_xforms],
+ &priv_xforms[i]);
+ if (ret < 0) {
+ RTE_LOG(ERR, USER1,
+ "Decompression private xform could not be created\n");
+ goto exit;
+ }
+ num_priv_xforms++;
+ }
+
+ /* Attach non shareable private xform data */
+ /* to ops */
+ for (i = 0; i < num_bufs; i++) {
+ priv_data = (struct priv_op_data *)
+ (ops[i] + 1);
+ uint16_t xform_idx =
+ priv_data->orig_idx;
+ ops[i]->private_xform =
+ priv_xforms[xform_idx];
+ }
}
+ } else {
+ /* Create a stream object for stateful decompression */
+ ret = rte_compressdev_stream_create(0,
+ decompress_xforms[0], &stream);
+ if (ret < 0) {
+ RTE_LOG(ERR, USER1,
+ "Decompression stream could not be created, error %d\n",
+ ret);
+ goto exit;
+ }
+ /* Attach stream to ops */
+ for (i = 0; i < num_bufs; i++)
+ ops[i]->stream = stream;
}
+next_step:
/* Enqueue and dequeue all operations */
num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
if (num_enqd < num_bufs) {
if (out_of_space && oos_zlib_compress) {
if (ops_processed[i]->status !=
RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
- ret_status = -1;
-
+ ret_status = TEST_FAILED;
RTE_LOG(ERR, USER1,
"Operation without expected out of "
"space status error\n");
continue;
}
- if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
+ if (decompress_state == RTE_COMP_OP_STATEFUL
+ && (ops_processed[i]->status ==
+ RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
+ || ops_processed[i]->status ==
+ RTE_COMP_OP_STATUS_SUCCESS)) {
+ /* collect the output into all_decomp_data */
+ const void *ptr = rte_pktmbuf_read(
+ ops_processed[i]->m_dst,
+ ops_processed[i]->dst.offset,
+ ops_processed[i]->produced,
+ all_decomp_data +
+ decomp_produced_data_size);
+ if (ptr != all_decomp_data + decomp_produced_data_size)
+ rte_memcpy(all_decomp_data +
+ decomp_produced_data_size,
+ ptr, ops_processed[i]->produced);
+ decomp_produced_data_size += ops_processed[i]->produced;
+ if (ops_processed[i]->src.length >
+ ops_processed[i]->consumed) {
+ if (ops_processed[i]->status ==
+ RTE_COMP_OP_STATUS_SUCCESS) {
+ ret_status = -1;
+ RTE_LOG(ERR, USER1,
+ "Operation finished too early\n");
+ goto exit;
+ }
+ step++;
+ if (step >= test_data->decompress_steps_max) {
+ ret_status = -1;
+ RTE_LOG(ERR, USER1,
+ "Operation exceeded maximum steps\n");
+ goto exit;
+ }
+ ops[i] = ops_processed[i];
+ ops[i]->status =
+ RTE_COMP_OP_STATUS_NOT_PROCESSED;
+ ops[i]->src.offset +=
+ ops_processed[i]->consumed;
+ ops[i]->src.length -=
+ ops_processed[i]->consumed;
+ goto next_step;
+ } else {
+ /* Compare the original stream with the */
+ /* decompressed stream (in size and the data) */
+ priv_data = (struct priv_op_data *)
+ (ops_processed[i] + 1);
+ const char *buf1 =
+ test_bufs[priv_data->orig_idx];
+ const char *buf2 = all_decomp_data;
+
+ if (compare_buffers(buf1, strlen(buf1) + 1,
+ buf2, decomp_produced_data_size) < 0)
+ goto exit;
+ /* Test checksums */
+ if (compress_xforms[0]->compress.chksum
+ != RTE_COMP_CHECKSUM_NONE) {
+ if (ops_processed[i]->output_chksum
+ != compress_checksum[i]) {
+ RTE_LOG(ERR, USER1,
+ "The checksums differ\n"
+ "Compression Checksum: %" PRIu64 "\tDecompression "
+ "Checksum: %" PRIu64 "\n", compress_checksum[i],
+ ops_processed[i]->output_chksum);
+ goto exit;
+ }
+ }
+ }
+ } else if (ops_processed[i]->status !=
+ RTE_COMP_OP_STATUS_SUCCESS) {
RTE_LOG(ERR, USER1,
"Some operations were not successful\n");
goto exit;
comp_bufs[priv_data->orig_idx] = NULL;
}
- if (out_of_space && oos_zlib_compress) {
- ret_status = 0;
+ if ((out_of_space && oos_zlib_compress)
+ || (decompress_state == RTE_COMP_OP_STATEFUL)) {
+ ret_status = TEST_SUCCESS;
goto exit;
}
*/
for (i = 0; i < num_bufs; i++) {
priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
- const char *buf1 = test_bufs[priv_data->orig_idx];
+ const char *buf1 = test_data->use_external_mbufs ?
+ test_data->inbuf_memzone->addr :
+ test_bufs[priv_data->orig_idx];
const char *buf2;
+ data_size = test_data->use_external_mbufs ?
+ test_data->inbuf_data_size :
+ strlen(buf1) + 1;
contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
if (contig_buf == NULL) {
RTE_LOG(ERR, USER1, "Contiguous buffer could not "
buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
ops_processed[i]->produced, contig_buf);
- if (compare_buffers(buf1, strlen(buf1) + 1,
+ if (compare_buffers(buf1, data_size,
buf2, ops_processed[i]->produced) < 0)
goto exit;
contig_buf = NULL;
}
- ret_status = 0;
+ ret_status = TEST_SUCCESS;
exit:
/* Free resources */
rte_comp_op_free(ops[i]);
rte_comp_op_free(ops_processed[i]);
}
- for (i = 0; i < num_priv_xforms; i++) {
+ for (i = 0; i < num_priv_xforms; i++)
if (priv_xforms[i] != NULL)
rte_compressdev_private_xform_free(0, priv_xforms[i]);
- }
+ if (stream != NULL)
+ rte_compressdev_stream_free(0, stream);
+ if (all_decomp_data != NULL)
+ rte_free(all_decomp_data);
rte_free(contig_buf);
return ret_status;
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
for (i = 0; i < RTE_DIM(compress_test_bufs); 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
/* 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
ret = TEST_SUCCESS;
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
for (i = 0; i < RTE_DIM(compress_test_bufs); 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
/* 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
ret = TEST_SUCCESS;
uint16_t num_bufs = RTE_DIM(compress_test_bufs);
uint16_t buf_idx[num_bufs];
uint16_t i;
+ int ret;
for (i = 0; i < num_bufs; i++)
buf_idx[i] = i;
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
/* Compress with compressdev, decompress with Zlib */
test_data.zlib_dir = ZLIB_DECOMPRESS;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
/* Compress with Zlib, decompress with compressdev */
test_data.zlib_dir = ZLIB_COMPRESS;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
return TEST_SUCCESS;
}
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
compress_xform->compress.level = level;
/* 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
}
uint16_t i;
unsigned int level = RTE_COMP_LEVEL_MIN;
uint16_t buf_idx[num_bufs];
-
int ret;
/* Create multiple xforms with various levels */
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
/* Compress with compressdev, decompress with Zlib */
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
ret = TEST_SUCCESS;
+
exit:
for (i = 0; i < NUM_XFORMS; i++) {
rte_free(compress_xforms[i]);
{
struct comp_testsuite_params *ts_params = &testsuite_params;
uint16_t i;
+ int ret;
const struct rte_compressdev_capabilities *capab;
capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- SGL_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = SGL_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
/* Compress with compressdev, decompress with Zlib */
test_data.zlib_dir = ZLIB_DECOMPRESS;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
/* Compress with Zlib, decompress with compressdev */
test_data.zlib_dir = ZLIB_COMPRESS;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) {
/* Compress with compressdev, decompress with Zlib */
test_data.zlib_dir = ZLIB_DECOMPRESS;
test_data.buff_type = SGL_TO_LB;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
/* Compress with Zlib, decompress with compressdev */
test_data.zlib_dir = ZLIB_COMPRESS;
test_data.buff_type = SGL_TO_LB;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
}
if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) {
/* Compress with compressdev, decompress with Zlib */
test_data.zlib_dir = ZLIB_DECOMPRESS;
test_data.buff_type = LB_TO_SGL;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
/* Compress with Zlib, decompress with compressdev */
test_data.zlib_dir = ZLIB_COMPRESS;
test_data.buff_type = LB_TO_SGL;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
- return TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ return ret;
}
-
-
}
return TEST_SUCCESS;
-
}
static int
rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
if (compress_xform == NULL) {
RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
- ret = TEST_FAILED;
- return ret;
+ return TEST_FAILED;
}
memcpy(compress_xform, ts_params->def_comp_xform,
if (decompress_xform == NULL) {
RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
rte_free(compress_xform);
- ret = TEST_FAILED;
- return ret;
+ return TEST_FAILED;
}
memcpy(decompress_xform, ts_params->def_decomp_xform,
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0
};
/* Check if driver supports crc32 checksum and test */
* drivers decompression checksum
*/
test_data.zlib_dir = ZLIB_COMPRESS;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
/* Generate compression and decompression
* checksum of selected driver
*/
test_data.zlib_dir = ZLIB_NONE;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
}
* drivers decompression checksum
*/
test_data.zlib_dir = ZLIB_COMPRESS;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
/* Generate compression and decompression
* checksum of selected driver
*/
test_data.zlib_dir = ZLIB_NONE;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
}
* checksum of selected driver
*/
test_data.zlib_dir = ZLIB_NONE;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
}
uint16_t i;
const struct rte_compressdev_capabilities *capab;
- RTE_LOG(ERR, USER1, "This is a negative test errors are expected\n");
+ RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
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_FIXED) == 0)
return -ENOTSUP;
- struct rte_comp_xform *compress_xform =
- rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
-
- if (compress_xform == NULL) {
- RTE_LOG(ERR, USER1,
- "Compress xform could not be created\n");
- ret = TEST_FAILED;
- goto exit;
- }
-
struct interim_data_params int_data = {
&compress_test_bufs[0],
1,
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- LB_BOTH,
- ZLIB_DECOMPRESS,
- 1, /* run out-of-space test */
- 0
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 1, /* run out-of-space test */
+ .big_data = 0
};
/* 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
/* 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;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
/* Compress with compressdev, decompress with Zlib */
test_data.zlib_dir = ZLIB_DECOMPRESS;
test_data.buff_type = SGL_BOTH;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
/* Compress with Zlib, decompress with compressdev */
test_data.zlib_dir = ZLIB_COMPRESS;
test_data.buff_type = SGL_BOTH;
- if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
- ret = TEST_FAILED;
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
goto exit;
- }
}
ret = TEST_SUCCESS;
exit:
- rte_free(compress_xform);
return ret;
}
{
struct comp_testsuite_params *ts_params = &testsuite_params;
uint16_t i = 0;
- int ret = TEST_SUCCESS;
+ int ret;
int j;
const struct rte_compressdev_capabilities *capab;
char *test_buffer = NULL;
};
struct test_data_params test_data = {
- RTE_COMP_OP_STATELESS,
- SGL_BOTH,
- ZLIB_DECOMPRESS,
- 0,
- 1
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = SGL_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 1
};
ts_params->def_comp_xform->compress.deflate.huffman =
/* 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;
- }
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ goto exit;
/* 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;
- }
+ ret = test_deflate_comp_decomp(&int_data, &test_data);
+ if (ret < 0)
+ goto exit;
+
+ ret = TEST_SUCCESS;
-end:
+exit:
ts_params->def_comp_xform->compress.deflate.huffman =
RTE_COMP_HUFFMAN_DEFAULT;
rte_free(test_buffer);
return ret;
}
+static int
+test_compressdev_deflate_stateful_decomp(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ int ret;
+ uint16_t i;
+ 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_STATEFUL_DECOMPRESSION))
+ return -ENOTSUP;
+
+ struct interim_data_params int_data = {
+ &compress_test_bufs[0],
+ 1,
+ &i,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1
+ };
+
+ struct test_data_params test_data = {
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATEFUL,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_COMPRESS,
+ .out_of_space = 0,
+ .big_data = 0,
+ .decompress_output_block_size = 2000,
+ .decompress_steps_max = 4
+ };
+
+ /* Compress with Zlib, decompress with compressdev */
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+
+ if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
+ /* Now test with SGL buffers */
+ test_data.buff_type = SGL_BOTH;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ }
+
+ ret = TEST_SUCCESS;
+
+exit:
+ return ret;
+}
+
+static int
+test_compressdev_deflate_stateful_decomp_checksum(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ int ret;
+ uint16_t i;
+ 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_STATEFUL_DECOMPRESSION))
+ return -ENOTSUP;
+
+ /* Check if driver supports any checksum */
+ if (!(capab->comp_feature_flags &
+ (RTE_COMP_FF_CRC32_CHECKSUM | RTE_COMP_FF_ADLER32_CHECKSUM |
+ RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)))
+ return -ENOTSUP;
+
+ struct rte_comp_xform *compress_xform =
+ rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
+ if (compress_xform == NULL) {
+ RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
+ return TEST_FAILED;
+ }
+
+ memcpy(compress_xform, ts_params->def_comp_xform,
+ sizeof(struct rte_comp_xform));
+
+ struct rte_comp_xform *decompress_xform =
+ rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
+ if (decompress_xform == NULL) {
+ RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
+ rte_free(compress_xform);
+ return TEST_FAILED;
+ }
+
+ memcpy(decompress_xform, ts_params->def_decomp_xform,
+ sizeof(struct rte_comp_xform));
+
+ struct interim_data_params int_data = {
+ &compress_test_bufs[0],
+ 1,
+ &i,
+ &compress_xform,
+ &decompress_xform,
+ 1
+ };
+
+ struct test_data_params test_data = {
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATEFUL,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_COMPRESS,
+ .out_of_space = 0,
+ .big_data = 0,
+ .decompress_output_block_size = 2000,
+ .decompress_steps_max = 4
+ };
+
+ /* Check if driver supports crc32 checksum and test */
+ if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) {
+ compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
+ decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
+ /* Compress with Zlib, decompress with compressdev */
+ test_data.buff_type = LB_BOTH;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ if (capab->comp_feature_flags &
+ RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
+ /* Now test with SGL buffers */
+ test_data.buff_type = SGL_BOTH;
+ if (test_deflate_comp_decomp(&int_data,
+ &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ }
+ }
+
+ /* Check if driver supports adler32 checksum and test */
+ if (capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM) {
+ compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
+ decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
+ /* Compress with Zlib, decompress with compressdev */
+ test_data.buff_type = LB_BOTH;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ if (capab->comp_feature_flags &
+ RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
+ /* Now test with SGL buffers */
+ test_data.buff_type = SGL_BOTH;
+ if (test_deflate_comp_decomp(&int_data,
+ &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ }
+ }
+
+ /* Check if driver supports combined crc and adler checksum and test */
+ if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) {
+ compress_xform->compress.chksum =
+ RTE_COMP_CHECKSUM_CRC32_ADLER32;
+ decompress_xform->decompress.chksum =
+ RTE_COMP_CHECKSUM_CRC32_ADLER32;
+ /* Zlib doesn't support combined checksum */
+ test_data.zlib_dir = ZLIB_NONE;
+ /* Compress stateless, decompress stateful with compressdev */
+ test_data.buff_type = LB_BOTH;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ if (capab->comp_feature_flags &
+ RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
+ /* Now test with SGL buffers */
+ test_data.buff_type = SGL_BOTH;
+ if (test_deflate_comp_decomp(&int_data,
+ &test_data) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ }
+ }
+
+ ret = TEST_SUCCESS;
+
+exit:
+ rte_free(compress_xform);
+ rte_free(decompress_xform);
+ return ret;
+}
+
+static const struct rte_memzone *
+make_memzone(const char *name, 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_%u", name, socket_id);
+ 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",
+ mz_name);
+ }
+ return memzone;
+}
+
+static int
+test_compressdev_external_mbufs(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ size_t data_len = 0;
+ uint16_t i;
+ int ret = TEST_FAILED;
+
+ for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
+ data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1);
+
+ struct interim_data_params int_data = {
+ NULL,
+ 1,
+ NULL,
+ &ts_params->def_comp_xform,
+ &ts_params->def_decomp_xform,
+ 1
+ };
+
+ struct test_data_params test_data = {
+ .compress_state = RTE_COMP_OP_STATELESS,
+ .decompress_state = RTE_COMP_OP_STATELESS,
+ .buff_type = LB_BOTH,
+ .zlib_dir = ZLIB_DECOMPRESS,
+ .out_of_space = 0,
+ .big_data = 0,
+ .use_external_mbufs = 1,
+ .inbuf_data_size = data_len,
+ .inbuf_memzone = make_memzone("inbuf", data_len),
+ .compbuf_memzone = make_memzone("compbuf", data_len *
+ COMPRESS_BUF_SIZE_RATIO),
+ .uncompbuf_memzone = make_memzone("decompbuf", data_len)
+ };
+
+ for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
+ /* prepare input data */
+ data_len = strlen(compress_test_bufs[i]) + 1;
+ rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i],
+ data_len);
+ test_data.inbuf_data_size = data_len;
+ 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)
+ goto exit;
+
+ /* Compress with Zlib, decompress with compressdev */
+ test_data.zlib_dir = ZLIB_COMPRESS;
+ if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
+ goto exit;
+ }
+
+ ret = TEST_SUCCESS;
+
+exit:
+ rte_memzone_free(test_data.inbuf_memzone);
+ rte_memzone_free(test_data.compbuf_memzone);
+ rte_memzone_free(test_data.uncompbuf_memzone);
+ return ret;
+}
static struct unit_test_suite compressdev_testsuite = {
.suite_name = "compressdev unit test suite",
test_compressdev_deflate_stateless_checksum),
TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
test_compressdev_out_of_space_buffer),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateful_decomp),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateful_decomp_checksum),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_external_mbufs),
TEST_CASES_END() /**< NULL terminate unit test array */
}
};
git.droids-corp.org / dpdk.git / blobdiff