summaryrefslogtreecommitdiffstats
path: root/src/isa-l/igzip/igzip_perf.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:45:59 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:45:59 +0000
commit19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch)
tree42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/isa-l/igzip/igzip_perf.c
parentInitial commit. (diff)
downloadceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.tar.xz
ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.zip
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/isa-l/igzip/igzip_perf.c')
-rw-r--r--src/isa-l/igzip/igzip_perf.c832
1 files changed, 832 insertions, 0 deletions
diff --git a/src/isa-l/igzip/igzip_perf.c b/src/isa-l/igzip/igzip_perf.c
new file mode 100644
index 000000000..da6d3b9eb
--- /dev/null
+++ b/src/isa-l/igzip/igzip_perf.c
@@ -0,0 +1,832 @@
+/**********************************************************************
+ Copyright(c) 2011-2018 Intel Corporation All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+ * Neither the name of Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**********************************************************************/
+
+#define _FILE_OFFSET_BITS 64
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <getopt.h>
+#include "huff_codes.h"
+#include "igzip_lib.h"
+#include "test.h"
+
+#include <zlib.h>
+
+#define BUF_SIZE 1024
+
+#define OPTARGS "hl:f:z:i:d:stub:y:w:o:"
+
+#define COMPRESSION_QUEUE_LIMIT 32
+#define UNSET -1
+
+#define xstr(a) str(a)
+#define str(a) #a
+
+/* Limit output buffer size to 2 Gigabytes. Since stream->avail_out is a
+ * uint32_t and there is no logic for handling an overflowed output buffer in
+ * the perf test, this define must be less then 4 Gigabytes */
+#define MAX_COMPRESS_BUF_SIZE (1U << 31)
+
+int level_size_buf[10] = {
+#ifdef ISAL_DEF_LVL0_DEFAULT
+ ISAL_DEF_LVL0_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL1_DEFAULT
+ ISAL_DEF_LVL1_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL2_DEFAULT
+ ISAL_DEF_LVL2_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL3_DEFAULT
+ ISAL_DEF_LVL3_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL4_DEFAULT
+ ISAL_DEF_LVL4_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL5_DEFAULT
+ ISAL_DEF_LVL5_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL6_DEFAULT
+ ISAL_DEF_LVL6_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL7_DEFAULT
+ ISAL_DEF_LVL7_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL8_DEFAULT
+ ISAL_DEF_LVL8_DEFAULT,
+#else
+ 0,
+#endif
+#ifdef ISAL_DEF_LVL9_DEFAULT
+ ISAL_DEF_LVL9_DEFAULT,
+#else
+ 0,
+#endif
+};
+
+enum {
+ ISAL_STATELESS,
+ ISAL_STATEFUL,
+ ZLIB
+};
+
+struct compress_strategy {
+ int32_t mode;
+ int32_t level;
+};
+
+struct inflate_modes {
+ int32_t stateless;
+ int32_t stateful;
+ int32_t zlib;
+};
+
+struct perf_info {
+ char *file_name;
+ size_t file_size;
+ size_t deflate_size;
+ uint32_t inblock_size;
+ uint32_t flush_type;
+ int32_t hist_bits;
+ int32_t deflate_time;
+ int32_t inflate_time;
+ struct compress_strategy strategy;
+ uint32_t inflate_mode;
+ struct perf start;
+};
+
+void init_perf_info(struct perf_info *info)
+{
+ memset(info, 0, sizeof(*info));
+ info->deflate_time = BENCHMARK_TIME;
+ info->inflate_time = BENCHMARK_TIME;
+}
+
+int usage(void)
+{
+ fprintf(stderr,
+ "Usage: igzip_perf [options] <infile>\n"
+ " -h help, print this message\n"
+ " The options -l, -f, -z may be used up to "
+ xstr(COMPRESSION_QUEUE_LIMIT) " times\n"
+ " -l <level> isa-l stateless deflate level to test ("
+ xstr(ISAL_DEF_MIN_LEVEL) "-" xstr(ISAL_DEF_MAX_LEVEL) ")\n"
+ " -f <level> isa-l stateful deflate level to test ("
+ xstr(ISAL_DEF_MIN_LEVEL) "-" xstr(ISAL_DEF_MAX_LEVEL) ")\n"
+ " -z <level> zlib deflate level to test\n"
+ " -d <time> approx time in seconds for deflate (at least 0)\n"
+ " -i <time> approx time in seconds for inflate (at least 0)\n"
+ " -s performance test isa-l stateful inflate\n"
+ " -t performance test isa-l stateless inflate\n"
+ " -u performance test zlib inflate\n"
+ " -o <file> output file to store compressed data (last one if multiple)\n"
+ " -b <size> input buffer size, applies to stateful options (-f,-z,-s)\n"
+ " -y <type> flush type: 0 (default: no flush), 1 (sync flush), 2 (full flush)\n"
+ " -w <size> log base 2 size of history window, between 9 and 15\n");
+ exit(0);
+}
+
+void print_perf_info_line(struct perf_info *info)
+{
+ printf("igzip_perf-> compress level: %d flush_type: %d block_size: %d\n",
+ info->strategy.level, info->flush_type, info->inblock_size);
+}
+
+void print_file_line(struct perf_info *info)
+{
+ printf(" file info-> name: %s file_size: %lu compress_size: %lu ratio: %2.02f%%\n",
+ info->file_name, info->file_size, info->deflate_size,
+ 100.0 * info->deflate_size / info->file_size);
+}
+
+void print_deflate_perf_line(struct perf_info *info)
+{
+ if (info->strategy.mode == ISAL_STATELESS)
+ printf(" isal_stateless_deflate-> ");
+ else if (info->strategy.mode == ISAL_STATEFUL)
+ printf(" isal_stateful_deflate-> ");
+ else if (info->strategy.mode == ZLIB)
+ printf(" zlib_deflate-> ");
+
+ perf_print(info->start, info->file_size);
+}
+
+void print_inflate_perf_line(struct perf_info *info)
+{
+ if (info->inflate_mode == ISAL_STATELESS)
+ printf(" isal_stateless_inflate-> ");
+ else if (info->inflate_mode == ISAL_STATEFUL)
+ printf(" isal_stateful_inflate-> ");
+ else if (info->inflate_mode == ZLIB)
+ printf(" zlib_inflate-> ");
+
+ perf_print(info->start, info->file_size);
+}
+
+int isal_deflate_round(struct isal_zstream *stream, uint8_t * outbuf, uint32_t outbuf_size,
+ uint8_t * inbuf, uint32_t inbuf_size,
+ uint32_t level, uint8_t * level_buf, uint32_t level_buf_size,
+ int flush_type, int hist_bits)
+{
+ int check;
+
+ /* Setup stream for stateless compression */
+ isal_deflate_init(stream);
+ stream->end_of_stream = 1; /* Do the entire file at once */
+ stream->flush = flush_type;
+ stream->next_in = inbuf;
+ stream->avail_in = inbuf_size;
+ stream->next_out = outbuf;
+ stream->avail_out = outbuf_size;
+ stream->level = level;
+ stream->level_buf = level_buf;
+ stream->level_buf_size = level_buf_size;
+ stream->hist_bits = hist_bits;
+
+ /* Compress stream */
+ check = isal_deflate_stateless(stream);
+
+ /* Verify compression success */
+ if (check || stream->avail_in)
+ return 1;
+
+ return 0;
+}
+
+int isal_inflate_round(struct inflate_state *state, uint8_t * inbuf, uint32_t inbuf_size,
+ uint8_t * outbuf, uint32_t outbuf_size, int hist_bits)
+{
+ int check = 0;
+
+ /* Setup for stateless inflate */
+ state->next_in = inbuf;
+ state->avail_in = inbuf_size;
+ state->next_out = outbuf;
+ state->avail_out = outbuf_size;
+ state->crc_flag = ISAL_DEFLATE;
+ state->hist_bits = hist_bits;
+
+ /* Inflate data */
+ check = isal_inflate_stateless(state);
+
+ /* Verify inflate was successful */
+ if (check)
+ return 1;
+
+ return 0;
+}
+
+int isal_deflate_stateful_round(struct isal_zstream *stream, uint8_t * outbuf,
+ uint32_t outbuf_size, uint8_t * inbuf,
+ uint32_t inbuf_size, uint32_t in_block_size, uint32_t level,
+ uint8_t * level_buf, uint32_t level_buf_size, int flush_type,
+ int hist_bits)
+{
+ uint64_t inbuf_remaining;
+ int check = COMP_OK;
+
+ /* Setup stream for stateful compression */
+ inbuf_remaining = inbuf_size;
+ isal_deflate_init(stream);
+ stream->flush = flush_type;
+ stream->next_in = inbuf;
+ stream->next_out = outbuf;
+ stream->avail_out = outbuf_size;
+ stream->level = level;
+ stream->level_buf = level_buf;
+ stream->level_buf_size = level_buf_size;
+ stream->hist_bits = hist_bits;
+
+ /* Keep compressing so long as more data is available and no error has
+ * been hit */
+ while (COMP_OK == check && inbuf_remaining > in_block_size) {
+ /* Setup next in buffer, assumes out buffer is sufficiently
+ * large */
+ stream->avail_in = in_block_size;
+ inbuf_remaining -= in_block_size;
+
+ /* Compress stream */
+ check = isal_deflate(stream);
+ }
+
+ /* Finish compressing all remaining input */
+ if (COMP_OK == check) {
+ stream->avail_in = inbuf_remaining;
+ stream->end_of_stream = 1;
+ check = isal_deflate(stream);
+ }
+
+ /* Verify Compression Success */
+ if (COMP_OK != check || stream->avail_in > 0)
+ return 1;
+
+ return 0;
+}
+
+int isal_inflate_stateful_round(struct inflate_state *state, uint8_t * inbuf,
+ uint32_t inbuf_size, uint32_t in_block_size, uint8_t * outbuf,
+ uint32_t outbuf_size, int hist_bits)
+{
+ int check = ISAL_DECOMP_OK;
+ uint64_t inbuf_remaining;
+
+ isal_inflate_init(state);
+ state->next_in = inbuf;
+ state->next_out = outbuf;
+ state->avail_out = outbuf_size;
+ state->hist_bits = hist_bits;
+ inbuf_remaining = inbuf_size;
+
+ while (ISAL_DECOMP_OK == check && inbuf_remaining >= in_block_size) {
+ state->avail_in = in_block_size;
+ inbuf_remaining -= in_block_size;
+ check = isal_inflate(state);
+ }
+ if (ISAL_DECOMP_OK == check && inbuf_remaining > 0) {
+ state->avail_in = inbuf_remaining;
+ check = isal_inflate(state);
+ }
+
+ if (ISAL_DECOMP_OK != check || state->avail_in > 0)
+ return 1;
+
+ return 0;
+}
+
+int zlib_deflate_round(z_stream * gstream, uint8_t * outbuf, uInt outbuf_size,
+ uint8_t * inbuf, uLong inbuf_size,
+ uLong in_block_size, int level, int flush_type)
+{
+ uLong inbuf_remaining;
+ int check = Z_OK;
+
+ inbuf_remaining = inbuf_size;
+
+ /* Setup stream for stateful compression */
+ if (0 != deflateReset(gstream))
+ return 1;
+
+ gstream->next_in = inbuf;
+ gstream->next_out = outbuf;
+ gstream->avail_out = outbuf_size;
+
+ /* Keep compressing so long as more data is available and no error has
+ * been hit */
+ while (Z_OK == check && inbuf_remaining > in_block_size) {
+ gstream->avail_in = in_block_size;
+ inbuf_remaining -= in_block_size;
+ check = deflate(gstream, flush_type);
+ }
+
+ /* Finish compressing all remaining input */
+ if (Z_OK == check) {
+ gstream->avail_in = inbuf_remaining;
+ check = deflate(gstream, Z_FINISH);
+ }
+
+ /* Verify Compression Success */
+ if (Z_STREAM_END != check)
+ return 1;
+
+ return 0;
+}
+
+int zlib_inflate_round(z_stream * gstream, uint8_t * inbuf,
+ uLong inbuf_size, uint8_t * outbuf, uInt outbuf_size)
+{
+ int check = 0;
+
+ if (0 != inflateReset(gstream))
+ return 1;
+
+ gstream->next_in = inbuf;
+ gstream->avail_in = inbuf_size;
+ gstream->next_out = outbuf;
+ gstream->avail_out = outbuf_size;
+ check = inflate(gstream, Z_FINISH);
+ if (check != Z_STREAM_END)
+ return 1;
+
+ return 0;
+}
+
+int isal_deflate_perf(uint8_t * outbuf, uint64_t * outbuf_size, uint8_t * inbuf,
+ uint64_t inbuf_size, int level, int flush_type, int hist_bits, int time,
+ struct perf *start)
+{
+ struct isal_zstream stream;
+ uint8_t *level_buf = NULL;
+ int check;
+
+ if (level_size_buf[level] > 0) {
+ level_buf = malloc(level_size_buf[level]);
+ if (level_buf == NULL)
+ return 1;
+ }
+
+ BENCHMARK(start, time, check =
+ isal_deflate_round(&stream, outbuf, *outbuf_size, inbuf,
+ inbuf_size, level, level_buf,
+ level_size_buf[level], flush_type, hist_bits));
+ *outbuf_size = stream.total_out;
+ return check;
+}
+
+int isal_deflate_stateful_perf(uint8_t * outbuf, uint64_t * outbuf_size, uint8_t * inbuf,
+ uint64_t inbuf_size, int level, int flush_type,
+ uint64_t in_block_size, int hist_bits, int time,
+ struct perf *start)
+{
+ struct isal_zstream stream;
+ uint8_t *level_buf = NULL;
+ int check;
+
+ if (in_block_size == 0)
+ in_block_size = inbuf_size;
+
+ if (level_size_buf[level] > 0) {
+ level_buf = malloc(level_size_buf[level]);
+ if (level_buf == NULL)
+ return 1;
+ }
+
+ BENCHMARK(start, time, check =
+ isal_deflate_stateful_round(&stream, outbuf, *outbuf_size, inbuf, inbuf_size,
+ in_block_size, level, level_buf,
+ level_size_buf[level], flush_type, hist_bits));
+ *outbuf_size = stream.total_out;
+ return check;
+
+}
+
+int zlib_deflate_perf(uint8_t * outbuf, uint64_t * outbuf_size, uint8_t * inbuf,
+ uint64_t inbuf_size, int level, int flush_type,
+ uint64_t in_block_size, int hist_bits, int time, struct perf *start)
+{
+ int check;
+ z_stream gstream;
+ int flush_translator[] = { Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FULL_FLUSH };
+
+ if (in_block_size == 0)
+ in_block_size = inbuf_size;
+
+ flush_type = flush_translator[flush_type];
+
+ /* Initialize the gstream buffer */
+ gstream.next_in = inbuf;
+ gstream.avail_in = inbuf_size;
+ gstream.zalloc = Z_NULL;
+ gstream.zfree = Z_NULL;
+ gstream.opaque = Z_NULL;
+
+ if (hist_bits == 0)
+ hist_bits = -15;
+ else
+ hist_bits = -hist_bits;
+
+ if (0 != deflateInit2(&gstream, level, Z_DEFLATED, hist_bits, 9, Z_DEFAULT_STRATEGY))
+ return 1;
+
+ BENCHMARK(start, time, check =
+ zlib_deflate_round(&gstream, outbuf, *outbuf_size, inbuf, inbuf_size,
+ in_block_size, level, flush_type));
+
+ *outbuf_size = gstream.total_out;
+ deflateEnd(&gstream);
+
+ return check;
+}
+
+int isal_inflate_perf(uint8_t * inbuf, uint64_t inbuf_size, uint8_t * outbuf,
+ uint64_t outbuf_size, uint8_t * filebuf, uint64_t file_size,
+ int hist_bits, int time, struct perf *start)
+{
+ struct inflate_state state;
+ int check;
+
+ /* Check that data decompresses */
+ check = isal_inflate_round(&state, inbuf, inbuf_size, outbuf, outbuf_size, hist_bits);
+ if (check || state.total_out != file_size || memcmp(outbuf, filebuf, file_size))
+ return 1;
+
+ BENCHMARK(start, time, isal_inflate_round(&state, inbuf, inbuf_size,
+ outbuf, outbuf_size, hist_bits));
+
+ return check;
+}
+
+int isal_inflate_stateful_perf(uint8_t * inbuf, uint64_t inbuf_size, uint8_t * outbuf,
+ uint64_t outbuf_size, uint8_t * filebuf, uint64_t file_size,
+ uint64_t in_block_size, int hist_bits, int time,
+ struct perf *start)
+{
+ struct inflate_state state;
+ int check;
+
+ if (in_block_size == 0)
+ in_block_size = inbuf_size;
+
+ check = isal_inflate_round(&state, inbuf, inbuf_size, outbuf, outbuf_size, hist_bits);
+ if (check || state.total_out != file_size || memcmp(outbuf, filebuf, file_size))
+ return 1;
+
+ BENCHMARK(start, time,
+ isal_inflate_stateful_round(&state, inbuf, inbuf_size, in_block_size, outbuf,
+ outbuf_size, hist_bits));
+
+ return 0;
+
+}
+
+int zlib_inflate_perf(uint8_t * inbuf, uint64_t inbuf_size, uint8_t * outbuf,
+ uint64_t outbuf_size, uint8_t * filebuf, uint64_t file_size,
+ int hist_bits, int time, struct perf *start)
+{
+ int check;
+ z_stream gstream;
+
+ gstream.next_in = inbuf;
+ gstream.avail_in = inbuf_size;
+ gstream.zalloc = Z_NULL;
+ gstream.zfree = Z_NULL;
+ gstream.opaque = Z_NULL;
+
+ if (hist_bits == 0)
+ hist_bits = -15;
+ else
+ hist_bits = -hist_bits;
+
+ if (0 != inflateInit2(&gstream, hist_bits))
+ return 1;
+
+ check = zlib_inflate_round(&gstream, inbuf, inbuf_size, outbuf, outbuf_size);
+ if (check || gstream.total_out != file_size || memcmp(outbuf, filebuf, file_size))
+ return 1;
+
+ BENCHMARK(start, time,
+ zlib_inflate_round(&gstream, inbuf, inbuf_size, outbuf, outbuf_size));
+
+ inflateEnd(&gstream);
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ FILE *in = NULL;
+ unsigned char *compressbuf, *decompbuf, *filebuf;
+ char *outfile = NULL;
+ int i, c, ret = 0;
+ uint64_t decompbuf_size, compressbuf_size;
+ uint64_t block_count;
+
+ struct compress_strategy compression_queue[COMPRESSION_QUEUE_LIMIT];
+
+ int compression_queue_size = 0;
+ struct compress_strategy compress_strat;
+ struct inflate_modes inflate_strat = { 0 };
+ struct perf_info info;
+ init_perf_info(&info);
+
+ while ((c = getopt(argc, argv, OPTARGS)) != -1) {
+ switch (c) {
+ case 'l':
+ if (compression_queue_size >= COMPRESSION_QUEUE_LIMIT) {
+ printf("Too many levels specified");
+ exit(0);
+ }
+
+ compress_strat.mode = ISAL_STATELESS;
+ compress_strat.level = atoi(optarg);
+ if (compress_strat.level > ISAL_DEF_MAX_LEVEL) {
+ printf("Unsupported isa-l compression level\n");
+ exit(0);
+ }
+
+ compression_queue[compression_queue_size] = compress_strat;
+ compression_queue_size++;
+ break;
+ case 'f':
+ if (compression_queue_size >= COMPRESSION_QUEUE_LIMIT) {
+ printf("Too many levels specified");
+ exit(0);
+ }
+
+ compress_strat.mode = ISAL_STATEFUL;
+ compress_strat.level = atoi(optarg);
+ if (compress_strat.level > ISAL_DEF_MAX_LEVEL) {
+ printf("Unsupported isa-l compression level\n");
+ exit(0);
+ }
+
+ compression_queue[compression_queue_size] = compress_strat;
+ compression_queue_size++;
+ break;
+ case 'z':
+ if (compression_queue_size >= COMPRESSION_QUEUE_LIMIT) {
+ printf("Too many levels specified");
+ exit(0);
+ }
+
+ compress_strat.mode = ZLIB;
+ compress_strat.level = atoi(optarg);
+ if (compress_strat.level > Z_BEST_COMPRESSION) {
+ printf("Unsupported zlib compression level\n");
+ exit(0);
+ }
+ compression_queue[compression_queue_size] = compress_strat;
+ compression_queue_size++;
+ break;
+ case 'i':
+ info.inflate_time = atoi(optarg);
+ if (info.inflate_time < 0)
+ usage();
+ break;
+ case 'd':
+ info.deflate_time = atoi(optarg);
+ if (info.deflate_time < 0)
+ usage();
+ break;
+ case 's':
+ inflate_strat.stateful = 1;
+ break;
+ case 't':
+ inflate_strat.stateless = 1;
+ break;
+ case 'u':
+ inflate_strat.zlib = 1;
+ break;
+ case 'b':
+ inflate_strat.stateful = 1;
+ info.inblock_size = atoi(optarg);
+ break;
+ case 'y':
+ info.flush_type = atoi(optarg);
+ if (info.flush_type != NO_FLUSH && info.flush_type != SYNC_FLUSH
+ && info.flush_type != FULL_FLUSH) {
+ printf("Unsupported flush type\n");
+ exit(0);
+ }
+ break;
+
+ case 'w':
+ info.hist_bits = atoi(optarg);
+ if (info.hist_bits > 15 || info.hist_bits < 9)
+ usage();
+ break;
+ case 'o':
+ outfile = optarg;
+ break;
+ case 'h':
+ default:
+ usage();
+ break;
+ }
+ }
+
+ if (optind >= argc)
+ usage();
+
+ if (!inflate_strat.stateless && !inflate_strat.stateful && !inflate_strat.zlib) {
+ if (info.inblock_size == 0)
+ inflate_strat.stateless = 1;
+ else
+ inflate_strat.stateful = 1;
+ }
+
+ /* Allocate space for entire input file and output
+ * (assuming some possible expansion on output size)
+ */
+ info.file_name = argv[optind];
+ in = fopen(info.file_name, "rb");
+ if (NULL == in) {
+ printf("Error: Can not find file %s\n", info.file_name);
+ exit(0);
+ }
+
+ info.file_size = get_filesize(in);
+ if (info.file_size == 0) {
+ printf("Error: input file has 0 size\n");
+ exit(0);
+ }
+
+ decompbuf_size = info.file_size;
+
+ if (compression_queue_size == 0) {
+ if (info.inblock_size == 0)
+ compression_queue[0].mode = ISAL_STATELESS;
+ else
+ compression_queue[0].mode = ISAL_STATEFUL;
+ compression_queue[0].level = 1;
+ compression_queue_size = 1;
+ }
+
+ filebuf = malloc(info.file_size);
+ if (filebuf == NULL) {
+ fprintf(stderr, "Can't allocate temp buffer memory\n");
+ exit(0);
+ }
+
+ block_count = 1;
+ if (info.flush_type > 0)
+ block_count = (info.file_size + info.inblock_size - 1) / info.inblock_size;
+
+ /* Way overestimate likely compressed size to handle bad type 0 and
+ * small block_size case */
+ compressbuf_size = block_count * ISAL_DEF_MAX_HDR_SIZE + 2 * info.file_size;
+ if (compressbuf_size >= MAX_COMPRESS_BUF_SIZE)
+ compressbuf_size = MAX_COMPRESS_BUF_SIZE;
+
+ compressbuf = malloc(compressbuf_size);
+ if (compressbuf == NULL) {
+ fprintf(stderr, "Can't allocate input buffer memory\n");
+ exit(0);
+ }
+
+ decompbuf = malloc(decompbuf_size);
+ if (decompbuf == NULL) {
+ fprintf(stderr, "Can't allocate output buffer memory\n");
+ exit(0);
+ }
+
+ if (info.file_size != fread(filebuf, 1, info.file_size, in)) {
+ fprintf(stderr, "Could not read in all input\n");
+ exit(0);
+ }
+ fclose(in);
+
+ for (i = 0; i < compression_queue_size; i++) {
+ if (i > 0)
+ printf("\n\n");
+
+ info.strategy = compression_queue[i];
+ print_perf_info_line(&info);
+
+ info.deflate_size = compressbuf_size;
+
+ if (info.strategy.mode == ISAL_STATELESS)
+ ret = isal_deflate_perf(compressbuf, &info.deflate_size, filebuf,
+ info.file_size, compression_queue[i].level,
+ info.flush_type, info.hist_bits,
+ info.deflate_time, &info.start);
+ else if (info.strategy.mode == ISAL_STATEFUL)
+ ret =
+ isal_deflate_stateful_perf(compressbuf, &info.deflate_size,
+ filebuf, info.file_size,
+ compression_queue[i].level,
+ info.flush_type, info.inblock_size,
+ info.hist_bits, info.deflate_time,
+ &info.start);
+ else if (info.strategy.mode == ZLIB)
+ ret = zlib_deflate_perf(compressbuf, &info.deflate_size, filebuf,
+ info.file_size, compression_queue[i].level,
+ info.flush_type, info.inblock_size,
+ info.hist_bits, info.deflate_time,
+ &info.start);
+
+ if (ret) {
+ printf(" Error in compression\n");
+ continue;
+ }
+
+ print_file_line(&info);
+ printf("\n");
+ print_deflate_perf_line(&info);
+ printf("\n");
+
+ if (outfile != NULL && i + 1 == compression_queue_size) {
+ FILE *out;
+ out = fopen(outfile, "wb");
+ fwrite(compressbuf, 1, info.deflate_size, out);
+ fclose(out);
+ }
+
+ if (info.inflate_time == 0)
+ continue;
+
+ if (inflate_strat.stateless) {
+ info.inflate_mode = ISAL_STATELESS;
+ ret = isal_inflate_perf(compressbuf, info.deflate_size, decompbuf,
+ decompbuf_size, filebuf, info.file_size,
+ info.hist_bits, info.inflate_time,
+ &info.start);
+ if (ret)
+ printf(" Error in isal stateless inflate\n");
+ else
+ print_inflate_perf_line(&info);
+ }
+
+ if (inflate_strat.stateful) {
+ info.inflate_mode = ISAL_STATEFUL;
+ ret =
+ isal_inflate_stateful_perf(compressbuf, info.deflate_size,
+ decompbuf, decompbuf_size, filebuf,
+ info.file_size, info.inblock_size,
+ info.hist_bits, info.inflate_time,
+ &info.start);
+
+ if (ret)
+ printf(" Error in isal stateful inflate\n");
+ else
+ print_inflate_perf_line(&info);
+ }
+
+ if (inflate_strat.zlib) {
+ info.inflate_mode = ZLIB;
+ ret = zlib_inflate_perf(compressbuf, info.deflate_size, decompbuf,
+ decompbuf_size, filebuf, info.file_size,
+ info.hist_bits, info.inflate_time,
+ &info.start);
+ if (ret)
+ printf(" Error in zlib inflate\n");
+ else
+ print_inflate_perf_line(&info);
+ }
+ }
+
+ free(compressbuf);
+ free(decompbuf);
+ free(filebuf);
+ return 0;
+}