From 3e4d8f433239c40311037616b1b8833a06651ae0 Mon Sep 17 00:00:00 2001 From: Arne Schwabe Date: Mon, 16 Apr 2012 19:21:14 +0200 Subject: Initial import --- lzo/lzotest/lzotest.c | 2091 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2091 insertions(+) create mode 100644 lzo/lzotest/lzotest.c (limited to 'lzo/lzotest/lzotest.c') diff --git a/lzo/lzotest/lzotest.c b/lzo/lzotest/lzotest.c new file mode 100644 index 00000000..13f6e089 --- /dev/null +++ b/lzo/lzotest/lzotest.c @@ -0,0 +1,2091 @@ +/* lzotest.c -- very comprehensive test driver for the LZO library + + This file is part of the LZO real-time data compression library. + + Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer + All Rights Reserved. + + The LZO library is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of + the License, or (at your option) any later version. + + The LZO library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with the LZO library; see the file COPYING. + If not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + Markus F.X.J. Oberhumer + + http://www.oberhumer.com/opensource/lzo/ + */ + + +#include "lzo/lzoconf.h" + + +/************************************************************************* +// util +**************************************************************************/ + +/* portability layer */ +#define WANT_LZO_MALLOC 1 +#define WANT_LZO_FREAD 1 +#define WANT_LZO_WILDARGV 1 +#define WANT_LZO_UCLOCK 1 +#include "examples/portab.h" + +#if defined(HAVE_STRNICMP) && !defined(HAVE_STRNCASECMP) +# define strncasecmp(a,b,c) strnicmp(a,b,c) +# define HAVE_STRNCASECMP 1 +#endif + +#if 0 +# define is_digit(x) (isdigit((unsigned char)(x))) +# define is_space(x) (isspace((unsigned char)(x))) +#else +# define is_digit(x) ((unsigned)(x) - '0' <= 9) +# define is_space(x) ((x)==' ' || (x)=='\t' || (x)=='\r' || (x)=='\n') +#endif + +#include "mygetopt.h" +#include "mygetopt.ch" + + +/************************************************************************* +// compression include section +**************************************************************************/ + +#define HAVE_LZO1_H 1 +#define HAVE_LZO1A_H 1 +#define HAVE_LZO1B_H 1 +#define HAVE_LZO1C_H 1 +#define HAVE_LZO1F_H 1 +#define HAVE_LZO1X_H 1 +#define HAVE_LZO1Y_H 1 +#define HAVE_LZO1Z_H 1 +#define HAVE_LZO2A_H 1 + +#if defined(NO_ZLIB_H) || (SIZEOF_INT < 4) +#undef HAVE_ZLIB_H +#endif +#if defined(NO_BZLIB_H) || (SIZEOF_INT != 4) +#undef HAVE_BZLIB_H +#endif + +#if 0 && defined(LZO_OS_DOS16) +/* don't make this test program too big */ +#undef HAVE_LZO1_H +#undef HAVE_LZO1A_H +#undef HAVE_LZO1C_H +#undef HAVE_LZO1Z_H +#undef HAVE_LZO2A_H +#undef HAVE_LZO2B_H +#undef HAVE_ZLIB_H +#endif + + +/* LZO algorithms */ +#if defined(HAVE_LZO1_H) +# include "lzo/lzo1.h" +#endif +#if defined(HAVE_LZO1A_H) +# include "lzo/lzo1a.h" +#endif +#if defined(HAVE_LZO1B_H) +# include "lzo/lzo1b.h" +#endif +#if defined(HAVE_LZO1C_H) +# include "lzo/lzo1c.h" +#endif +#if defined(HAVE_LZO1F_H) +# include "lzo/lzo1f.h" +#endif +#if defined(HAVE_LZO1X_H) +# include "lzo/lzo1x.h" +#endif +#if defined(HAVE_LZO1Y_H) +# include "lzo/lzo1y.h" +#endif +#if defined(HAVE_LZO1Z_H) +# include "lzo/lzo1z.h" +#endif +#if defined(HAVE_LZO2A_H) +# include "lzo/lzo2a.h" +#endif +#if defined(HAVE_LZO2B_H) +# include "lzo/lzo2b.h" +#endif + +/* other compressors */ +#if defined(__LZO_PROFESSIONAL__) +# include "lzopro/t_config.ch" +#endif +#if defined(HAVE_ZLIB_H) +# include +# define ALG_ZLIB +#endif +#if defined(HAVE_BZLIB_H) +# include +# define ALG_BZIP2 +#endif + + +/************************************************************************* +// enumerate all methods +**************************************************************************/ + +enum { +/* compression algorithms */ + M_LZO1B_1 = 1, + M_LZO1B_2, M_LZO1B_3, M_LZO1B_4, M_LZO1B_5, + M_LZO1B_6, M_LZO1B_7, M_LZO1B_8, M_LZO1B_9, + + M_LZO1C_1 = 11, + M_LZO1C_2, M_LZO1C_3, M_LZO1C_4, M_LZO1C_5, + M_LZO1C_6, M_LZO1C_7, M_LZO1C_8, M_LZO1C_9, + + M_LZO1 = 21, + M_LZO1A = 31, + + M_LZO1B_99 = 901, + M_LZO1B_999 = 902, + M_LZO1C_99 = 911, + M_LZO1C_999 = 912, + M_LZO1_99 = 921, + M_LZO1A_99 = 931, + + M_LZO1F_1 = 61, + M_LZO1F_999 = 962, + M_LZO1X_1 = 71, + M_LZO1X_1_11 = 111, + M_LZO1X_1_12 = 112, + M_LZO1X_1_15 = 115, + M_LZO1X_999 = 972, + M_LZO1Y_1 = 81, + M_LZO1Y_999 = 982, + M_LZO1Z_999 = 992, + + M_LZO2A_999 = 942, + M_LZO2B_999 = 952, + + M_LAST_LZO_COMPRESSOR = 998, + +/* other compressors */ +#if defined(ALG_ZLIB) + M_ZLIB_8_1 = 1101, + M_ZLIB_8_2, M_ZLIB_8_3, M_ZLIB_8_4, M_ZLIB_8_5, + M_ZLIB_8_6, M_ZLIB_8_7, M_ZLIB_8_8, M_ZLIB_8_9, +#endif +#if defined(ALG_BZIP2) + M_BZIP2_1 = 1201, + M_BZIP2_2, M_BZIP2_3, M_BZIP2_4, M_BZIP2_5, + M_BZIP2_6, M_BZIP2_7, M_BZIP2_8, M_BZIP2_9, +#endif + +/* dummy compressor - for benchmarking */ + M_MEMCPY = 999, + + M_LAST_COMPRESSOR = 4999, + +/* dummy algorithms - for benchmarking */ + M_MEMSET = 5001, + +/* checksum algorithms - for benchmarking */ + M_ADLER32 = 6001, + M_CRC32 = 6002, +#if defined(ALG_ZLIB) + M_Z_ADLER32 = 6011, + M_Z_CRC32 = 6012, +#endif + + M_UNUSED +}; + + +/************************************************************************* +// command line options +**************************************************************************/ + +struct corpus_entry_t; + +int opt_verbose = 2; + +long opt_c_loops = 0; +long opt_d_loops = 0; +const struct corpus_entry_t *opt_corpus = NULL; +const char *opt_corpus_path = NULL; +const char *opt_dump_compressed_data = NULL; + +lzo_bool opt_use_safe_decompressor = 0; +lzo_bool opt_use_asm_decompressor = 0; +lzo_bool opt_use_asm_fast_decompressor = 0; +lzo_bool opt_optimize_compressed_data = 0; + +int opt_dict = 0; +lzo_uint opt_max_dict_len = LZO_UINT_MAX; +const char *opt_dictionary_file = NULL; + +lzo_bool opt_read_from_stdin = 0; + +/* set these to 1 to measure the speed impact of a checksum */ +lzo_bool opt_compute_adler32 = 0; +lzo_bool opt_compute_crc32 = 0; +static lzo_uint32 adler_in, adler_out; +static lzo_uint32 crc_in, crc_out; + +lzo_bool opt_execution_time = 0; +int opt_uclock = -1; +lzo_bool opt_clear_wrkmem = 0; + +static const lzo_bool opt_try_to_compress_0_bytes = 1; + + +/************************************************************************* +// misc globals +**************************************************************************/ + +static const char *progname = ""; +static lzo_uclock_handle_t uch; + +/* for statistics and benchmark */ +int opt_totals = 0; +static unsigned long total_n = 0; +static unsigned long total_c_len = 0; +static unsigned long total_d_len = 0; +static unsigned long total_blocks = 0; +static double total_perc = 0.0; +static const char *total_method_name = NULL; +static unsigned total_method_names = 0; +/* Note: the average value of a rate (e.g. compression speed) is defined + * by the Harmonic Mean (and _not_ by the Arithmethic Mean ) */ +static unsigned long total_c_mbs_n = 0; +static unsigned long total_d_mbs_n = 0; +static double total_c_mbs_harmonic = 0.0; +static double total_d_mbs_harmonic = 0.0; +static double total_c_mbs_sum = 0.0; +static double total_d_mbs_sum = 0.0; + + +#if defined(HAVE_LZO1X_H) +int default_method = M_LZO1X_1; +#elif defined(HAVE_LZO1B_H) +int default_method = M_LZO1B_1; +#elif defined(HAVE_LZO1C_H) +int default_method = M_LZO1C_1; +#elif defined(HAVE_LZO1F_H) +int default_method = M_LZO1F_1; +#elif defined(HAVE_LZO1Y_H) +int default_method = M_LZO1Y_1; +#else +int default_method = M_MEMCPY; +#endif + + +static const int benchmark_methods[] = { + M_LZO1B_1, M_LZO1B_9, + M_LZO1C_1, M_LZO1C_9, + M_LZO1F_1, + M_LZO1X_1, + 0 +}; + +static const int x1_methods[] = { + M_LZO1, M_LZO1A, M_LZO1B_1, M_LZO1C_1, M_LZO1F_1, M_LZO1X_1, M_LZO1Y_1, + 0 +}; + +static const int x99_methods[] = { + M_LZO1_99, M_LZO1A_99, M_LZO1B_99, M_LZO1C_99, + 0 +}; + +static const int x999_methods[] = { + M_LZO1B_999, M_LZO1C_999, M_LZO1F_999, M_LZO1X_999, M_LZO1Y_999, + M_LZO1Z_999, + M_LZO2A_999, + 0 +}; + + +/* exit codes of this test program */ +#define EXIT_OK 0 +#define EXIT_USAGE 1 +#define EXIT_FILE 2 +#define EXIT_MEM 3 +#define EXIT_ADLER 4 +#define EXIT_LZO_ERROR 5 +#define EXIT_LZO_INIT 6 +#define EXIT_INTERNAL 7 + + +/************************************************************************* +// memory setup +**************************************************************************/ + +static lzo_uint opt_block_size; +static lzo_uint opt_max_data_len; + +typedef struct { + lzo_bytep ptr; + lzo_uint len; + lzo_uint32 adler; + lzo_uint32 crc; + lzo_bytep alloc_ptr; + lzo_uint alloc_len; + lzo_uint saved_len; +} mblock_t; + +static mblock_t file_data; +static mblock_t block1; +static mblock_t block2; +static mblock_t wrkmem; +static mblock_t dict; + + +static void mb_alloc_extra(mblock_t *mb, lzo_uint len, lzo_uint extra_bottom, lzo_uint extra_top) +{ + mb->alloc_ptr = mb->ptr = NULL; + mb->alloc_len = mb->len = 0; + + mb->alloc_len = extra_bottom + len + extra_top; + if (mb->alloc_len == 0) mb->alloc_len = 1; + mb->alloc_ptr = (lzo_bytep) lzo_malloc(mb->alloc_len); + + if (mb->alloc_ptr == NULL) { + fprintf(stderr, "%s: out of memory (wanted %lu bytes)\n", progname, (unsigned long)mb->alloc_len); + exit(EXIT_MEM); + } + + mb->ptr = mb->alloc_ptr + extra_bottom; + mb->len = mb->saved_len = len; + mb->adler = 1; + mb->crc = 0; +} + + +static void mb_alloc(mblock_t *mb, lzo_uint len) +{ + mb_alloc_extra(mb, len, 0, 0); +} + + +static void mb_free(mblock_t *mb) +{ + if (!mb) return; + if (mb->alloc_ptr) lzo_free(mb->alloc_ptr); + mb->alloc_ptr = mb->ptr = NULL; + mb->alloc_len = mb->len = 0; +} + + +static lzo_uint get_max_compression_expansion(int m, lzo_uint bl) +{ + if (m == M_MEMCPY || m >= M_LAST_COMPRESSOR) + return 0; + if (m == M_LZO2A_999 || m == M_LZO2B_999) + return bl / 8 + 256; + if (m > 0 && m < M_LAST_LZO_COMPRESSOR) + return bl / 16 + 64 + 3; + return bl / 8 + 256; +} + +static lzo_uint get_max_decompression_overrun(int m, lzo_uint bl) +{ + LZO_UNUSED(m); + LZO_UNUSED(bl); + /* may overwrite 3 bytes past the end of the decompressed block */ + if (opt_use_asm_fast_decompressor) + return (lzo_uint) sizeof(lzo_voidp) - 1; + return 0; +} + + +/************************************************************************* +// dictionary support +**************************************************************************/ + +static void dict_alloc(lzo_uint max_dict_len) +{ + lzo_uint l = 0xbfff; /* MAX_DICT_LEN */ + if (max_dict_len > 0 && l > max_dict_len) + l = max_dict_len; + mb_alloc(&dict, l); +} + + +/* this default dictionary does not provide good contexts... */ +static void dict_set_default(void) +{ + lzo_uint d = 0; + unsigned i, j; + + dict.len = 16 * 256; + if (dict.len > dict.alloc_len) + dict.len = dict.alloc_len; + + lzo_memset(dict.ptr, 0, dict.len); + + for (i = 0; i < 256; i++) + for (j = 0; j < 16; j++) { + if (d >= dict.len) + goto done; + dict.ptr[d++] = (unsigned char) i; + } + +done: + dict.adler = lzo_adler32(1, dict.ptr, dict.len); +} + + +static void dict_load(const char *file_name) +{ + FILE *fp; + + dict.len = 0; + fp = fopen(file_name,"rb"); + if (fp) + { + dict.len = (lzo_uint) lzo_fread(fp, dict.ptr, dict.alloc_len); + fclose(fp); + dict.adler = lzo_adler32(1, dict.ptr, dict.len); + } +} + + +/************************************************************************* +// compression database +**************************************************************************/ + +typedef struct +{ + const char * name; + int id; + lzo_uint32 mem_compress; + lzo_uint32 mem_decompress; + lzo_compress_t compress; + lzo_optimize_t optimize; + lzo_decompress_t decompress; + lzo_decompress_t decompress_safe; + lzo_decompress_t decompress_asm; + lzo_decompress_t decompress_asm_safe; + lzo_decompress_t decompress_asm_fast; + lzo_decompress_t decompress_asm_fast_safe; + lzo_compress_dict_t compress_dict; + lzo_decompress_dict_t decompress_dict_safe; +} +compress_t; + +#include "asm.h" + +#include "wrap.h" +#define M_PRIVATE LZO_PRIVATE +#define m_uint lzo_uint +#define m_uint32 lzo_uint32 +#define m_voidp lzo_voidp +#define m_bytep lzo_bytep +#define m_uintp lzo_uintp +#include "wrapmisc.h" + +static const compress_t compress_database[] = { +#include "db.h" +{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } +}; + + +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/db.ch" +#endif + + +/************************************************************************* +// method info +**************************************************************************/ + +static +lzo_decompress_t get_decomp_info ( const compress_t *c, const char **nn ) +{ + lzo_decompress_t d = 0; + const char *n = NULL; + + /* safe has priority over asm/fast */ + if (!d && opt_use_safe_decompressor && opt_use_asm_fast_decompressor) + { + d = c->decompress_asm_fast_safe; + n = " [fs]"; + } + if (!d && opt_use_safe_decompressor && opt_use_asm_decompressor) + { + d = c->decompress_asm_safe; + n = " [as]"; + } + if (!d && opt_use_safe_decompressor) + { + d = c->decompress_safe; + n = " [s]"; + } + if (!d && opt_use_asm_fast_decompressor) + { + d = c->decompress_asm_fast; + n = " [f]"; + } + if (!d && opt_use_asm_decompressor) + { + d = c->decompress_asm; + n = " [a]"; + } + if (!d) + { + d = c->decompress; + n = ""; + } + if (!d) + n = "(null)"; + + if (opt_dict && c->decompress_dict_safe) + n = ""; + + if (nn) + *nn = n; + return d; +} + + +static +const compress_t *find_method_by_id ( int method ) +{ + const compress_t *db; + size_t size = sizeof(compress_database) / sizeof(*(compress_database)); + size_t i; + +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/find_id.ch" +#endif + + db = compress_database; + for (i = 0; i < size && db->name != NULL; i++, db++) + { + if (method == db->id) + return db; + } + return NULL; +} + + +static +const compress_t *find_method_by_name ( const char *name ) +{ + const compress_t *db; + size_t size = sizeof(compress_database) / sizeof(*(compress_database)); + size_t i; + +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/find_name.ch" +#endif + + db = compress_database; + for (i = 0; i < size && db->name != NULL; i++, db++) + { + size_t n = strlen(db->name); + +#if defined(HAVE_STRNCASECMP) + if (strncasecmp(name,db->name,n) == 0 && (!name[n] || name[n] == ',')) + return db; +#else + if (strncmp(name,db->name,n) == 0 && (!name[n] || name[n] == ',')) + return db; +#endif + } + return NULL; +} + + +static +lzo_bool is_compressor ( const compress_t *c ) +{ + return (c->id <= M_LAST_COMPRESSOR || c->id >= 9721); +} + + +/************************************************************************* +// check that memory gets accessed within bounds +**************************************************************************/ + +void memchecker_init ( mblock_t *mb, lzo_xint l, unsigned char random_byte ) +{ + lzo_uint i; + lzo_uint len = (lzo_uint) l; + lzo_bytep p; + + assert(len <= mb->len); + + /* bottom */ + p = mb->ptr; + for (i = 0; i < 16 && p > mb->alloc_ptr; i++) + *--p = random_byte++; + /* top */ + p = mb->ptr + len; + for (i = 0; i < 16 && p < mb->alloc_ptr + mb->alloc_len; i++) + *p++ = random_byte++; +#if 0 || defined(LZO_DEBUG) + /* fill in garbage */ + p = mb->ptr; + random_byte |= 1; + for (i = 0; i < len; i++, random_byte += 2) + *p++ = random_byte; +#endif +} + + +int memchecker_check ( mblock_t *mb, lzo_xint l, unsigned char random_byte ) +{ + lzo_uint i; + lzo_uint len = (lzo_uint) l; + lzo_bytep p; + + assert(len <= mb->len); + + /* bottom */ + p = mb->ptr; + for (i = 0; i < 16 && p > mb->alloc_ptr; i++) + if (*--p != random_byte++) + return -1; + /* top */ + p = mb->ptr + len; + for (i = 0; i < 16 && p < mb->alloc_ptr + mb->alloc_len; i++) + if (*p++ != random_byte++) + return -1; + return 0; +} + + +/************************************************************************* +// compress a block +**************************************************************************/ + +static +int call_compressor ( const compress_t *c, + const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len ) +{ + int r = -100; + + if (c && c->compress && wrkmem.len >= c->mem_compress) + { + unsigned char random_byte = (unsigned char) src_len; + memchecker_init(&wrkmem, c->mem_compress, random_byte); + if (opt_clear_wrkmem) + lzo_memset(wrkmem.ptr, 0, c->mem_compress); + + if (opt_dict && c->compress_dict) + r = c->compress_dict(src,src_len,dst,dst_len,wrkmem.ptr,dict.ptr,dict.len); + else + r = c->compress(src,src_len,dst,dst_len,wrkmem.ptr); + + if (memchecker_check(&wrkmem, c->mem_compress, random_byte) != 0) + printf("WARNING: wrkmem overwrite error (compress) !!!\n"); + } + + if (r == 0 && opt_compute_adler32) + { + lzo_uint32 adler; + adler = lzo_adler32(0, NULL, 0); + adler = lzo_adler32(adler, src, src_len); + adler_in = adler; + } + if (r == 0 && opt_compute_crc32) + { + lzo_uint32 crc; + crc = lzo_crc32(0, NULL, 0); + crc = lzo_crc32(crc, src, src_len); + crc_in = crc; + } + + return r; +} + + +/************************************************************************* +// decompress a block +**************************************************************************/ + +static +int call_decompressor ( const compress_t *c, lzo_decompress_t d, + const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len ) +{ + int r = -100; + + if (c && d && wrkmem.len >= c->mem_decompress) + { + unsigned char random_byte = (unsigned char) src_len; + memchecker_init(&wrkmem, c->mem_decompress, random_byte); + if (opt_clear_wrkmem) + lzo_memset(wrkmem.ptr, 0, c->mem_decompress); + + if (opt_dict && c->decompress_dict_safe) + r = c->decompress_dict_safe(src,src_len,dst,dst_len,wrkmem.ptr,dict.ptr,dict.len); + else + r = d(src,src_len,dst,dst_len,wrkmem.ptr); + + if (memchecker_check(&wrkmem, c->mem_decompress, random_byte) != 0) + printf("WARNING: wrkmem overwrite error (decompress) !!!\n"); + } + + if (r == 0 && opt_compute_adler32) + adler_out = lzo_adler32(1, dst, *dst_len); + if (r == 0 && opt_compute_crc32) + crc_out = lzo_crc32(0, dst, *dst_len); + + return r; +} + + +/************************************************************************* +// optimize a block +**************************************************************************/ + +static +int call_optimizer ( const compress_t *c, + lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len ) +{ + if (c && c->optimize && wrkmem.len >= c->mem_decompress) + return c->optimize(src,src_len,dst,dst_len,wrkmem.ptr); + return 0; +} + + +/*********************************************************************** +// read a file +************************************************************************/ + +static int load_file(const char *file_name, lzo_uint max_len) +{ + FILE *fp; + long ll = -1; + lzo_uint l; + int r; + mblock_t *mb = &file_data; + + mb_free(mb); + + fp = fopen(file_name,"rb"); + if (fp == NULL) + { + fprintf(stderr,"%s: ",file_name); + perror("fopen"); + fflush(stderr); + return EXIT_FILE; + } + r = fseek(fp,(long)max_len,SEEK_SET); + if (r != 0) + r = fseek(fp,0,SEEK_END); + if (r == 0) + { + ll = ftell(fp); + r = fseek(fp,0,SEEK_SET); + } + if (r != 0 || ll < 0) + { + fprintf(stderr,"%s: ",file_name); + perror("fseek"); + fflush(stderr); + return EXIT_FILE; + } + + l = (lzo_uint) ll; + if (max_len > 0 && l > max_len) + l = max_len; + mb_alloc(mb, l); + mb->len = (lzo_uint) lzo_fread(fp, mb->ptr, mb->len); + if (fclose(fp) != 0) + { + mb_free(mb); + fprintf(stderr,"%s: ",file_name); + perror("fclose"); + fflush(stderr); + return EXIT_FILE; + } + + return EXIT_OK; +} + + +/*********************************************************************** +// print some compression statistics +************************************************************************/ + +static double t_div(double a, double b) +{ + return b > 0.00001 ? a / b : 0; +} + +static double set_perc_d(double perc, char *s) +{ + if (perc <= 0) { + strcpy(s, "0.0"); + return 0; + } + if (perc <= 100 - 1.0 / 16) { + sprintf(s, "%4.1f", perc); + } + else { + long p = (long) (perc + 0.5); + if (p < 100) + strcpy(s, "???"); + else if (p >= 9999) + strcpy(s, "9999"); + else + sprintf(s, "%ld", p); + } + return perc; +} + +static double set_perc(unsigned long c_len, unsigned long d_len, char *s) +{ + double perc = 0.0; + if (d_len > 0) + perc = c_len * 100.0 / d_len; + return set_perc_d(perc, s); +} + + +static +void print_stats ( const char *method_name, const char *file_name, + long t_loops, long c_loops, long d_loops, + double t_secs, double c_secs, double d_secs, + unsigned long c_len, unsigned long d_len, + unsigned long blocks ) +{ + unsigned long x_len = d_len; + unsigned long t_bytes, c_bytes, d_bytes; + double c_mbs, d_mbs, t_mbs; + double perc; + char perc_str[4+1]; + + perc = set_perc(c_len, d_len, perc_str); + + c_bytes = x_len * c_loops * t_loops; + d_bytes = x_len * d_loops * t_loops; + t_bytes = c_bytes + d_bytes; + + if (opt_uclock == 0) + c_secs = d_secs = t_secs = 0.0; + + /* speed in uncompressed megabytes per second (1 megabyte = 1.000.000 bytes) */ + c_mbs = (c_secs > 0.001) ? (c_bytes / c_secs) / 1000000.0 : 0; + d_mbs = (d_secs > 0.001) ? (d_bytes / d_secs) / 1000000.0 : 0; + t_mbs = (t_secs > 0.001) ? (t_bytes / t_secs) / 1000000.0 : 0; + + total_n++; + total_c_len += c_len; + total_d_len += d_len; + total_blocks += blocks; + total_perc += perc; + if (c_mbs > 0) { + total_c_mbs_n += 1; + total_c_mbs_harmonic += 1.0 / c_mbs; + total_c_mbs_sum += c_mbs; + } + if (d_mbs > 0) { + total_d_mbs_n += 1; + total_d_mbs_harmonic += 1.0 / d_mbs; + total_d_mbs_sum += d_mbs; + } + + if (opt_verbose >= 2) + { + printf(" compressed into %lu bytes, %s%% (%s%.3f bits/byte)\n", + c_len, perc_str, "", perc * 0.08); + +#if 0 + printf("%-15s %5ld: ","overall", t_loops); + printf("%10lu bytes, %8.2f secs, %8.3f MB/sec\n", + t_bytes, t_secs, t_mbs); +#else + LZO_UNUSED(t_mbs); +#endif + printf("%-15s %5ld: ","compress", c_loops); + printf("%10lu bytes, %8.2f secs, %8.3f MB/sec\n", + c_bytes, c_secs, c_mbs); + printf("%-15s %5ld: ","decompress", d_loops); + printf("%10lu bytes, %8.2f secs, %8.3f MB/sec\n", + d_bytes, d_secs, d_mbs); + printf("\n"); + } + + /* create a line for util/table.pl */ + if (opt_verbose >= 1) + { + /* get basename */ + const char *n, *nn, *b; + for (nn = n = b = file_name; *nn; nn++) + if (*nn == '/' || *nn == '\\' || *nn == ':') + b = nn + 1; + else + n = b; + + printf("%-13s| %-14s %8lu %4lu %9lu %4s %s%8.3f %8.3f |\n", + method_name, n, d_len, blocks, c_len, perc_str, "", c_mbs, d_mbs); + } + + if (opt_verbose >= 2) + printf("\n"); +} + + +static +void print_totals ( void ) +{ + char perc_str[4+1]; + + if ((opt_verbose >= 1 && total_n > 1) || (opt_totals >= 2)) + { + unsigned long n = total_n > 0 ? total_n : 1; + const char *t1 = "-------"; + const char *t2 = total_method_names == 1 ? total_method_name : ""; +#if 1 && defined(__ACCLIB_PCLOCK_CH_INCLUDED) + char uclock_mode[32+1]; + sprintf(uclock_mode, "[clock=%d]", uch.mode); + t1 = uclock_mode; + if (opt_uclock == 0) t1 = t2; +#endif + +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/print_totals.ch" +#endif + +#if 1 + set_perc_d(total_perc / n, perc_str); + printf("%-13s %-12s %10lu %4.1f %9lu %4s %8.3f %8.3f\n", + t1, "***AVG***", + total_d_len / n, total_blocks * 1.0 / n, total_c_len / n, perc_str, + t_div(total_c_mbs_n, total_c_mbs_harmonic), + t_div(total_d_mbs_n, total_d_mbs_harmonic)); +#endif + set_perc(total_c_len, total_d_len, perc_str); + printf("%-13s %-12s %10lu %4lu %9lu %4s %s%8.3f %8.3f\n", + t2, "***TOTALS***", + total_d_len, total_blocks, total_c_len, perc_str, "", + t_div(total_c_mbs_n, total_c_mbs_harmonic), + t_div(total_d_mbs_n, total_d_mbs_harmonic)); + } +} + + +/************************************************************************* +// compress and decompress a file +**************************************************************************/ + +static +int process_file ( const compress_t *c, lzo_decompress_t decompress, + const char *method_name, + const char *file_name, + long t_loops, long c_loops, long d_loops ) +{ + long t_i; + unsigned long blocks = 0; + unsigned long compressed_len = 0; + double t_time = 0, c_time = 0, d_time = 0; + lzo_uclock_t t_start, t_stop, x_start, x_stop; + FILE *fp_dump = NULL; + + if (opt_dump_compressed_data) + fp_dump = fopen(opt_dump_compressed_data,"wb"); + +/* process the file */ + + lzo_uclock_flush_cpu_cache(&uch, 0); + lzo_uclock_read(&uch, &t_start); + for (t_i = 0; t_i < t_loops; t_i++) + { + lzo_uint len, c_len, c_len_max, d_len = 0; + const lzo_bytep d = file_data.ptr; + + len = file_data.len; + c_len = 0; + blocks = 0; + + /* process blocks */ + if (len > 0 || opt_try_to_compress_0_bytes) do + { + lzo_uint bl; + long c_i; + int r; + unsigned char random_byte = (unsigned char) file_data.len; +#if 1 && defined(CLOCKS_PER_SEC) + random_byte ^= (unsigned char) clock(); +#endif + blocks++; + + bl = len > opt_block_size ? opt_block_size : len; + /* update lengths for memchecker_xxx() */ + block1.len = bl + get_max_compression_expansion(c->id, bl); + block2.len = bl + get_max_decompression_overrun(c->id, bl); +#if defined(__LZO_CHECKER) + /* malloc a block of the exact size to detect any overrun */ + assert(block1.alloc_ptr == NULL); + assert(block2.alloc_ptr == NULL); + mb_alloc(&block1, block1.len); + mb_alloc(&block2, block2.len); +#endif + assert(block1.len <= block1.saved_len); + assert(block2.len <= block2.saved_len); + + memchecker_init(&block1, block1.len, random_byte); + memchecker_init(&block2, block2.len, random_byte); + + /* compress the block */ + c_len = c_len_max = 0; + lzo_uclock_flush_cpu_cache(&uch, 0); + lzo_uclock_read(&uch, &x_start); + for (r = 0, c_i = 0; r == 0 && c_i < c_loops; c_i++) + { + c_len = block1.len; + r = call_compressor(c, d, bl, block1.ptr, &c_len); + if (r == 0 && c_len > c_len_max) + c_len_max = c_len; + if (r == 0 && c_len > block1.len) + goto compress_overrun; + } + lzo_uclock_read(&uch, &x_stop); + c_time += lzo_uclock_get_elapsed(&uch, &x_start, &x_stop); + if (r != 0) + { + printf(" compression failed in block %ld (%d) (%lu %lu)\n", + blocks, r, (long)c_len, (long)bl); + return EXIT_LZO_ERROR; + } + if (memchecker_check(&block1, block1.len, random_byte) != 0) + { +compress_overrun: + printf(" compression overwrite error in block %lu " + "(%lu %lu %lu %lu)\n", + blocks, (long)c_len, (long)d_len, (long)bl, (long)block1.len); + return EXIT_LZO_ERROR; + } + + /* optimize the compressed block */ + if (c_len < bl && opt_optimize_compressed_data) + { + d_len = bl; + r = call_optimizer(c, block1.ptr, c_len, block2.ptr, &d_len); + if (r != 0 || d_len != bl) + { + printf(" optimization failed in block %lu (%d) " + "(%lu %lu %lu)\n", blocks, r, + (long)c_len, (long)d_len, (long)bl); + return EXIT_LZO_ERROR; + } + if (memchecker_check(&block1, block1.len, random_byte) != 0 || + memchecker_check(&block2, block2.len, random_byte) != 0) + { + printf(" optimize overwrite error in block %lu " + "(%lu %lu %lu %lu)\n", + blocks, (long)c_len, (long)d_len, (long)bl, (long)block1.len); + return EXIT_LZO_ERROR; + } + } + + /* dump compressed data to disk */ + if (fp_dump) + { + (void) lzo_fwrite(fp_dump, block1.ptr, c_len); + fflush(fp_dump); + } + + /* decompress the block and verify */ + lzo_uclock_flush_cpu_cache(&uch, 0); + lzo_uclock_read(&uch, &x_start); + for (r = 0, c_i = 0; r == 0 && c_i < d_loops; c_i++) + { + d_len = bl; + r = call_decompressor(c, decompress, block1.ptr, c_len, block2.ptr, &d_len); + if (d_len != bl) + break; + } + lzo_uclock_read(&uch, &x_stop); + d_time += lzo_uclock_get_elapsed(&uch, &x_start, &x_stop); + if (r != 0) + { + printf(" decompression failed in block %lu (%d) " + "(%lu %lu %lu)\n", blocks, r, + (long)c_len, (long)d_len, (long)bl); + return EXIT_LZO_ERROR; + } + if (d_len != bl) + { + printf(" decompression size error in block %lu (%lu %lu %lu)\n", + blocks, (long)c_len, (long)d_len, (long)bl); + return EXIT_LZO_ERROR; + } + if (is_compressor(c)) + { + if (lzo_memcmp(d, block2.ptr, bl) != 0) + { + lzo_uint x = 0; + while (x < bl && block2.ptr[x] == d[x]) + x++; + printf(" decompression data error in block %lu at offset " + "%lu (%lu %lu)\n", blocks, (long)x, + (long)c_len, (long)d_len); + if (opt_compute_adler32) + printf(" checksum: 0x%08lx 0x%08lx\n", + (long)adler_in, (long)adler_out); +#if 0 + printf("Orig: "); + r = (x >= 10) ? -10 : 0 - (int) x; + for (j = r; j <= 10 && x + j < bl; j++) + printf(" %02x", (int)d[x+j]); + printf("\nDecomp:"); + for (j = r; j <= 10 && x + j < bl; j++) + printf(" %02x", (int)block2.ptr[x+j]); + printf("\n"); +#endif + return EXIT_LZO_ERROR; + } + if ((opt_compute_adler32 && adler_in != adler_out) || + (opt_compute_crc32 && crc_in != crc_out)) + { + printf(" checksum error in block %lu (%lu %lu)\n", + blocks, (long)c_len, (long)d_len); + printf(" adler32: 0x%08lx 0x%08lx\n", + (long)adler_in, (long)adler_out); + printf(" crc32: 0x%08lx 0x%08lx\n", + (long)crc_in, (long)crc_out); + return EXIT_LZO_ERROR; + } + } + + if (memchecker_check(&block2, block2.len, random_byte) != 0) + { + printf(" decompression overwrite error in block %lu " + "(%lu %lu %lu %lu)\n", + blocks, (long)c_len, (long)d_len, (long)bl, (long)block2.len); + return EXIT_LZO_ERROR; + } + +#if defined(__LZO_CHECKER) + /* free in reverse order of allocations */ + mb_free(&block2); + mb_free(&block1); +#endif + + d += bl; + len -= bl; + compressed_len += (unsigned long) c_len_max; + } + while (len > 0); + } + lzo_uclock_read(&uch, &t_stop); + t_time += lzo_uclock_get_elapsed(&uch, &t_start, &t_stop); + + if (fp_dump) + fclose(fp_dump); + opt_dump_compressed_data = NULL; /* only dump the first file */ + + print_stats(method_name, file_name, + t_loops, c_loops, d_loops, + t_time, c_time, d_time, + compressed_len, (unsigned long) file_data.len, blocks); + if (total_method_name != c->name) { + total_method_name = c->name; + total_method_names += 1; + } + + return EXIT_OK; +} + + + +static +int do_file ( int method, const char *file_name, + long c_loops, long d_loops, + lzo_uint32p p_adler, lzo_uint32p p_crc ) +{ + int r; + const compress_t *c; + lzo_decompress_t decompress; + lzo_uint32 adler, crc; + char method_name[256+1]; + const char *n; + const long t_loops = 1; + + adler_in = adler_out = 0; + crc_in = crc_out = 0; + if (p_adler) + *p_adler = 0; + if (p_crc) + *p_crc = 0; + + c = find_method_by_id(method); + if (c == NULL || c->name == NULL || c->compress == NULL) + return EXIT_INTERNAL; + decompress = get_decomp_info(c,&n); + if (!decompress || n == NULL || wrkmem.len < c->mem_decompress) + return EXIT_INTERNAL; + strcpy(method_name,c->name); + strcat(method_name,n); + + if (c_loops < 1) c_loops = 1; + if (d_loops < 1) d_loops = 1; + + fflush(stdout); fflush(stderr); + + /* read the whole file */ + r = load_file(file_name, opt_max_data_len); + if (r != 0) + return r; + + /* compute some checksums */ + adler = lzo_adler32(0, NULL, 0); + adler = lzo_adler32(adler, file_data.ptr, file_data.len); + if (p_adler) + *p_adler = adler; + crc = lzo_crc32(0, NULL, 0); + crc = lzo_crc32(crc, file_data.ptr, file_data.len); + if (p_crc) + *p_crc = crc; + + if (opt_verbose >= 2) + { + printf("File %s: %lu bytes (0x%08lx, 0x%08lx)\n", + file_name, (long) file_data.len, (long) adler, (long) crc); + printf(" compressing %lu bytes (%ld/%ld/%ld loops, %lu block-size)\n", + (long) file_data.len, t_loops, c_loops, d_loops, (long) opt_block_size); + printf(" %s\n", method_name); + } + + r = process_file(c, decompress, method_name, file_name, + t_loops, c_loops, d_loops); + + return r; +} + + +/************************************************************************* +// Calgary Corpus and Silesia Corpus test suite driver +**************************************************************************/ + +struct corpus_entry_t +{ + const char *name; + long loops; + lzo_uint32 adler; + lzo_uint32 crc; +}; + +static const struct corpus_entry_t calgary_corpus[] = +{ + { "bib", 8, 0x4bd09e98L, 0xb856ebe8L }, + { "book1", 1, 0xd4d3613eL, 0x24e19972L }, + { "book2", 1, 0x6fe14cc3L, 0xba0f3f26L }, + { "geo", 6, 0xf3cc5be0L, 0x4d3a6ed0L }, + { "news", 2, 0x2ed405b8L, 0xcafac853L }, + { "obj1", 35, 0x3887dd2cL, 0xc7b0cd26L }, + { "obj2", 4, 0xf89407c4L, 0x3ae33007L }, + { "paper1", 17, 0xfe65ce62L, 0x2b6baca0L }, + { "paper2", 11, 0x1238b7c2L, 0xf76cba72L }, + { "pic", 4, 0xf61a5702L, 0x4b17e59cL }, + { "progc", 25, 0x4c00ba45L, 0x6fb16094L }, + { "progl", 20, 0x4cba738eL, 0xddbf6baaL }, + { "progp", 28, 0x7495b92bL, 0x493a1809L }, + { "trans", 15, 0x52a2cec8L, 0xcdec06a6L }, + { NULL, 0, 0x00000000L, 0x00000000L } +}; + +static const struct corpus_entry_t silesia_corpus[] = +{ + { "dickens", 1, 0x170f606fL, 0xaf3a6b76L }, + { "mozilla", 1, 0x1188dd4eL, 0x7fb0ab7dL }, + { "mr", 1, 0xaea14b97L, 0xa341883fL }, + { "nci", 1, 0x0af16f1fL, 0x60ff63d3L }, + { "ooffice", 1, 0x83c8f689L, 0xa023e1faL }, + { "osdb", 1, 0xb825b790L, 0xa0ca388cL }, + { "reymont", 1, 0xce5c82caL, 0x50d35f03L }, + { "samba", 1, 0x19dbb9f5L, 0x2beac5f3L }, + { "sao", 1, 0x7edfc4a9L, 0xfda125bfL }, + { "webster", 1, 0xf2962fc6L, 0x01f5a2e9L }, + { "xml", 1, 0xeccd03d6L, 0xff8f3051L }, + { "x-ray", 1, 0xc95435a0L, 0xc86a35c6L }, + { NULL, 0, 0x00000000L, 0x00000000L } +}; + + +static +int do_corpus ( const struct corpus_entry_t *corpus, int method, const char *path, + long c_loops, long d_loops ) +{ + size_t i, n; + char name[256]; + + if (path == NULL || strlen(path) >= sizeof(name) - 12) + return EXIT_USAGE; + + strcpy(name,path); + n = strlen(name); + if (n > 0 && name[n-1] != '/' && name[n-1] != '\\' && name[n-1] != ':') + { + strcat(name,"/"); + n++; + } + + for (i = 0; corpus[i].name != NULL; i++) + { + lzo_uint32 adler, crc; + long c = c_loops * corpus[i].loops; + long d = d_loops * corpus[i].loops; + int r; + + strcpy(name+n,corpus[i].name); + r = do_file(method, name, c, d, &adler, &crc); + if (r != 0) + return r; + if (adler != corpus[i].adler) + { + printf(" invalid test suite\n"); + return EXIT_ADLER; + } + if (corpus[i].crc && crc != corpus[i].crc) + { + printf(" internal checksum error !! (0x%08lx 0x%08lx)\n", + (long) crc, (long) corpus[i].crc); + return EXIT_INTERNAL; + } + } + return EXIT_OK; +} + + +/************************************************************************* +// usage +**************************************************************************/ + +static +void usage ( const char *name, int exit_code, lzo_bool show_methods ) +{ + FILE *f; + int i; + + f = stdout; + + fflush(stdout); fflush(stderr); + + fprintf(f,"Usage: %s [option..] file...\n", name); + fprintf(f,"\n"); + fprintf(f,"Options:\n"); + fprintf(f," -m# compression method\n"); + fprintf(f," -b# set input block size (default %ld, max %ld)\n", + (long) opt_block_size, (long) opt_max_data_len); + fprintf(f," -n# number of compression/decompression runs\n"); + fprintf(f," -c# number of compression runs\n"); + fprintf(f," -d# number of decompression runs\n"); + fprintf(f," -S use safe decompressor (if available)\n"); + fprintf(f," -A use assembler decompressor (if available)\n"); + fprintf(f," -F use fast assembler decompressor (if available)\n"); + fprintf(f," -O optimize compressed data (if available)\n"); + fprintf(f," -s DIR process Calgary Corpus test suite in directory `DIR'\n"); + fprintf(f," -@ read list of files to compress from stdin\n"); + fprintf(f," -q be quiet\n"); + fprintf(f," -Q be very quiet\n"); + fprintf(f," -v be verbose\n"); + fprintf(f," -L display software license\n"); + + if (show_methods) + { +#if defined(__ACCLIB_PCLOCK_CH_INCLUDED) + lzo_uclock_t t_dummy; + lzo_uclock_read(&uch, &t_dummy); + (void) lzo_uclock_get_elapsed(&uch, &t_dummy, &t_dummy); + fprintf(f,"\nAll timings are recorded using uclock mode %d %s.\n", uch.mode, uch.name); +#endif + fprintf(f,"\n\n"); + fprintf(f,"The following compression methods are available:\n"); + fprintf(f,"\n"); + fprintf(f," usage name memory available extras\n"); + fprintf(f," ----- ---- ------ ----------------\n"); + + for (i = 0; i <= M_LAST_COMPRESSOR; i++) + { + const compress_t *c; + c = find_method_by_id(i); + if (c) + { + char n[16]; + static const char * const s[3] = {" ", ", ", ""}; + int j = 0; + unsigned long m = c->mem_compress; + + sprintf(n,"-m%d",i); + fprintf(f," %-6s %-13s",n,c->name); +#if 1 + fprintf(f,"%9ld", m); +#else + m = (m + 1023) / 1024; + fprintf(f,"%6ld kB", m); +#endif + + if (c->decompress_safe) + fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "safe"); + if (c->decompress_asm) + fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "asm"); + if (c->decompress_asm_safe) + fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "asm+safe"); + if (c->decompress_asm_fast) + fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "fastasm"); + if (c->decompress_asm_fast_safe) + fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "fastasm+safe"); + if (c->optimize) + fprintf(f, "%s%s", j++ == 0 ? s[0] : s[1], "optimize"); + if (j > 0) + fprintf(f, s[2]); + fprintf(f,"\n"); + } + } + } + else + { + fprintf(f,"\n"); + fprintf(f,"Type '%s -m' to list all available methods.\n", name); + } + + fflush(f); + if (exit_code < 0) + exit_code = EXIT_USAGE; + exit(exit_code); +} + + +static +void license(void) +{ + FILE *f; + + f = stdout; + + fflush(stdout); fflush(stderr); + +#if defined(__LZO_PROFESSIONAL__) +# include "lzopro/license.ch" +#else +fprintf(f, +" The LZO library is free software; you can redistribute it and/or\n" +" modify it under the terms of the GNU General Public License as\n" +" published by the Free Software Foundation; either version 2 of\n" +" the License, or (at your option) any later version.\n" +"\n" +" The LZO library is distributed in the hope that it will be useful,\n" +" but WITHOUT ANY WARRANTY; without even the implied warranty of\n" +" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" +" GNU General Public License for more details.\n" + ); +fprintf(f, +"\n" +" You should have received a copy of the GNU General Public License\n" +" along with the LZO library; see the file COPYING.\n" +" If not, write to the Free Software Foundation, Inc.,\n" +" 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n" +"\n" +" Markus F.X.J. Oberhumer\n" +" \n" +" http://www.oberhumer.com/opensource/lzo/\n" +"\n" + ); +#endif + + fflush(f); + exit(EXIT_OK); +} + + +/************************************************************************* +// parse method option '-m' +**************************************************************************/ + +static int methods[256+1]; +static int methods_n = 0; + +static void add_method(int m) +{ + int i; + + if (m > 0) + { + if (!find_method_by_id(m)) { + fprintf(stdout,"%s: invalid method %d\n",progname,m); + exit(EXIT_USAGE); + } + + for (i = 0; i < methods_n; i++) + if (methods[i] == m) + return; + + if (methods_n >= 256) + { + fprintf(stderr,"%s: too many methods\n",progname); + exit(EXIT_USAGE); + } + + methods[methods_n++] = m; + methods[methods_n] = 0; + } +} + + +static void add_methods(const int *ml) +{ + while (*ml != 0) + add_method(*ml++); +} + + +static void add_all_methods(int first, int last) +{ + int m; + + for (m = first; m <= last; m++) + if (find_method_by_id(m) != NULL) + add_method(m); +} + + +static int m_strcmp(const char *a, const char *b) +{ + size_t n; + + if (a[0] == 0 || b[0] == 0) + return 1; + n = strlen(b); + if (strncmp(a,b,n) == 0 && (a[n] == 0 || a[n] == ',')) + return 0; + return 1; +} + + +static lzo_bool m_strisdigit(const char *s) +{ + for (;;) + { + if (!is_digit(*s)) + return 0; + s++; + if (*s == 0 || *s == ',') + return 1; + } +} + + +static void parse_methods(const char *p) +{ + const compress_t *c; + + for (;;) + { + if (p == NULL || p[0] == 0) + usage(progname,-1,1); + else if ((c = find_method_by_name(p)) != NULL) + add_method(c->id); + else if (m_strcmp(p,"all") == 0 || m_strcmp(p,"avail") == 0) + add_all_methods(1,M_LAST_COMPRESSOR); + else if (m_strcmp(p,"ALL") == 0) + { + add_all_methods(1,M_LAST_COMPRESSOR); + add_all_methods(9721,9729); + add_all_methods(9781,9789); + } + else if (m_strcmp(p,"lzo") == 0) + add_all_methods(1,M_MEMCPY); + else if (m_strcmp(p,"bench") == 0) + add_methods(benchmark_methods); + else if (m_strcmp(p,"m1") == 0) + add_methods(x1_methods); + else if (m_strcmp(p,"m99") == 0) + add_methods(x99_methods); + else if (m_strcmp(p,"m999") == 0) + add_methods(x999_methods); + else if (m_strcmp(p,"1x999") == 0) + add_all_methods(9721,9729); + else if (m_strcmp(p,"1y999") == 0) + add_all_methods(9821,9829); +#if defined(ALG_ZLIB) + else if (m_strcmp(p,"zlib") == 0) + add_all_methods(M_ZLIB_8_1,M_ZLIB_8_9); +#endif +#if defined(ALG_BZIP2) + else if (m_strcmp(p,"bzip2") == 0) + add_all_methods(M_BZIP2_1,M_BZIP2_9); +#endif +#if defined(__LZO_PROFESSIONAL__) +# include "lzopro/t_opt_m.ch" +#endif + else if (m_strisdigit(p)) + add_method(atoi(p)); + else + { + printf("%s: invalid method '%s'\n\n",progname,p); + exit(EXIT_USAGE); + } + + while (*p && *p != ',') + p++; + while (*p == ',') + p++; + if (*p == 0) + return; + } +} + + +/************************************************************************* +// options +**************************************************************************/ + +enum { + OPT_LONGOPT_ONLY = 512, + OPT_ADLER32, + OPT_CALGARY_CORPUS, + OPT_CLEAR_WRKMEM, + OPT_CRC32, + OPT_DICT, + OPT_DUMP, + OPT_EXECUTION_TIME, + OPT_MAX_DATA_LEN, + OPT_MAX_DICT_LEN, + OPT_SILESIA_CORPUS, + OPT_UCLOCK, +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/o_enum.ch" +#endif + OPT_UNUSED +}; + +static const struct mfx_option longopts[] = +{ + /* { name has_arg *flag val } */ + {"help", 0, 0, 'h'+256}, /* give help */ + {"license", 0, 0, 'L'}, /* display software license */ + {"quiet", 0, 0, 'q'}, /* quiet mode */ + {"verbose", 0, 0, 'v'}, /* verbose mode */ + {"version", 0, 0, 'V'+256}, /* display version number */ + + {"adler32", 0, 0, OPT_ADLER32}, + {"calgary-corpus", 1, 0, OPT_CALGARY_CORPUS}, + {"clear-wrkmem", 0, 0, OPT_CLEAR_WRKMEM}, + {"clock", 1, 0, OPT_UCLOCK}, + {"corpus", 1, 0, OPT_CALGARY_CORPUS}, + {"crc32", 0, 0, OPT_CRC32}, + {"dict", 1, 0, OPT_DICT}, + {"dump-compressed", 1, 0, OPT_DUMP}, + {"execution-time", 0, 0, OPT_EXECUTION_TIME}, + {"max-data-length", 1, 0, OPT_MAX_DATA_LEN}, + {"max-dict-length", 1, 0, OPT_MAX_DICT_LEN}, + {"silesia-corpus", 1, 0, OPT_SILESIA_CORPUS}, + {"uclock", 1, 0, OPT_UCLOCK}, + {"methods", 1, 0, 'm'}, + {"totals", 0, 0, 'T'}, +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/o_longopts.ch" +#endif + + { 0, 0, 0, 0 } +}; + + +static int do_option(int optc) +{ + switch (optc) + { + case 'A': + opt_use_asm_decompressor = 1; + break; + case 'b': + opt_block_size = 0; /* set to opt_max_data_len later */ + if (mfx_optarg) + { + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_block_size = atol(mfx_optarg); + } + break; + case 'c': + case 'C': + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_c_loops = atol(mfx_optarg); + break; + case 'd': + case 'D': + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_d_loops = atol(mfx_optarg); + break; + case 'F': + opt_use_asm_fast_decompressor = 1; + break; + case 'h': + case 'H': + case '?': + case 'h'+256: + usage(progname,EXIT_OK,0); + break; + case 'L': + license(); + break; + case 'm': + parse_methods(mfx_optarg); + break; + case 'n': + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_c_loops = opt_d_loops = atol(mfx_optarg); + break; + case 'O': + opt_optimize_compressed_data = 1; + break; + case 'q': + opt_verbose -= 1; + break; + case 'Q': + opt_verbose = 0; + break; + case 's': + case OPT_CALGARY_CORPUS: + if (!mfx_optarg || !mfx_optarg[0]) + return optc; + opt_corpus_path = mfx_optarg; + opt_corpus = calgary_corpus; + break; + case OPT_SILESIA_CORPUS: + if (!mfx_optarg || !mfx_optarg[0]) + return optc; + opt_corpus_path = mfx_optarg; + opt_corpus = silesia_corpus; + break; + case 'S': + opt_use_safe_decompressor = 1; + break; + case 'T': + opt_totals += 1; + break; + case 'v': + opt_verbose += 1; + break; + case 'V': + case 'V'+256: + exit(EXIT_OK); + break; + case '@': + opt_read_from_stdin = 1; + break; + + case '1': case '2': case '3': case '4': case '5': + case '6': case '7': case '8': case '9': + /* this is a dirty hack... */ + parse_methods(nextchar-1); + if (nextchar[0]) + { + nextchar = NULL; + mfx_optind++; + } + break; + + case OPT_ADLER32: + opt_compute_adler32 = 1; + break; + case OPT_CLEAR_WRKMEM: + opt_clear_wrkmem = 1; + break; + case OPT_CRC32: + opt_compute_crc32 = 1; + break; + case OPT_DICT: + opt_dict = 1; + opt_dictionary_file = mfx_optarg; + break; + case OPT_EXECUTION_TIME: + opt_execution_time = 1; + break; + case OPT_DUMP: + opt_dump_compressed_data = mfx_optarg; + break; + case OPT_MAX_DATA_LEN: + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_max_data_len = atol(mfx_optarg); + break; + case OPT_MAX_DICT_LEN: + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_max_dict_len = atol(mfx_optarg); + break; + case OPT_UCLOCK: + if (!mfx_optarg || !is_digit(mfx_optarg[0])) + return optc; + opt_uclock = atoi(mfx_optarg); +#if defined(__ACCLIB_PCLOCK_CH_INCLUDED) + if (opt_uclock > 0) + uch.mode = opt_uclock; +#endif + break; + +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/o_do_option.ch" +#endif + + case '\0': + return -1; + case ':': + return -2; + default: + fprintf(stderr,"%s: internal error in getopt (%d)\n",progname,optc); + return -3; + } + return 0; +} + + +static int get_options(int argc, char **argv) +{ + int optc; + + mfx_optind = 0; + mfx_opterr = 1; + while ((optc = mfx_getopt_long (argc, argv, + "Ab::c:C:d:D:FhHLm::n:OqQs:STvV@123456789" +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/o_shortopts.ch" +#endif + , longopts, (int *)0)) >= 0) + { + if (do_option(optc) != 0) + exit(EXIT_USAGE); + } + + return mfx_optind; +} + + +/************************************************************************* +// main +**************************************************************************/ + +int __lzo_cdecl_main main(int argc, char *argv[]) +{ + int r = EXIT_OK; + int i, ii; + int m; + time_t t_total; + const char *s; + + lzo_wildargv(&argc, &argv); + lzo_uclock_open(&uch); + + progname = argv[0]; + for (s = progname; *s; s++) + if ((*s == '/' || *s == '\\') && s[1]) + progname = s + 1; + +#if defined(__LZO_PROFESSIONAL__) + printf("\nLZO Professional real-time data compression library (v%s, %s).\n", + lzo_version_string(), lzo_version_date()); + printf("Copyright (C) 1996-2008 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n"); +#elif defined(LZOTEST_USE_DYNLOAD) +# include "dynload/init.ch" +#else + printf("\nLZO real-time data compression library (v%s, %s).\n", + lzo_version_string(), lzo_version_date()); + printf("Copyright (C) 1996-2008 Markus Franz Xaver Johannes Oberhumer\nAll Rights Reserved.\n\n"); +#endif + + +/* + * Step 1: initialize the LZO library + */ + + if (lzo_init() != LZO_E_OK) + { + printf("internal error - lzo_init() failed !!!\n"); + printf("(this usually indicates a compiler bug - try recompiling\nwithout optimizations, and enable `-DLZO_DEBUG' for diagnostics)\n"); + exit(1); + } + + +/* + * Step 2: setup default options + */ + + opt_max_data_len = 64 * 1024L * 1024L; + opt_block_size = 256 * 1024L; + +#if defined(LZO_ARCH_I086) && defined(ACC_MM_AHSHIFT) +# if 1 && defined(LZO_ARCH_I086PM) && defined(BLX286) + opt_max_data_len = 32 * 1024L * 1024L; +# else + opt_max_data_len = 14 * 1024L * 1024L; +# endif + /* reduce memory requirements for ancient 16-bit DOS 640kB real-mode */ + if (ACC_MM_AHSHIFT != 3) { + opt_max_data_len = 16 * 1024L; + } +#elif defined(LZO_OS_TOS) + /* reduce memory requirements for 14 MB machines */ + opt_max_data_len = 8 * 1024L * 1024L; +#endif + + + +/* + * Step 3: parse options + */ + + if (argc < 2) + usage(progname,-1,0); + i = get_options(argc,argv); + + if (methods_n == 0) + add_method(default_method); + if (methods_n > 1 && opt_read_from_stdin) + { + printf("%s: cannot use multiple methods and '-@'\n", progname); + exit(EXIT_USAGE); + } + + if (opt_block_size == 0) + opt_block_size = opt_max_data_len; + if (opt_block_size > opt_max_data_len) + opt_block_size = opt_max_data_len; + + if (opt_c_loops < 1) + opt_c_loops = 1; + if (opt_d_loops < 1) + opt_d_loops = 1; + + +/* + * Step 4: start work + */ + + wrkmem.len = 0; + for (ii = 0; ii < methods_n; ii++) { + const compress_t *c = find_method_by_id(methods[ii]); + assert(c != NULL); + if (c->mem_compress > wrkmem.len) + wrkmem.len = c->mem_compress; + if (c->mem_decompress > wrkmem.len) + wrkmem.len = c->mem_decompress; + } + + mb_alloc(&wrkmem, wrkmem.len); + +#if !defined(__LZO_CHECKER) + mb_alloc_extra(&block1, opt_block_size + get_max_compression_expansion(-1, opt_block_size), 16, 16); + mb_alloc_extra(&block2, opt_block_size + get_max_decompression_overrun(-1, opt_block_size), 16, 16); +#endif + + if (opt_dict) + { + opt_optimize_compressed_data = 0; + dict_alloc(opt_max_dict_len); + if (opt_dictionary_file) + { + dict_load(opt_dictionary_file); + if (dict.len > 0) + printf("Using dictionary '%s', %ld bytes, ID 0x%08lx.\n", + opt_dictionary_file, + (long) dict.len, (long) dict.adler); + } + if (dict.len == 0) + { + dict_set_default(); + printf("Using default dictionary, %ld bytes, ID 0x%08lx.\n", + (long) dict.len, (long) dict.adler); + } + } + + t_total = time(NULL); + ii = i; + for (m = 0; m < methods_n && r == EXIT_OK; m++) + { + int method = methods[m]; + + i = ii; + if (i >= argc && opt_corpus_path == NULL && !opt_read_from_stdin) + usage(progname,-1,0); + if (m == 0 && opt_verbose >= 1) + printf("%lu block-size\n\n", (long) opt_block_size); + + assert(find_method_by_id(method) != NULL); + + if (opt_corpus_path != NULL) + r = do_corpus(opt_corpus, method, opt_corpus_path, + opt_c_loops, opt_d_loops); + else + { + for ( ; i < argc && r == EXIT_OK; i++) + { + r = do_file(method,argv[i],opt_c_loops,opt_d_loops,NULL,NULL); + if (r == EXIT_FILE) /* ignore file errors */ + r = EXIT_OK; + } + if (opt_read_from_stdin) + { + char buf[512], *p; + + while (r == EXIT_OK && fgets(buf,sizeof(buf)-1,stdin) != NULL) + { + buf[sizeof(buf)-1] = 0; + p = buf + strlen(buf); + while (p > buf && is_space(p[-1])) + *--p = 0; + p = buf; + while (*p && is_space(*p)) + p++; + if (*p) + r = do_file(method,p,opt_c_loops,opt_d_loops,NULL,NULL); + if (r == EXIT_FILE) /* ignore file errors */ + r = EXIT_OK; + } + opt_read_from_stdin = 0; + } + } + } + +#if defined(LZOTEST_USE_DYNLOAD) +# include "dynload/exit.ch" +#endif + t_total = time(NULL) - t_total; + + if (opt_totals) + print_totals(); + if (opt_execution_time || (methods_n > 1 && opt_verbose >= 1)) + printf("\n%s: execution time: %lu seconds\n", progname, (long) t_total); + if (r != EXIT_OK) + printf("\n%s: exit code: %d\n", progname, r); + + lzo_uclock_close(&uch); + return r; +} + + +/* +vi:ts=4:et +*/ + -- cgit v1.2.3