| /* 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 |
| <markus@oberhumer.com> |
| 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 <zlib.h> |
| # define ALG_ZLIB |
| #endif |
| #if defined(HAVE_BZLIB_H) |
| # include <bzlib.h> |
| # 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" |
| " <markus@oberhumer.com>\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 |
| */ |
| |
