#include "test_compressdev_test_buffer.h"
#include "test.h"
+#define DIV_CEIL(a, b) ((a) / (b) + ((a) % (b) != 0))
+
#define DEFAULT_WINDOW_SIZE 15
#define DEFAULT_MEM_LEVEL 8
#define MAX_DEQD_RETRIES 10
* due to the compress block headers
*/
#define COMPRESS_BUF_SIZE_RATIO 1.3
-#define NUM_MBUFS 16
+#define NUM_LARGE_MBUFS 16
+#define SMALL_SEG_SIZE 256
+#define MAX_SEGS 16
#define NUM_OPS 16
-#define NUM_MAX_XFORMS 1
+#define NUM_MAX_XFORMS 16
#define NUM_MAX_INFLIGHT_OPS 128
#define CACHE_SIZE 0
};
struct comp_testsuite_params {
- struct rte_mempool *mbuf_pool;
+ struct rte_mempool *large_mbuf_pool;
+ struct rte_mempool *small_mbuf_pool;
struct rte_mempool *op_pool;
- struct rte_comp_xform def_comp_xform;
- struct rte_comp_xform def_decomp_xform;
+ struct rte_comp_xform *def_comp_xform;
+ struct rte_comp_xform *def_decomp_xform;
};
static struct comp_testsuite_params testsuite_params = { 0 };
{
struct comp_testsuite_params *ts_params = &testsuite_params;
- rte_mempool_free(ts_params->mbuf_pool);
+ rte_mempool_free(ts_params->large_mbuf_pool);
+ rte_mempool_free(ts_params->small_mbuf_pool);
rte_mempool_free(ts_params->op_pool);
+ rte_free(ts_params->def_comp_xform);
+ rte_free(ts_params->def_decomp_xform);
}
static int
testsuite_setup(void)
{
struct comp_testsuite_params *ts_params = &testsuite_params;
+ uint32_t max_buf_size = 0;
unsigned int i;
if (rte_compressdev_count() == 0) {
return TEST_FAILED;
}
- uint32_t max_buf_size = 0;
+ RTE_LOG(NOTICE, USER1, "Running tests on device %s\n",
+ rte_compressdev_name_get(0));
+
for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
max_buf_size = RTE_MAX(max_buf_size,
strlen(compress_test_bufs[i]) + 1);
- max_buf_size *= COMPRESS_BUF_SIZE_RATIO;
/*
* Buffers to be used in compression and decompression.
* Since decompressed data might be larger than
* compressed data (due to block header),
* buffers should be big enough for both cases.
*/
- ts_params->mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool",
- NUM_MBUFS,
+ max_buf_size *= COMPRESS_BUF_SIZE_RATIO;
+ ts_params->large_mbuf_pool = rte_pktmbuf_pool_create("large_mbuf_pool",
+ NUM_LARGE_MBUFS,
CACHE_SIZE, 0,
max_buf_size + RTE_PKTMBUF_HEADROOM,
rte_socket_id());
- if (ts_params->mbuf_pool == NULL) {
+ if (ts_params->large_mbuf_pool == NULL) {
RTE_LOG(ERR, USER1, "Large mbuf pool could not be created\n");
return TEST_FAILED;
}
+ /* Create mempool with smaller buffers for SGL testing */
+ ts_params->small_mbuf_pool = rte_pktmbuf_pool_create("small_mbuf_pool",
+ NUM_LARGE_MBUFS * MAX_SEGS,
+ CACHE_SIZE, 0,
+ SMALL_SEG_SIZE + RTE_PKTMBUF_HEADROOM,
+ rte_socket_id());
+ if (ts_params->small_mbuf_pool == NULL) {
+ RTE_LOG(ERR, USER1, "Small 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());
goto exit;
}
+ ts_params->def_comp_xform =
+ rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
+ if (ts_params->def_comp_xform == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Default compress xform could not be created\n");
+ goto exit;
+ }
+ ts_params->def_decomp_xform =
+ rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
+ if (ts_params->def_decomp_xform == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Default decompress xform could not be created\n");
+ goto exit;
+ }
+
/* Initializes default values for compress/decompress xforms */
- ts_params->def_comp_xform.type = RTE_COMP_COMPRESS;
- ts_params->def_comp_xform.compress.algo = RTE_COMP_ALGO_DEFLATE,
- ts_params->def_comp_xform.compress.deflate.huffman =
+ ts_params->def_comp_xform->type = RTE_COMP_COMPRESS;
+ ts_params->def_comp_xform->compress.algo = RTE_COMP_ALGO_DEFLATE,
+ ts_params->def_comp_xform->compress.deflate.huffman =
RTE_COMP_HUFFMAN_DEFAULT;
- ts_params->def_comp_xform.compress.level = RTE_COMP_LEVEL_PMD_DEFAULT;
- ts_params->def_comp_xform.compress.chksum = RTE_COMP_CHECKSUM_NONE;
- ts_params->def_comp_xform.compress.window_size = DEFAULT_WINDOW_SIZE;
+ ts_params->def_comp_xform->compress.level = RTE_COMP_LEVEL_PMD_DEFAULT;
+ ts_params->def_comp_xform->compress.chksum = RTE_COMP_CHECKSUM_NONE;
+ ts_params->def_comp_xform->compress.window_size = DEFAULT_WINDOW_SIZE;
- ts_params->def_decomp_xform.type = RTE_COMP_DECOMPRESS;
- ts_params->def_decomp_xform.decompress.algo = RTE_COMP_ALGO_DEFLATE,
- ts_params->def_decomp_xform.decompress.chksum = RTE_COMP_CHECKSUM_NONE;
- ts_params->def_decomp_xform.decompress.window_size = DEFAULT_WINDOW_SIZE;
+ ts_params->def_decomp_xform->type = RTE_COMP_DECOMPRESS;
+ ts_params->def_decomp_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE,
+ ts_params->def_decomp_xform->decompress.chksum = RTE_COMP_CHECKSUM_NONE;
+ ts_params->def_decomp_xform->decompress.window_size = DEFAULT_WINDOW_SIZE;
return TEST_SUCCESS;
RTE_LOG(ERR, USER1, "Device could not be closed\n");
}
+static int
+test_compressdev_invalid_configuration(void)
+{
+ struct rte_compressdev_config invalid_config;
+ struct rte_compressdev_config valid_config = {
+ .socket_id = rte_socket_id(),
+ .nb_queue_pairs = 1,
+ .max_nb_priv_xforms = NUM_MAX_XFORMS,
+ .max_nb_streams = 0
+ };
+ struct rte_compressdev_info dev_info;
+
+ /* Invalid configuration with 0 queue pairs */
+ memcpy(&invalid_config, &valid_config,
+ sizeof(struct rte_compressdev_config));
+ invalid_config.nb_queue_pairs = 0;
+
+ TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
+ "Device configuration was successful "
+ "with no queue pairs (invalid)\n");
+
+ /*
+ * Invalid configuration with too many queue pairs
+ * (if there is an actual maximum number of queue pairs)
+ */
+ rte_compressdev_info_get(0, &dev_info);
+ if (dev_info.max_nb_queue_pairs != 0) {
+ memcpy(&invalid_config, &valid_config,
+ sizeof(struct rte_compressdev_config));
+ invalid_config.nb_queue_pairs = dev_info.max_nb_queue_pairs + 1;
+
+ TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
+ "Device configuration was successful "
+ "with too many queue pairs (invalid)\n");
+ }
+
+ /* Invalid queue pair setup, with no number of queue pairs set */
+ TEST_ASSERT_FAIL(rte_compressdev_queue_pair_setup(0, 0,
+ NUM_MAX_INFLIGHT_OPS, rte_socket_id()),
+ "Queue pair setup was successful "
+ "with no queue pairs set (invalid)\n");
+
+ return TEST_SUCCESS;
+}
+
static int
compare_buffers(const char *buffer1, uint32_t buffer1_len,
const char *buffer2, uint32_t buffer2_len)
z_stream stream;
int zlib_flush;
int strategy, window_bits, comp_level;
- int ret = -1;
+ int ret = TEST_FAILED;
+ uint8_t *single_src_buf = NULL;
+ uint8_t *single_dst_buf = NULL;
/* initialize zlib stream */
stream.zalloc = Z_NULL;
}
/* Assuming stateless operation */
- stream.avail_in = op->src.length;
- stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
- stream.avail_out = op->m_dst->data_len;
- stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
+ /* SGL */
+ if (op->m_src->nb_segs > 1) {
+ single_src_buf = rte_malloc(NULL,
+ rte_pktmbuf_pkt_len(op->m_src), 0);
+ if (single_src_buf == NULL) {
+ RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
+ goto exit;
+ }
+ single_dst_buf = rte_malloc(NULL,
+ rte_pktmbuf_pkt_len(op->m_dst), 0);
+ if (single_dst_buf == NULL) {
+ 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),
+ single_src_buf) == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Buffer could not be read entirely\n");
+ goto exit;
+ }
+ stream.avail_in = op->src.length;
+ stream.next_in = single_src_buf;
+ stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst);
+ stream.next_out = single_dst_buf;
+
+ } else {
+ stream.avail_in = op->src.length;
+ stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
+ stream.avail_out = op->m_dst->data_len;
+ stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
+ }
/* Stateless operation, all buffer will be compressed in one go */
zlib_flush = map_zlib_flush_flag(op->flush_flag);
ret = deflate(&stream, zlib_flush);
if (ret != Z_STREAM_END)
goto exit;
- op->consumed = op->src.length - stream.avail_in;
- op->produced = op->m_dst->data_len - stream.avail_out;
+ /* Copy data to destination SGL */
+ if (op->m_src->nb_segs > 1) {
+ uint32_t remaining_data = stream.total_out;
+ uint8_t *src_data = single_dst_buf;
+ struct rte_mbuf *dst_buf = op->m_dst;
+
+ while (remaining_data > 0) {
+ 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);
+ remaining_data = 0;
+ } else {
+ memcpy(dst_data, src_data, dst_buf->data_len);
+ remaining_data -= dst_buf->data_len;
+ src_data += dst_buf->data_len;
+ dst_buf = dst_buf->next;
+ }
+ }
+ }
+
+ op->consumed = stream.total_in;
+ op->produced = stream.total_out;
op->status = RTE_COMP_OP_STATUS_SUCCESS;
deflateReset(&stream);
ret = 0;
exit:
deflateEnd(&stream);
+ rte_free(single_src_buf);
+ rte_free(single_dst_buf);
return ret;
}
int window_bits;
int zlib_flush;
int ret = TEST_FAILED;
+ uint8_t *single_src_buf = NULL;
+ uint8_t *single_dst_buf = NULL;
/* initialize zlib stream */
stream.zalloc = Z_NULL;
}
/* Assuming stateless operation */
- stream.avail_in = op->src.length;
- stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
- stream.avail_out = op->m_dst->data_len;
- stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
+ /* SGL */
+ if (op->m_src->nb_segs > 1) {
+ single_src_buf = rte_malloc(NULL,
+ rte_pktmbuf_pkt_len(op->m_src), 0);
+ if (single_src_buf == NULL) {
+ RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
+ goto exit;
+ }
+ single_dst_buf = rte_malloc(NULL,
+ rte_pktmbuf_pkt_len(op->m_dst), 0);
+ if (single_dst_buf == NULL) {
+ 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),
+ single_src_buf) == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Buffer could not be read entirely\n");
+ goto exit;
+ }
+
+ stream.avail_in = op->src.length;
+ stream.next_in = single_src_buf;
+ stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst);
+ stream.next_out = single_dst_buf;
+
+ } else {
+ stream.avail_in = op->src.length;
+ stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
+ stream.avail_out = op->m_dst->data_len;
+ stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
+ }
/* Stateless operation, all buffer will be compressed in one go */
zlib_flush = map_zlib_flush_flag(op->flush_flag);
if (ret != Z_STREAM_END)
goto exit;
- op->consumed = op->src.length - stream.avail_in;
- op->produced = op->m_dst->data_len - stream.avail_out;
+ if (op->m_src->nb_segs > 1) {
+ uint32_t remaining_data = stream.total_out;
+ uint8_t *src_data = single_dst_buf;
+ struct rte_mbuf *dst_buf = op->m_dst;
+
+ while (remaining_data > 0) {
+ 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);
+ remaining_data = 0;
+ } else {
+ memcpy(dst_data, src_data, dst_buf->data_len);
+ remaining_data -= dst_buf->data_len;
+ src_data += dst_buf->data_len;
+ dst_buf = dst_buf->next;
+ }
+ }
+ }
+
+ op->consumed = stream.total_in;
+ op->produced = stream.total_out;
op->status = RTE_COMP_OP_STATUS_SUCCESS;
inflateReset(&stream);
return ret;
}
+static int
+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)
+{
+ uint32_t remaining_data = total_data_size;
+ uint16_t num_remaining_segs = DIV_CEIL(remaining_data, 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;
+
+ if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl)
+ num_remaining_segs = limit_segs_in_sgl - 1;
+
+ /*
+ * Allocate data in the first segment (header) and
+ * copy data if test buffer is provided
+ */
+ if (remaining_data < SMALL_SEG_SIZE)
+ data_size = remaining_data;
+ else
+ data_size = SMALL_SEG_SIZE;
+ buf_ptr = rte_pktmbuf_append(head_buf, data_size);
+ if (buf_ptr == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Not enough space in the 1st buffer\n");
+ return -1;
+ }
+
+ if (data_ptr != NULL) {
+ /* Copy characters without NULL terminator */
+ strncpy(buf_ptr, data_ptr, data_size);
+ data_ptr += data_size;
+ }
+ remaining_data -= data_size;
+ num_remaining_segs--;
+
+ /*
+ * Allocate the rest of the segments,
+ * copy the rest of the data and chain the segments.
+ */
+ for (i = 0; i < num_remaining_segs; i++) {
+
+ if (i == (num_remaining_segs - 1)) {
+ /* last segment */
+ if (remaining_data > SMALL_SEG_SIZE)
+ pool = large_mbuf_pool;
+ else
+ pool = small_mbuf_pool;
+ data_size = remaining_data;
+ } else {
+ data_size = SMALL_SEG_SIZE;
+ pool = small_mbuf_pool;
+ }
+
+ next_seg = rte_pktmbuf_alloc(pool);
+ if (next_seg == NULL) {
+ RTE_LOG(ERR, USER1,
+ "New segment could not be allocated "
+ "from the mempool\n");
+ return -1;
+ }
+ buf_ptr = rte_pktmbuf_append(next_seg, data_size);
+ if (buf_ptr == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Not enough space in the buffer\n");
+ rte_pktmbuf_free(next_seg);
+ return -1;
+ }
+ if (data_ptr != NULL) {
+ /* Copy characters without NULL terminator */
+ strncpy(buf_ptr, data_ptr, data_size);
+ data_ptr += data_size;
+ }
+ remaining_data -= data_size;
+
+ ret = rte_pktmbuf_chain(head_buf, next_seg);
+ if (ret != 0) {
+ rte_pktmbuf_free(next_seg);
+ RTE_LOG(ERR, USER1,
+ "Segment could not chained\n");
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
/*
* Compresses and decompresses buffer with compressdev API and Zlib API
*/
test_deflate_comp_decomp(const char * const test_bufs[],
unsigned int num_bufs,
uint16_t buf_idx[],
- struct rte_comp_xform *compress_xform,
- struct rte_comp_xform *decompress_xform,
+ struct rte_comp_xform *compress_xforms[],
+ struct rte_comp_xform *decompress_xforms[],
+ unsigned int num_xforms,
enum rte_comp_op_type state,
+ unsigned int sgl,
enum zlib_direction zlib_dir)
{
struct comp_testsuite_params *ts_params = &testsuite_params;
uint16_t num_priv_xforms = 0;
unsigned int deqd_retries = 0;
struct priv_op_data *priv_data;
- char *data_ptr;
+ char *buf_ptr;
unsigned int i;
+ struct rte_mempool *buf_pool;
+ uint32_t data_size;
const struct rte_compressdev_capabilities *capa =
rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+ char *contig_buf = NULL;
/* Initialize all arrays to NULL */
memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
memset(priv_xforms, 0, sizeof(void *) * num_bufs);
+ if (sgl)
+ buf_pool = ts_params->small_mbuf_pool;
+ else
+ buf_pool = ts_params->large_mbuf_pool;
+
/* Prepare the source mbufs with the data */
- ret = rte_pktmbuf_alloc_bulk(ts_params->mbuf_pool, uncomp_bufs, num_bufs);
+ ret = rte_pktmbuf_alloc_bulk(buf_pool,
+ uncomp_bufs, num_bufs);
if (ret < 0) {
RTE_LOG(ERR, USER1,
"Source mbufs could not be allocated "
goto exit;
}
- for (i = 0; i < num_bufs; i++) {
- data_ptr = rte_pktmbuf_append(uncomp_bufs[i],
- strlen(test_bufs[i]) + 1);
- snprintf(data_ptr, strlen(test_bufs[i]) + 1, "%s",
- test_bufs[i]);
+ if (sgl) {
+ 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)
+ 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]);
+ }
}
/* Prepare the destination mbufs */
- ret = rte_pktmbuf_alloc_bulk(ts_params->mbuf_pool, comp_bufs, num_bufs);
+ ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
if (ret < 0) {
RTE_LOG(ERR, USER1,
"Destination mbufs could not be allocated "
goto exit;
}
- for (i = 0; i < num_bufs; i++)
- rte_pktmbuf_append(comp_bufs[i],
- strlen(test_bufs[i]) * COMPRESS_BUF_SIZE_RATIO);
+ if (sgl) {
+ for (i = 0; i < num_bufs; i++) {
+ data_size = strlen(test_bufs[i]) *
+ 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)
+ goto exit;
+ }
+
+ } else {
+ 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);
+ }
+ }
/* Build the compression operations */
ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
/* Compress data (either with Zlib API or compressdev API */
if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
for (i = 0; i < num_bufs; i++) {
- ret = compress_zlib(ops[i],
- (const struct rte_comp_xform *)compress_xform,
+ const struct rte_comp_xform *compress_xform =
+ compress_xforms[i % num_xforms];
+ ret = compress_zlib(ops[i], compress_xform,
DEFAULT_MEM_LEVEL);
if (ret < 0)
goto exit;
ops_processed[i] = ops[i];
}
} else {
- if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
- /* Create single compress private xform data */
+ /* Create compress private xform data */
+ for (i = 0; i < num_xforms; i++) {
ret = rte_compressdev_private_xform_create(0,
- (const struct rte_comp_xform *)compress_xform,
- &priv_xforms[0]);
+ (const struct rte_comp_xform *)compress_xforms[i],
+ &priv_xforms[i]);
if (ret < 0) {
RTE_LOG(ERR, USER1,
"Compression private xform "
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++)
- ops[i]->private_xform = priv_xforms[0];
+ ops[i]->private_xform = priv_xforms[i % num_xforms];
} else {
- /* Create compress private xform data per op */
- for (i = 0; i < num_bufs; i++) {
+ /* 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,
- compress_xform, &priv_xforms[i]);
+ compress_xforms[i % num_xforms],
+ &priv_xforms[i]);
if (ret < 0) {
RTE_LOG(ERR, USER1,
"Compression private xform "
num_priv_xforms = 0;
}
- enum rte_comp_huffman huffman_type =
- compress_xform->compress.deflate.huffman;
for (i = 0; i < num_bufs; i++) {
priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
+ uint16_t xform_idx = priv_data->orig_idx % num_xforms;
+ const struct rte_comp_compress_xform *compress_xform =
+ &compress_xforms[xform_idx]->compress;
+ enum rte_comp_huffman huffman_type =
+ compress_xform->deflate.huffman;
RTE_LOG(DEBUG, USER1, "Buffer %u compressed from %u to %u bytes "
- "(level = %u, huffman = %s)\n",
+ "(level = %d, huffman = %s)\n",
buf_idx[priv_data->orig_idx],
ops_processed[i]->consumed, ops_processed[i]->produced,
- compress_xform->compress.level,
+ compress_xform->level,
huffman_type_strings[huffman_type]);
RTE_LOG(DEBUG, USER1, "Compression ratio = %.2f",
(float)ops_processed[i]->produced /
}
/* Allocate buffers for decompressed data */
- ret = rte_pktmbuf_alloc_bulk(ts_params->mbuf_pool, uncomp_bufs, num_bufs);
+ ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
if (ret < 0) {
RTE_LOG(ERR, USER1,
"Destination mbufs could not be allocated "
goto exit;
}
- for (i = 0; i < num_bufs; i++) {
- priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
- rte_pktmbuf_append(uncomp_bufs[i],
- strlen(test_bufs[priv_data->orig_idx]) + 1);
+ if (sgl) {
+ for (i = 0; i < num_bufs; i++) {
+ priv_data = (struct priv_op_data *)
+ (ops_processed[i] + 1);
+ data_size = 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)
+ goto exit;
+ }
+
+ } else {
+ for (i = 0; i < num_bufs; i++) {
+ 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);
+ }
}
/* Build the decompression operations */
/* Decompress data (either with Zlib API or compressdev API */
if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
for (i = 0; i < num_bufs; i++) {
- ret = decompress_zlib(ops[i],
- (const struct rte_comp_xform *)decompress_xform);
+ priv_data = (struct priv_op_data *)(ops[i] + 1);
+ uint16_t xform_idx = priv_data->orig_idx % num_xforms;
+ const struct rte_comp_xform *decompress_xform =
+ decompress_xforms[xform_idx];
+
+ ret = decompress_zlib(ops[i], decompress_xform);
if (ret < 0)
goto exit;
ops_processed[i] = ops[i];
}
} else {
- if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
- /* Create single decompress private xform data */
+ /* 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_xform,
- &priv_xforms[0]);
+ (const struct rte_comp_xform *)decompress_xforms[i],
+ &priv_xforms[i]);
if (ret < 0) {
RTE_LOG(ERR, USER1,
"Decompression private xform "
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++)
- ops[i]->private_xform = priv_xforms[0];
- } else {
- /* Create decompress private xform data per op */
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_xform, &priv_xforms[i]);
+ decompress_xforms[i % num_xforms],
+ &priv_xforms[i]);
if (ret < 0) {
RTE_LOG(ERR, USER1,
- "Deompression private xform "
+ "Decompression private xform "
"could not be created\n");
goto exit;
}
}
/* Attach non shareable private xform data to ops */
- for (i = 0; i < num_bufs; i++)
- ops[i]->private_xform = priv_xforms[i];
+ 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];
+ }
}
/* Enqueue and dequeue all operations */
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 *buf2 = rte_pktmbuf_mtod(ops_processed[i]->m_dst,
- const char *);
+ const char *buf2;
+ contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
+ if (contig_buf == NULL) {
+ RTE_LOG(ERR, USER1, "Contiguous buffer could not "
+ "be allocated\n");
+ goto exit;
+ }
+
+ buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
+ ops_processed[i]->produced, contig_buf);
if (compare_buffers(buf1, strlen(buf1) + 1,
buf2, ops_processed[i]->produced) < 0)
goto exit;
+
+ rte_free(contig_buf);
+ contig_buf = NULL;
}
ret_status = 0;
if (priv_xforms[i] != NULL)
rte_compressdev_private_xform_free(0, priv_xforms[i]);
}
+ rte_free(contig_buf);
return ret_status;
}
struct comp_testsuite_params *ts_params = &testsuite_params;
const char *test_buffer;
uint16_t i;
- struct rte_comp_xform compress_xform;
+ int ret;
+ 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_HUFFMAN_FIXED) == 0)
+ return -ENOTSUP;
- memcpy(&compress_xform, &ts_params->def_comp_xform,
+ 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;
+ }
+
+ memcpy(compress_xform, ts_params->def_comp_xform,
sizeof(struct rte_comp_xform));
- compress_xform.compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
+ compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
test_buffer = compress_test_bufs[i];
&i,
&compress_xform,
&ts_params->def_decomp_xform,
+ 1,
RTE_COMP_OP_STATELESS,
- ZLIB_DECOMPRESS) < 0)
- return TEST_FAILED;
+ 0,
+ ZLIB_DECOMPRESS) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
/* Compress with Zlib, decompress with compressdev */
if (test_deflate_comp_decomp(&test_buffer, 1,
&i,
&compress_xform,
&ts_params->def_decomp_xform,
+ 1,
RTE_COMP_OP_STATELESS,
- ZLIB_COMPRESS) < 0)
- return TEST_FAILED;
+ 0,
+ ZLIB_COMPRESS) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
}
- return TEST_SUCCESS;
+ ret = TEST_SUCCESS;
+
+exit:
+ rte_free(compress_xform);
+ return ret;
}
static int
struct comp_testsuite_params *ts_params = &testsuite_params;
const char *test_buffer;
uint16_t i;
- struct rte_comp_xform compress_xform;
+ int ret;
+ struct rte_comp_xform *compress_xform =
+ rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
+
+ 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_HUFFMAN_DYNAMIC) == 0)
+ return -ENOTSUP;
+
+ if (compress_xform == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Compress xform could not be created\n");
+ ret = TEST_FAILED;
+ goto exit;
+ }
- memcpy(&compress_xform, &ts_params->def_comp_xform,
+ memcpy(compress_xform, ts_params->def_comp_xform,
sizeof(struct rte_comp_xform));
- compress_xform.compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC;
+ compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC;
for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
test_buffer = compress_test_bufs[i];
&i,
&compress_xform,
&ts_params->def_decomp_xform,
+ 1,
RTE_COMP_OP_STATELESS,
- ZLIB_DECOMPRESS) < 0)
- return TEST_FAILED;
+ 0,
+ ZLIB_DECOMPRESS) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
/* Compress with Zlib, decompress with compressdev */
if (test_deflate_comp_decomp(&test_buffer, 1,
&i,
&compress_xform,
&ts_params->def_decomp_xform,
+ 1,
RTE_COMP_OP_STATELESS,
- ZLIB_COMPRESS) < 0)
- return TEST_FAILED;
+ 0,
+ ZLIB_COMPRESS) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
}
- return TEST_SUCCESS;
+ ret = TEST_SUCCESS;
+
+exit:
+ rte_free(compress_xform);
+ return ret;
}
static int
buf_idx,
&ts_params->def_comp_xform,
&ts_params->def_decomp_xform,
+ 1,
RTE_COMP_OP_STATELESS,
+ 0,
ZLIB_DECOMPRESS) < 0)
return TEST_FAILED;
buf_idx,
&ts_params->def_comp_xform,
&ts_params->def_decomp_xform,
+ 1,
RTE_COMP_OP_STATELESS,
+ 0,
ZLIB_COMPRESS) < 0)
return TEST_FAILED;
return TEST_SUCCESS;
}
+static int
+test_compressdev_deflate_stateless_multi_level(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ const char *test_buffer;
+ unsigned int level;
+ uint16_t i;
+ int ret;
+ 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;
+ }
+
+ memcpy(compress_xform, ts_params->def_comp_xform,
+ sizeof(struct rte_comp_xform));
+
+ for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
+ test_buffer = compress_test_bufs[i];
+ for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX;
+ level++) {
+ compress_xform->compress.level = level;
+ /* Compress with compressdev, decompress with Zlib */
+ if (test_deflate_comp_decomp(&test_buffer, 1,
+ &i,
+ &compress_xform,
+ &ts_params->def_decomp_xform,
+ 1,
+ RTE_COMP_OP_STATELESS,
+ 0,
+ ZLIB_DECOMPRESS) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+ }
+ }
+
+ ret = TEST_SUCCESS;
+
+exit:
+ rte_free(compress_xform);
+ return ret;
+}
+
+#define NUM_XFORMS 3
+static int
+test_compressdev_deflate_stateless_multi_xform(void)
+{
+ struct comp_testsuite_params *ts_params = &testsuite_params;
+ uint16_t num_bufs = NUM_XFORMS;
+ struct rte_comp_xform *compress_xforms[NUM_XFORMS] = {NULL};
+ struct rte_comp_xform *decompress_xforms[NUM_XFORMS] = {NULL};
+ const char *test_buffers[NUM_XFORMS];
+ uint16_t i;
+ unsigned int level = RTE_COMP_LEVEL_MIN;
+ uint16_t buf_idx[num_bufs];
+
+ int ret;
+
+ /* Create multiple xforms with various levels */
+ for (i = 0; i < NUM_XFORMS; i++) {
+ compress_xforms[i] = rte_malloc(NULL,
+ sizeof(struct rte_comp_xform), 0);
+ if (compress_xforms[i] == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Compress xform could not be created\n");
+ ret = TEST_FAILED;
+ goto exit;
+ }
+
+ memcpy(compress_xforms[i], ts_params->def_comp_xform,
+ sizeof(struct rte_comp_xform));
+ compress_xforms[i]->compress.level = level;
+ level++;
+
+ decompress_xforms[i] = rte_malloc(NULL,
+ sizeof(struct rte_comp_xform), 0);
+ if (decompress_xforms[i] == NULL) {
+ RTE_LOG(ERR, USER1,
+ "Decompress xform could not be created\n");
+ ret = TEST_FAILED;
+ goto exit;
+ }
+
+ memcpy(decompress_xforms[i], ts_params->def_decomp_xform,
+ sizeof(struct rte_comp_xform));
+ }
+
+ for (i = 0; i < NUM_XFORMS; i++) {
+ buf_idx[i] = 0;
+ /* Use the same buffer in all sessions */
+ test_buffers[i] = compress_test_bufs[0];
+ }
+ /* Compress with compressdev, decompress with Zlib */
+ if (test_deflate_comp_decomp(test_buffers, num_bufs,
+ buf_idx,
+ compress_xforms,
+ decompress_xforms,
+ NUM_XFORMS,
+ RTE_COMP_OP_STATELESS,
+ 0,
+ ZLIB_DECOMPRESS) < 0) {
+ ret = TEST_FAILED;
+ goto exit;
+ }
+
+ ret = TEST_SUCCESS;
+exit:
+ for (i = 0; i < NUM_XFORMS; i++) {
+ rte_free(compress_xforms[i]);
+ rte_free(decompress_xforms[i]);
+ }
+
+ return ret;
+}
+
+static int
+test_compressdev_deflate_stateless_sgl(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) == 0)
+ return -ENOTSUP;
+
+ 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) < 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) < 0)
+ return TEST_FAILED;
+ }
+
+ return TEST_SUCCESS;
+}
+
static struct unit_test_suite compressdev_testsuite = {
.suite_name = "compressdev unit test suite",
.setup = testsuite_setup,
.teardown = testsuite_teardown,
.unit_test_cases = {
+ TEST_CASE_ST(NULL, NULL,
+ test_compressdev_invalid_configuration),
TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
test_compressdev_deflate_stateless_fixed),
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_multi_op),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateless_multi_level),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateless_multi_xform),
+ TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+ test_compressdev_deflate_stateless_sgl),
TEST_CASES_END() /**< NULL terminate unit test array */
}
};
git.droids-corp.org / dpdk.git / blobdiff