Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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;
+}