From b3b207c4db9378f3eb3518c0778ff03a9b5cdbb3 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 23 Nov 2014 00:46:15 +0100 Subject: [PATCH 01/22] New endian & alignment code --- NEWS | 10 +- lz4.c | 454 +++++++++++++++++++++++++++++-------------------------- lz4.h | 12 +- lz4hc.h | 6 +- xxhash.c | 72 ++++----- 5 files changed, 292 insertions(+), 262 deletions(-) diff --git a/NEWS b/NEWS index 7edee54..763fa5a 100644 --- a/NEWS +++ b/NEWS @@ -1,6 +1,12 @@ +r125: +Changed : endian and alignment code +Fixed : some alignment warnings under clang + r124: -Fix : LZ4F_compressBound() using NULL preferencesPtr -Updated : xxHash, to r37 +New : LZ4 HC streaming mode +Fixed : LZ4F_compressBound() using null preferencesPtr +Updated : xxHash to r38 +Updated library number, to 1.4.0 r123: Added : experimental lz4frame API, thanks to Takayuki Matsuoka and Christopher Jackson for testings diff --git a/lz4.c b/lz4.c index 198b581..579a4fc 100644 --- a/lz4.c +++ b/lz4.c @@ -31,63 +31,37 @@ - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c */ + /************************************** Tuning parameters **************************************/ /* * HEAPMODE : * Select how default compression functions will allocate memory for their hash table, - * in memory stack (0:default, fastest), or in memory heap (1:requires memory allocation (malloc)). + * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()). */ #define HEAPMODE 0 +/* + * CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS : + * You can force the code to use unaligned memory access if you know your CPU can handle it. + */ +/* #define CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS 1 */ + /************************************** CPU Feature Detection **************************************/ -/* 32 or 64 bits ? */ -#if (defined(__x86_64__) || defined(_M_X64) || defined(_WIN64) \ - || defined(__64BIT__) || defined(__mips64) \ - || defined(__powerpc64__) || defined(__powerpc64le__) \ - || defined(__ppc64__) || defined(__ppc64le__) \ - || defined(__PPC64__) || defined(__PPC64LE__) \ - || defined(__ia64) || defined(__itanium__) || defined(_M_IA64) \ - || defined(__s390x__) ) /* Detects 64 bits mode */ -# define LZ4_ARCH64 1 -#else -# define LZ4_ARCH64 0 -#endif -#define LZ4_32BITS (sizeof(void*)==4) -#define LZ4_64BITS (sizeof(void*)==8) - /* - * Little Endian or Big Endian ? - * Overwrite the #define below if you know your architecture endianess + * Unaligned memory access detection */ -#include /* Apparently required to detect endianess */ -#if defined (__GLIBC__) -# include -# if (__BYTE_ORDER == __BIG_ENDIAN) -# define LZ4_BIG_ENDIAN 1 -# endif -#elif (defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN)) && !(defined(__LITTLE_ENDIAN__) || defined(__LITTLE_ENDIAN) || defined(_LITTLE_ENDIAN)) -# define LZ4_BIG_ENDIAN 1 -#elif defined(__sparc) || defined(__sparc__) \ - || defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) \ - || defined(__hpux) || defined(__hppa) \ - || defined(_MIPSEB) || defined(__s390__) -# define LZ4_BIG_ENDIAN 1 +#if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \ + || defined(__ARM_FEATURE_UNALIGNED) \ + || defined(__i386__) || defined(__x86_64__) \ + || defined(_M_IX86) || defined(_M_X64) +# define LZ4_UNALIGNED_ACCESS 1 #else -/* Little Endian assumed. PDP Endian and other very rare endian format are unsupported. */ -#endif - -/* - * Unaligned memory access is automatically enabled for "common" CPU, such as x86. - * For others CPU, such as ARM, the compiler may be more cautious, inserting unnecessary extra code to ensure aligned access property - * If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance - */ -#if defined(__ARM_FEATURE_UNALIGNED) -# define LZ4_FORCE_UNALIGNED_ACCESS 1 +# define LZ4_UNALIGNED_ACCESS 0 #endif /* Define this parameter if your target system or compiler does not support hardware bit count */ @@ -95,18 +69,9 @@ # define LZ4_FORCE_SW_BITCOUNT #endif -/* - * BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE : - * This option may provide a small boost to performance for some big endian cpu, although probably modest. - * You may set this option to 1 if data will remain within closed environment. - * This option is useless on Little_Endian CPU (such as x86) - */ - -/* #define BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE 1 */ - /************************************** - Compiler Options + Compiler Options **************************************/ #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */ /* "restrict" is a known keyword */ @@ -117,13 +82,6 @@ #ifdef _MSC_VER /* Visual Studio */ # define FORCE_INLINE static __forceinline # include /* For Visual 2005 */ -# if LZ4_ARCH64 /* 64-bits */ -# pragma intrinsic(_BitScanForward64) /* For Visual 2005 */ -# pragma intrinsic(_BitScanReverse64) /* For Visual 2005 */ -# else /* 32-bits */ -# pragma intrinsic(_BitScanForward) /* For Visual 2005 */ -# pragma intrinsic(_BitScanReverse) /* For Visual 2005 */ -# endif # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ #else # ifdef __GNUC__ @@ -133,12 +91,6 @@ # endif #endif -#ifdef _MSC_VER /* Visual Studio */ -# define lz4_bswap16(x) _byteswap_ushort(x) -#else -# define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8))) -#endif - #define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #if (GCC_VERSION >= 302) || (__INTEL_COMPILER >= 800) || defined(__clang__) @@ -185,38 +137,168 @@ typedef unsigned long long U64; #endif -#if defined(__GNUC__) && !defined(LZ4_FORCE_UNALIGNED_ACCESS) -# define _PACKED __attribute__ ((packed)) + +/************************************** + Reading and writing into memory +**************************************/ +static unsigned LZ4_64bits(void) { return sizeof(void*)==8; } + +static unsigned LZ4_isLittleEndian(void) +{ + const union { U32 i; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */ + return one.c[0]; +} + +static U16 LZ4_readLE16(const void* memPtr) +{ + if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) + return *(U16*)memPtr; + { + const BYTE* p = memPtr; + return (U16)((U16)p[0] + (p[1]<<8)); + } +} + +static void LZ4_writeLE16(void* memPtr, U16 value) +{ + if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) + { + *(U16*)memPtr = value; + return; + } + { + BYTE* p = memPtr; + p[0] = (BYTE) value; + p[1] = (BYTE)(value>>8); + } +} + +static U32 LZ4_readLE32(const void* memPtr) +{ + if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) + return *(U32*)memPtr; + { + const BYTE* p = memPtr; + U32 result = (U32)((U32)p[0] + (p[1]<<8) + (p[2]<<16) + ((U32)p[3]<<24)); + return result; + } +} + +/* +static void LZ4_writeLE32(void* memPtr, U32 value) +{ + BYTE* p = memPtr; + p[0] = (BYTE) value; + p[1] = (BYTE)(value>>8); + p[2] = (BYTE)(value>>16); + p[3] = (BYTE)(value>>24); +} +*/ + +static void LZ4_copy4(void* dstPtr, const void* srcPtr) +{ + if (LZ4_UNALIGNED_ACCESS) + { + *(U32*)dstPtr = *(U32*)srcPtr; + return; + } + { + BYTE* d = dstPtr; + const BYTE* s = srcPtr; + d[0] = s[0]; + d[1] = s[1]; + d[2] = s[2]; + d[3] = s[3]; + } +} + +static U64 LZ4_readLE64(const void* memPtr) +{ + if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) + return *(U64*)memPtr; + { + const BYTE* p = memPtr; + return (U64)((U64)p[0] + (p[1]<<8) + (p[2]<<16) + ((U64)p[3]<<24) + + (((U64)p[4])<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); + } +} + +/* +static void LZ4_writeLE64(void* memPtr, U64 value) +{ + BYTE* p = memPtr; + p[0] = (BYTE) value; + p[1] = (BYTE)(value>>8); + p[2] = (BYTE)(value>>16); + p[3] = (BYTE)(value>>24); + p[4] = (BYTE)(value>>32); + p[5] = (BYTE)(value>>40); + p[6] = (BYTE)(value>>48); + p[7] = (BYTE)(value>>56); +} +*/ + +static void LZ4_copy8(void* dstPtr, const void* srcPtr) +{ + if (LZ4_UNALIGNED_ACCESS) + { + if (LZ4_64bits()) + *(U64*)dstPtr = *(U64*)srcPtr; + else + ((U32*)dstPtr)[0] = ((U32*)srcPtr)[0], + ((U32*)dstPtr)[1] = ((U32*)srcPtr)[1]; + return; + } + { + BYTE* d = dstPtr; + const BYTE* s = srcPtr; + d[0] = s[0]; + d[1] = s[1]; + d[2] = s[2]; + d[3] = s[3]; + d[4] = s[4]; + d[5] = s[5]; + d[6] = s[6]; + d[7] = s[7]; + } +} + +#define STEPSIZE sizeof(size_t) + +static size_t LZ4_readLE_ARCH(const void* p) +{ + if (LZ4_64bits()) + return (size_t)LZ4_readLE64(p); + else + return (size_t)LZ4_readLE32(p); +} + +/* +static void LZ4_writeLE_ARCH(void* p, size_t value) +{ + if (LZ4_64BITS) + LZ4_writeLE64(p, (U64)value); + else + LZ4_writeLE32(p, (U32)value); +} + +static void LZ4_copyARCH(void* dstPtr, const void* srcPtr) +{ + if (LZ4_64BITS) + LZ4_copy8(dstPtr, srcPtr); + else + LZ4_copy4(dstPtr, srcPtr); +} +*/ + +#if !defined(__GNUC__) +# define LZ4_WILDCOPY(d,s,e) { do { LZ4_copy8(d,s); d+=8; s+=8; } while (d=e; */ #else -# define _PACKED +# define LZ4_WILDCOPY64(d,s,e) { do { LZ4_copy8(d,s); d+=8; s+=8; } while (d=e; */ +# define LZ4_WILDCOPY32(d,s,e) { if (likely(e-d <= 8)) { LZ4_copy8(d,s); d+=8; s+=8; } else do { LZ4_copy8(d,s); d+=8; s+=8; } while (dv) -#define A32(x) (((U32_S *)(x))->v) -#define A64(x) (((U64_S *)(x))->v) -#define AARCH(x) (((size_t_S *)(x))->v) - /************************************** Constants @@ -252,12 +334,12 @@ static const int LZ4_minLength = (MFLIMIT+1); Structures and local types **************************************/ typedef struct { - U32 hashTable[HASH_SIZE_U32]; - U32 currentOffset; - U32 initCheck; + U32 hashTable[HASH_SIZE_U32]; + U32 currentOffset; + U32 initCheck; const BYTE* dictionary; const BYTE* bufferStart; - U32 dictSize; + U32 dictSize; } LZ4_stream_t_internal; typedef enum { notLimited = 0, limitedOutput = 1 } limitedOutput_directive; @@ -271,108 +353,49 @@ typedef enum { full = 0, partial = 1 } earlyEnd_directive; /************************************** - Architecture-specific macros -**************************************/ -#define STEPSIZE sizeof(size_t) -#define LZ4_COPYSTEP(d,s) { AARCH(d) = AARCH(s); d+=STEPSIZE; s+=STEPSIZE; } -#define LZ4_COPY8(d,s) { LZ4_COPYSTEP(d,s); if (STEPSIZE<8) LZ4_COPYSTEP(d,s); } - -#if (defined(LZ4_BIG_ENDIAN) && !defined(BIG_ENDIAN_NATIVE_BUT_INCOMPATIBLE)) -# define LZ4_READ_LITTLEENDIAN_16(d,s,p) { U16 v = A16(p); v = lz4_bswap16(v); d = (s) - v; } -# define LZ4_WRITE_LITTLEENDIAN_16(p,i) { U16 v = (U16)(i); v = lz4_bswap16(v); A16(p) = v; p+=2; } -#else /* Little Endian */ -# define LZ4_READ_LITTLEENDIAN_16(d,s,p) { d = (s) - A16(p); } -# define LZ4_WRITE_LITTLEENDIAN_16(p,v) { A16(p) = v; p+=2; } -#endif - - -/************************************** - Macros + Utils **************************************/ #define LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ -#if LZ4_ARCH64 || !defined(__GNUC__) -# define LZ4_WILDCOPY(d,s,e) { do { LZ4_COPY8(d,s) } while (d=e; */ -#else -# define LZ4_WILDCOPY(d,s,e) { if (likely(e-d <= 8)) LZ4_COPY8(d,s) else do { LZ4_COPY8(d,s) } while (d>3); -# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_clzll(val) >> 3); -# else - int r; - if (!(val>>32)) { r=4; } else { r=0; val>>=32; } - if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } - r += (!val); - return r; -# endif -# else -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r = 0; - _BitScanForward64( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_ctzll(val) >> 3); -# else - static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; - return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; -# endif -# endif -} - -#else - -static int LZ4_NbCommonBytes (register U32 val) -{ -# if defined(LZ4_BIG_ENDIAN) -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r = 0; - _BitScanReverse( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_clz(val) >> 3); -# else - int r; - if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } - r += (!val); - return r; -# endif -# else -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r; - _BitScanForward( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_ctz(val) >> 3); -# else - static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; - return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; -# endif -# endif -} - -#endif +int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; } +int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } /******************************** Compression functions ********************************/ -int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; } -int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } +static int LZ4_NbCommonBytes (register size_t val) +{ + if (LZ4_64bits()) + { +# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r = 0; + _BitScanForward64( &r, (U64)val ); + return (int)(r>>3); +# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (__builtin_ctzll((U64)val) >> 3); +# else + static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; + return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; +# endif + } + /* 32 bits */ + { +# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r; + _BitScanForward( &r, (U32)val ); + return (int)(r>>3); +# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (__builtin_ctz((U32)val) >> 3); +# else + static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; + return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; +# endif + } +} -static int LZ4_hashSequence(U32 sequence, tableType_t tableType) + +static U32 LZ4_hashSequence(U32 sequence, tableType_t tableType) { if (tableType == byU16) return (((sequence) * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1))); @@ -380,15 +403,15 @@ static int LZ4_hashSequence(U32 sequence, tableType_t tableType) return (((sequence) * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG)); } -static int LZ4_hashPosition(const BYTE* p, tableType_t tableType) { return LZ4_hashSequence(A32(p), tableType); } +static U32 LZ4_hashPosition(const BYTE* p, tableType_t tableType) { return LZ4_hashSequence(LZ4_readLE32(p), tableType); } static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase) { switch (tableType) { - case byPtr: { const BYTE** hashTable = (const BYTE**) tableBase; hashTable[h] = p; break; } - case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); break; } - case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); break; } + case byPtr: { const BYTE** hashTable = (const BYTE**) tableBase; hashTable[h] = p; return; } + case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; } + case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; } } } @@ -417,13 +440,13 @@ static unsigned LZ4_count(const BYTE* pIn, const BYTE* pRef, const BYTE* pInLimi while (likely(pIn=lowRefLimit) : 1) && (ref+MAX_DISTANCE>=ip) - && (A32(ref+refDelta)==A32(ip)) ) + && (LZ4_readLE32(ref+refDelta)==LZ4_readLE32(ip)) ) { token=op++; *token=0; goto _next_match; } /* Prepare next loop */ @@ -646,16 +669,16 @@ _last_literals: int LZ4_compress(const char* source, char* dest, int inputSize) { #if (HEAPMODE) - void* ctx = ALLOCATOR(LZ4_STREAMSIZE_U32, 4); /* Aligned on 4-bytes boundaries */ + void* ctx = ALLOCATOR(LZ4_STREAMSIZE_U64, 8); /* Aligned on 8-bytes boundaries */ #else - U32 ctx[LZ4_STREAMSIZE_U32] = {0}; /* Ensure data is aligned on 4-bytes boundaries */ + U64 ctx[LZ4_STREAMSIZE_U64] = {0}; /* Ensure data is aligned on 8-bytes boundaries */ #endif int result; if (inputSize < (int)LZ4_64KLIMIT) result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, 0, notLimited, byU16, noDict, noDictIssue); else - result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, 0, notLimited, LZ4_64BITS ? byU32 : byPtr, noDict, noDictIssue); + result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, 0, notLimited, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue); #if (HEAPMODE) FREEMEM(ctx); @@ -666,16 +689,16 @@ int LZ4_compress(const char* source, char* dest, int inputSize) int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) { #if (HEAPMODE) - void* ctx = ALLOCATOR(LZ4_STREAMSIZE_U32, 4); /* Aligned on 4-bytes boundaries */ + void* ctx = ALLOCATOR(LZ4_STREAMSIZE_U64, 4); /* Aligned on 8-bytes boundaries */ #else - U32 ctx[LZ4_STREAMSIZE_U32] = {0}; /* Ensure data is aligned on 4-bytes boundaries */ + U64 ctx[LZ4_STREAMSIZE_U64] = {0}; /* Ensure data is aligned on 8-bytes boundaries */ #endif int result; if (inputSize < (int)LZ4_64KLIMIT) result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue); else - result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64BITS ? byU32 : byPtr, noDict, noDictIssue); + result = LZ4_compress_generic((void*)ctx, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue); #if (HEAPMODE) FREEMEM(ctx); @@ -700,7 +723,7 @@ void LZ4_resetStream (LZ4_stream_t* LZ4_stream) LZ4_stream_t* LZ4_createStream(void) { - LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(4, LZ4_STREAMSIZE_U32); + LZ4_stream_t* lz4s = (LZ4_stream_t*)ALLOCATOR(8, LZ4_STREAMSIZE_U64); LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal)); /* A compilation error here means LZ4_STREAMSIZE is not large enough */ LZ4_resetStream(lz4s); return lz4s; @@ -959,11 +982,12 @@ FORCE_INLINE int LZ4_decompress_generic( LZ4_WILDCOPY(op, ip, cpy); ip -= (op-cpy); op = cpy; /* get offset */ - LZ4_READ_LITTLEENDIAN_16(match,cpy,ip); ip+=2; + match = cpy - LZ4_readLE16(ip); ip+=2; if ((checkOffset) && (unlikely(match < lowLimit))) goto _output_error; /* Error : offset outside destination buffer */ /* get matchlength */ - if ((length=(token&ML_MASK)) == ML_MASK) + length = token & ML_MASK; + if (length == ML_MASK) { unsigned s; do @@ -1020,9 +1044,9 @@ FORCE_INLINE int LZ4_decompress_generic( op[2] = match[2]; op[3] = match[3]; match += dec32table[op-match]; - A32(op+4) = A32(match); + LZ4_copy4(op+4, match); op += 8; match -= dec64; - } else { LZ4_COPY8(op,match); } + } else { LZ4_copy8(op, match); op+=8; match+=8; } if (unlikely(cpy>oend-12)) { @@ -1079,7 +1103,7 @@ typedef struct */ LZ4_streamDecode_t* LZ4_createStreamDecode(void) { - LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(sizeof(U32), LZ4_STREAMDECODESIZE_U32); + LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOCATOR(sizeof(U64), LZ4_STREAMDECODESIZE_U64); return lz4s; } @@ -1241,7 +1265,7 @@ int LZ4_resetStreamState(void* state, const char* inputBuffer) void* LZ4_create (const char* inputBuffer) { - void* lz4ds = ALLOCATOR(4, LZ4_STREAMSIZE_U32); + void* lz4ds = ALLOCATOR(8, LZ4_STREAMSIZE_U64); LZ4_init ((LZ4_stream_t_internal*)lz4ds, (const BYTE*)inputBuffer); return lz4ds; } @@ -1267,7 +1291,7 @@ int LZ4_compress_withState (void* state, const char* source, char* dest, int inp if (inputSize < (int)LZ4_64KLIMIT) return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, byU16, noDict, noDictIssue); else - return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, LZ4_64BITS ? byU32 : byPtr, noDict, noDictIssue); + return LZ4_compress_generic(state, source, dest, inputSize, 0, notLimited, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue); } int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize) @@ -1278,7 +1302,7 @@ int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* if (inputSize < (int)LZ4_64KLIMIT) return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue); else - return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64BITS ? byU32 : byPtr, noDict, noDictIssue); + return LZ4_compress_generic(state, source, dest, inputSize, maxOutputSize, limitedOutput, LZ4_64bits() ? byU32 : byPtr, noDict, noDictIssue); } /* Obsolete streaming decompression functions */ diff --git a/lz4.h b/lz4.h index 0350f6a..f995b05 100644 --- a/lz4.h +++ b/lz4.h @@ -172,14 +172,14 @@ int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedS Experimental Streaming Compression Functions ***********************************************/ -#define LZ4_STREAMSIZE_U32 ((1 << (LZ4_MEMORY_USAGE-2)) + 8) -#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U32 * sizeof(unsigned int)) +#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4) +#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long)) /* * LZ4_stream_t * information structure to track an LZ4 stream. * important : init this structure content before first use ! */ -typedef struct { unsigned int table[LZ4_STREAMSIZE_U32]; } LZ4_stream_t; +typedef struct { unsigned long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t; /* * LZ4_resetStream @@ -234,14 +234,14 @@ int LZ4_saveDict (LZ4_stream_t* LZ4_streamPtr, char* safeBuffer, int dictSize); Experimental Streaming Decompression Functions ************************************************/ -#define LZ4_STREAMDECODESIZE_U32 8 -#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U32 * sizeof(unsigned int)) +#define LZ4_STREAMDECODESIZE_U64 4 +#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long)) /* * LZ4_streamDecode_t * information structure to track an LZ4 stream. * important : init this structure content using LZ4_setStreamDecode or memset() before first use ! */ -typedef struct { unsigned int table[LZ4_STREAMDECODESIZE_U32]; } LZ4_streamDecode_t; +typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_streamDecode_t; /* * If you prefer dynamic allocation methods, diff --git a/lz4hc.h b/lz4hc.h index 23ad7c1..26ba6d3 100644 --- a/lz4hc.h +++ b/lz4hc.h @@ -105,9 +105,9 @@ They just use the externally allocated memory for state instead of allocating th /************************************** Experimental Streaming Functions **************************************/ -#define LZ4_STREAMHCSIZE_U32 65548 -#define LZ4_STREAMHCSIZE (LZ4_STREAMHCSIZE_U32 * sizeof(unsigned int)) -typedef struct { unsigned int table[LZ4_STREAMHCSIZE_U32]; } LZ4_streamHC_t; +#define LZ4_STREAMHCSIZE_U64 32774 +#define LZ4_STREAMHCSIZE (LZ4_STREAMHCSIZE_U64 * sizeof(unsigned long long)) +typedef struct { unsigned long long table[LZ4_STREAMHCSIZE_U64]; } LZ4_streamHC_t; /* This structure allows static allocation of LZ4 HC streaming state. diff --git a/xxhash.c b/xxhash.c index e6c2f31..24a64b5 100644 --- a/xxhash.c +++ b/xxhash.c @@ -84,11 +84,11 @@ You can contact the author at : // Modify the local functions below should you wish to use some other memory routines // for malloc(), free() #include -FORCE_INLINE void* XXH_malloc(size_t s) { return malloc(s); } -FORCE_INLINE void XXH_free (void* p) { free(p); } +static void* XXH_malloc(size_t s) { return malloc(s); } +static void XXH_free (void* p) { free(p); } // for memcpy() #include -FORCE_INLINE void* XXH_memcpy(void* dest, const void* src, size_t size) +static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); } @@ -221,28 +221,28 @@ static const int one = 1; //**************************** typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; -FORCE_INLINE U32 XXH_readLE32_align(const U32* ptr, XXH_endianess endian, XXH_alignment align) +FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align) { if (align==XXH_unaligned) return endian==XXH_littleEndian ? A32(ptr) : XXH_swap32(A32(ptr)); else - return endian==XXH_littleEndian ? *ptr : XXH_swap32(*ptr); + return endian==XXH_littleEndian ? *(U32*)ptr : XXH_swap32(*(U32*)ptr); } -FORCE_INLINE U32 XXH_readLE32(const U32* ptr, XXH_endianess endian) +FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian) { return XXH_readLE32_align(ptr, endian, XXH_unaligned); } -FORCE_INLINE U64 XXH_readLE64_align(const U64* ptr, XXH_endianess endian, XXH_alignment align) +FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align) { if (align==XXH_unaligned) return endian==XXH_littleEndian ? A64(ptr) : XXH_swap64(A64(ptr)); else - return endian==XXH_littleEndian ? *ptr : XXH_swap64(*ptr); + return endian==XXH_littleEndian ? *(U64*)ptr : XXH_swap64(*(U64*)ptr); } -FORCE_INLINE U64 XXH_readLE64(const U64* ptr, XXH_endianess endian) +FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian) { return XXH_readLE64_align(ptr, endian, XXH_unaligned); } @@ -256,7 +256,7 @@ FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH const BYTE* p = (const BYTE*)input; const BYTE* bEnd = p + len; U32 h32; -#define XXH_get32bits(p) XXH_readLE32_align((const U32*)p, endian, align) +#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align) #ifdef XXH_ACCEPT_NULL_INPUT_POINTER if (p==NULL) @@ -361,7 +361,7 @@ FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH const BYTE* p = (const BYTE*)input; const BYTE* bEnd = p + len; U64 h64; -#define XXH_get64bits(p) XXH_readLE64_align((const U64*)p, endian, align) +#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align) #ifdef XXH_ACCEPT_NULL_INPUT_POINTER if (p==NULL) @@ -509,8 +509,8 @@ typedef struct U32 v2; U32 v3; U32 v4; + U32 mem32[4]; /* defined as U32 for alignment */ U32 memsize; - char memory[16]; } XXH_istate32_t; typedef struct @@ -521,8 +521,8 @@ typedef struct U64 v2; U64 v3; U64 v4; + U64 mem64[4]; /* defined as U64 for alignment */ U32 memsize; - char memory[32]; } XXH_istate64_t; @@ -592,16 +592,16 @@ FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state_in, const v if (state->memsize + len < 16) // fill in tmp buffer { - XXH_memcpy(state->memory + state->memsize, input, len); + XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len); state->memsize += (U32)len; return XXH_OK; } if (state->memsize) // some data left from previous update { - XXH_memcpy(state->memory + state->memsize, input, 16-state->memsize); + XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize); { - const U32* p32 = (const U32*)state->memory; + const U32* p32 = state->mem32; state->v1 += XXH_readLE32(p32, endian) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; @@ -633,19 +633,19 @@ FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state_in, const v do { - v1 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; + v1 += XXH_readLE32(p, endian) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4; - v2 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; + v2 += XXH_readLE32(p, endian) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4; - v3 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; + v3 += XXH_readLE32(p, endian) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4; - v4 += XXH_readLE32((const U32*)p, endian) * PRIME32_2; + v4 += XXH_readLE32(p, endian) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4; @@ -660,7 +660,7 @@ FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state_in, const v if (p < bEnd) { - XXH_memcpy(state->memory, p, bEnd-p); + XXH_memcpy(state->mem32, p, bEnd-p); state->memsize = (int)(bEnd-p); } @@ -682,8 +682,8 @@ XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t l FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state_in, XXH_endianess endian) { XXH_istate32_t* state = (XXH_istate32_t*) state_in; - const BYTE * p = (const BYTE*)state->memory; - BYTE* bEnd = (BYTE*)state->memory + state->memsize; + const BYTE * p = (const BYTE*)state->mem32; + BYTE* bEnd = (BYTE*)(state->mem32) + state->memsize; U32 h32; if (state->total_len >= 16) @@ -699,7 +699,7 @@ FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state_in, XXH_endiane while (p+4<=bEnd) { - h32 += XXH_readLE32((const U32*)p, endian) * PRIME32_3; + h32 += XXH_readLE32(p, endian) * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; p+=4; } @@ -746,16 +746,16 @@ FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state_in, const v if (state->memsize + len < 32) // fill in tmp buffer { - XXH_memcpy(state->memory + state->memsize, input, len); + XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len); state->memsize += (U32)len; return XXH_OK; } if (state->memsize) // some data left from previous update { - XXH_memcpy(state->memory + state->memsize, input, 32-state->memsize); + XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize); { - const U64* p64 = (const U64*)state->memory; + const U64* p64 = state->mem64; state->v1 += XXH_readLE64(p64, endian) * PRIME64_2; state->v1 = XXH_rotl64(state->v1, 31); state->v1 *= PRIME64_1; @@ -787,19 +787,19 @@ FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state_in, const v do { - v1 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; + v1 += XXH_readLE64(p, endian) * PRIME64_2; v1 = XXH_rotl64(v1, 31); v1 *= PRIME64_1; p+=8; - v2 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; + v2 += XXH_readLE64(p, endian) * PRIME64_2; v2 = XXH_rotl64(v2, 31); v2 *= PRIME64_1; p+=8; - v3 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; + v3 += XXH_readLE64(p, endian) * PRIME64_2; v3 = XXH_rotl64(v3, 31); v3 *= PRIME64_1; p+=8; - v4 += XXH_readLE64((const U64*)p, endian) * PRIME64_2; + v4 += XXH_readLE64(p, endian) * PRIME64_2; v4 = XXH_rotl64(v4, 31); v4 *= PRIME64_1; p+=8; @@ -814,7 +814,7 @@ FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state_in, const v if (p < bEnd) { - XXH_memcpy(state->memory, p, bEnd-p); + XXH_memcpy(state->mem64, p, bEnd-p); state->memsize = (int)(bEnd-p); } @@ -836,8 +836,8 @@ XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t l FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state_in, XXH_endianess endian) { XXH_istate64_t * state = (XXH_istate64_t *) state_in; - const BYTE * p = (const BYTE*)state->memory; - BYTE* bEnd = (BYTE*)state->memory + state->memsize; + const BYTE * p = (const BYTE*)state->mem64; + BYTE* bEnd = (BYTE*)state->mem64 + state->memsize; U64 h64; if (state->total_len >= 32) @@ -882,7 +882,7 @@ FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state_in, XXH_endiane while (p+8<=bEnd) { - U64 k1 = XXH_readLE64((const U64*)p, endian); + U64 k1 = XXH_readLE64(p, endian); k1 *= PRIME64_2; k1 = XXH_rotl64(k1,31); k1 *= PRIME64_1; @@ -893,7 +893,7 @@ FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state_in, XXH_endiane if (p+4<=bEnd) { - h64 ^= (U64)(XXH_readLE32((const U32*)p, endian)) * PRIME64_1; + h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1; h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; p+=4; } From 2ad37dbe58eb3709e5dee16ebcf345bd53680f85 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 23 Nov 2014 01:14:04 +0100 Subject: [PATCH 02/22] Corrected lz4io --- lz4.c | 11 +++++++++-- lz4.h | 2 +- programs/lz4cli.c | 2 +- programs/lz4io.c | 2 +- 4 files changed, 12 insertions(+), 5 deletions(-) diff --git a/lz4.c b/lz4.c index 579a4fc..7e454fd 100644 --- a/lz4.c +++ b/lz4.c @@ -44,7 +44,7 @@ /* * CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS : - * You can force the code to use unaligned memory access if you know your CPU can handle it. + * You can force the code to use unaligned memory access if you know your CPU can handle it efficiently. */ /* #define CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS 1 */ @@ -58,7 +58,9 @@ #if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \ || defined(__ARM_FEATURE_UNALIGNED) \ || defined(__i386__) || defined(__x86_64__) \ - || defined(_M_IX86) || defined(_M_X64) + || defined(_M_IX86) || defined(_M_X64) \ + || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \ + || (defined(_M_ARM) && (_M_ARM >= 7)) # define LZ4_UNALIGNED_ACCESS 1 #else # define LZ4_UNALIGNED_ACCESS 0 @@ -153,6 +155,7 @@ static U16 LZ4_readLE16(const void* memPtr) { if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) return *(U16*)memPtr; + else { const BYTE* p = memPtr; return (U16)((U16)p[0] + (p[1]<<8)); @@ -166,6 +169,7 @@ static void LZ4_writeLE16(void* memPtr, U16 value) *(U16*)memPtr = value; return; } + else { BYTE* p = memPtr; p[0] = (BYTE) value; @@ -202,6 +206,7 @@ static void LZ4_copy4(void* dstPtr, const void* srcPtr) *(U32*)dstPtr = *(U32*)srcPtr; return; } + else { BYTE* d = dstPtr; const BYTE* s = srcPtr; @@ -216,6 +221,7 @@ static U64 LZ4_readLE64(const void* memPtr) { if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) return *(U64*)memPtr; + else { const BYTE* p = memPtr; return (U64)((U64)p[0] + (p[1]<<8) + (p[2]<<16) + ((U64)p[3]<<24) + @@ -249,6 +255,7 @@ static void LZ4_copy8(void* dstPtr, const void* srcPtr) ((U32*)dstPtr)[1] = ((U32*)srcPtr)[1]; return; } + else { BYTE* d = dstPtr; const BYTE* s = srcPtr; diff --git a/lz4.h b/lz4.h index f995b05..c9ed49f 100644 --- a/lz4.h +++ b/lz4.h @@ -48,7 +48,7 @@ extern "C" { **************************************/ #define LZ4_VERSION_MAJOR 1 /* for major interface/format changes */ #define LZ4_VERSION_MINOR 4 /* for minor interface/format changes */ -#define LZ4_VERSION_RELEASE 0 /* for tweaks, bug-fixes, or development */ +#define LZ4_VERSION_RELEASE 1 /* for tweaks, bug-fixes, or development */ #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE) int LZ4_versionNumber (void); diff --git a/programs/lz4cli.c b/programs/lz4cli.c index 2d612e7..9a6e5bc 100644 --- a/programs/lz4cli.c +++ b/programs/lz4cli.c @@ -113,7 +113,7 @@ //**************************** #define COMPRESSOR_NAME "LZ4 Compression CLI" #ifndef LZ4_VERSION -# define LZ4_VERSION "r122" +# define LZ4_VERSION "r125" #endif #define AUTHOR "Yann Collet" #define WELCOME_MESSAGE "*** %s %i-bits %s, by %s (%s) ***\n", COMPRESSOR_NAME, (int)(sizeof(void*)*8), LZ4_VERSION, AUTHOR, __DATE__ diff --git a/programs/lz4io.c b/programs/lz4io.c index 3a84866..afaa59f 100644 --- a/programs/lz4io.c +++ b/programs/lz4io.c @@ -357,7 +357,7 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i static void* LZ4IO_LZ4_createStream (const char* inputBuffer) { (void)inputBuffer; - return calloc(4, LZ4_STREAMSIZE_U32); + return calloc(8, LZ4_STREAMSIZE_U64); } static int LZ4IO_LZ4_compress_limitedOutput_continue (void* ctx, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel) From 86fa21b3019d7e9983704661966a64f5aa1456bf Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 23 Nov 2014 18:36:04 +0100 Subject: [PATCH 03/22] Added : $(EXT) within install for cross-compilation support --- Makefile | 9 +-------- lz4.c | 5 ++++- programs/Makefile | 14 +++++++------- 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/Makefile b/Makefile index 586ac5e..c2bbd57 100644 --- a/Makefile +++ b/Makefile @@ -31,7 +31,7 @@ # ################################################################ # Version numbers -VERSION=124 +VERSION=125 export RELEASE=r$(VERSION) LIBVER_MAJOR=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` LIBVER_MINOR=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` @@ -50,13 +50,6 @@ PRGDIR = programs DISTRIBNAME=lz4-$(RELEASE).tar.gz -# Define *.exe as extension for Windows systems -ifneq (,$(filter Windows%,$(OS))) -EXT =.exe -else -EXT = -endif - # OS X linker doesn't support -soname, and use different extension # see : https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html ifeq ($(shell uname), Darwin) diff --git a/lz4.c b/lz4.c index 7e454fd..8e81cc2 100644 --- a/lz4.c +++ b/lz4.c @@ -44,7 +44,10 @@ /* * CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS : - * You can force the code to use unaligned memory access if you know your CPU can handle it efficiently. + * You can force the code to use unaligned memory access, should you know your CPU can handle it efficiently. + * If it effectively results in better speed (up to 50% improvement can be expected) + * please report your configuration to upstream (https://groups.google.com/forum/#!forum/lz4c) + * so that an automatic detection macro can be added to mainline. */ /* #define CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS 1 */ diff --git a/programs/Makefile b/programs/Makefile index 1d7e17f..fcfb32c 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -30,7 +30,7 @@ # fullbench32: Same as fullbench, but forced to compile in 32-bits mode # ########################################################################## -RELEASE=r124 +RELEASE=r125 DESTDIR?= PREFIX ?= /usr @@ -113,9 +113,9 @@ ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU)) install: lz4 lz4c @echo Installing binaries @install -d -m 755 $(DESTDIR)$(BINDIR)/ $(DESTDIR)$(MANDIR)/ - @install -m 755 lz4 $(DESTDIR)$(BINDIR)/lz4 - @ln -sf lz4 $(DESTDIR)$(BINDIR)/lz4cat - @install -m 755 lz4c $(DESTDIR)$(BINDIR)/lz4c + @install -m 755 lz4$(EXT) $(DESTDIR)$(BINDIR)/lz4$(EXT) + @ln -sf lz4$(EXT) $(DESTDIR)$(BINDIR)/lz4cat + @install -m 755 lz4c$(EXT) $(DESTDIR)$(BINDIR)/lz4c$(EXT) @echo Installing man pages @install -m 644 lz4.1 $(DESTDIR)$(MANDIR)/lz4.1 @install -m 644 lz4c.1 $(DESTDIR)$(MANDIR)/lz4c.1 @@ -124,12 +124,12 @@ install: lz4 lz4c uninstall: rm -f $(DESTDIR)$(BINDIR)/lz4cat - [ -x $(DESTDIR)$(BINDIR)/lz4 ] && rm -f $(DESTDIR)$(BINDIR)/lz4 - [ -x $(DESTDIR)$(BINDIR)/lz4c ] && rm -f $(DESTDIR)$(BINDIR)/lz4c + [ -x $(DESTDIR)$(BINDIR)/lz4$(EXT) ] && rm -f $(DESTDIR)$(BINDIR)/lz4$(EXT) + [ -x $(DESTDIR)$(BINDIR)/lz4c$(EXT) ] && rm -f $(DESTDIR)$(BINDIR)/lz4c$(EXT) [ -f $(DESTDIR)$(MANDIR)/lz4.1 ] && rm -f $(DESTDIR)$(MANDIR)/lz4.1 [ -f $(DESTDIR)$(MANDIR)/lz4c.1 ] && rm -f $(DESTDIR)$(MANDIR)/lz4c.1 [ -f $(DESTDIR)$(MANDIR)/lz4cat.1 ] && rm -f $(DESTDIR)$(MANDIR)/lz4cat.1 - @echo lz4 successfully uninstalled + @echo lz4 programs successfully uninstalled test: test-lz4 test-lz4c test-frametest test-fullbench test-fuzzer test-mem From 2d98faf238516ecd6588f9202f8ae546c0b798e4 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Thu, 27 Nov 2014 22:44:36 +0100 Subject: [PATCH 04/22] Improved decoding speed --- lz4.c | 187 +++++++++++++++++++------------------------ lz4.h | 4 +- programs/fullbench.c | 20 ++++- 3 files changed, 101 insertions(+), 110 deletions(-) diff --git a/lz4.c b/lz4.c index 8e81cc2..b3f1b2d 100644 --- a/lz4.c +++ b/lz4.c @@ -56,7 +56,9 @@ CPU Feature Detection **************************************/ /* - * Unaligned memory access detection + * Automated efficient unaligned memory access detection + * Based on known hardware architectures + * This list will be updated thanks to Open Source community feedbacks */ #if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \ || defined(__ARM_FEATURE_UNALIGNED) \ @@ -146,6 +148,8 @@ /************************************** Reading and writing into memory **************************************/ +#define STEPSIZE sizeof(size_t) + static unsigned LZ4_64bits(void) { return sizeof(void*)==8; } static unsigned LZ4_isLittleEndian(void) @@ -180,6 +184,36 @@ static void LZ4_writeLE16(void* memPtr, U16 value) } } + +static U32 LZ4_read16(const void* memPtr) +{ + if (LZ4_UNALIGNED_ACCESS) + { + return *(U16*)memPtr; + } + else + { + U16 val16; + memcpy(&val16, memPtr, 2); + return val16; + } +} + +static U32 LZ4_read32(const void* memPtr) +{ + if (LZ4_UNALIGNED_ACCESS) + { + return *(U32*)memPtr; + } + else + { + U32 val32; + memcpy(&val32, memPtr, 4); + return val32; + } +} + + static U32 LZ4_readLE32(const void* memPtr) { if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) @@ -191,35 +225,6 @@ static U32 LZ4_readLE32(const void* memPtr) } } -/* -static void LZ4_writeLE32(void* memPtr, U32 value) -{ - BYTE* p = memPtr; - p[0] = (BYTE) value; - p[1] = (BYTE)(value>>8); - p[2] = (BYTE)(value>>16); - p[3] = (BYTE)(value>>24); -} -*/ - -static void LZ4_copy4(void* dstPtr, const void* srcPtr) -{ - if (LZ4_UNALIGNED_ACCESS) - { - *(U32*)dstPtr = *(U32*)srcPtr; - return; - } - else - { - BYTE* d = dstPtr; - const BYTE* s = srcPtr; - d[0] = s[0]; - d[1] = s[1]; - d[2] = s[2]; - d[3] = s[3]; - } -} - static U64 LZ4_readLE64(const void* memPtr) { if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) @@ -232,20 +237,24 @@ static U64 LZ4_readLE64(const void* memPtr) } } -/* -static void LZ4_writeLE64(void* memPtr, U64 value) +static size_t LZ4_readLE_ARCH(const void* p) { - BYTE* p = memPtr; - p[0] = (BYTE) value; - p[1] = (BYTE)(value>>8); - p[2] = (BYTE)(value>>16); - p[3] = (BYTE)(value>>24); - p[4] = (BYTE)(value>>32); - p[5] = (BYTE)(value>>40); - p[6] = (BYTE)(value>>48); - p[7] = (BYTE)(value>>56); + if (LZ4_64bits()) + return (size_t)LZ4_readLE64(p); + else + return (size_t)LZ4_readLE32(p); +} + + +static void LZ4_copy4(void* dstPtr, const void* srcPtr) +{ + if (LZ4_UNALIGNED_ACCESS) + { + *(U32*)dstPtr = *(U32*)srcPtr; + return; + } + memcpy(dstPtr, srcPtr, 4); } -*/ static void LZ4_copy8(void* dstPtr, const void* srcPtr) { @@ -258,57 +267,18 @@ static void LZ4_copy8(void* dstPtr, const void* srcPtr) ((U32*)dstPtr)[1] = ((U32*)srcPtr)[1]; return; } - else - { - BYTE* d = dstPtr; - const BYTE* s = srcPtr; - d[0] = s[0]; - d[1] = s[1]; - d[2] = s[2]; - d[3] = s[3]; - d[4] = s[4]; - d[5] = s[5]; - d[6] = s[6]; - d[7] = s[7]; - } + memcpy(dstPtr, srcPtr, 8); } -#define STEPSIZE sizeof(size_t) - -static size_t LZ4_readLE_ARCH(const void* p) +/* customized version of memcpy, which may overwrite up to 7 bytes beyond dstEnd */ +static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd) { - if (LZ4_64bits()) - return (size_t)LZ4_readLE64(p); - else - return (size_t)LZ4_readLE32(p); + BYTE* d = dstPtr; + const BYTE* s = srcPtr; + BYTE* e = dstEnd; + do { LZ4_copy8(d,s); d+=8; s+=8; } while (d=e; */ -#else -# define LZ4_WILDCOPY64(d,s,e) { do { LZ4_copy8(d,s); d+=8; s+=8; } while (d=e; */ -# define LZ4_WILDCOPY32(d,s,e) { if (likely(e-d <= 8)) { LZ4_copy8(d,s); d+=8; s+=8; } else do { LZ4_copy8(d,s); d+=8; s+=8; } while (d> ((MINMATCH*8)-LZ4_HASHLOG)); } -static U32 LZ4_hashPosition(const BYTE* p, tableType_t tableType) { return LZ4_hashSequence(LZ4_readLE32(p), tableType); } +static U32 LZ4_hashPosition(const BYTE* p, tableType_t tableType) { return LZ4_hashSequence(LZ4_read32(p), tableType); } static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableType_t tableType, const BYTE* srcBase) { @@ -444,20 +414,20 @@ static const BYTE* LZ4_getPosition(const BYTE* p, void* tableBase, tableType_t t return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase); } -static unsigned LZ4_count(const BYTE* pIn, const BYTE* pRef, const BYTE* pInLimit) +static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) { const BYTE* const pStart = pIn; while (likely(pIn=lowRefLimit) : 1) && (ref+MAX_DISTANCE>=ip) - && (LZ4_readLE32(ref+refDelta)==LZ4_readLE32(ip)) ) + && (LZ4_read32(ref+refDelta)==LZ4_read32(ip)) ) { token=op++; *token=0; goto _next_match; } /* Prepare next loop */ @@ -699,7 +669,7 @@ int LZ4_compress(const char* source, char* dest, int inputSize) int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize) { #if (HEAPMODE) - void* ctx = ALLOCATOR(LZ4_STREAMSIZE_U64, 4); /* Aligned on 8-bytes boundaries */ + void* ctx = ALLOCATOR(LZ4_STREAMSIZE_U64, 8); /* Aligned on 8-bytes boundaries */ #else U64 ctx[LZ4_STREAMSIZE_U64] = {0}; /* Ensure data is aligned on 8-bytes boundaries */ #endif @@ -989,7 +959,9 @@ FORCE_INLINE int LZ4_decompress_generic( op += length; break; /* Necessarily EOF, due to parsing restrictions */ } - LZ4_WILDCOPY(op, ip, cpy); ip -= (op-cpy); op = cpy; + LZ4_wildCopy(op, ip, cpy); + ip += length; op = cpy; + //LZ4_WILDCOPY(op, ip, cpy); ip -= (op-cpy); op = cpy; /* get offset */ match = cpy - LZ4_readLE16(ip); ip+=2; @@ -1060,11 +1032,14 @@ FORCE_INLINE int LZ4_decompress_generic( if (unlikely(cpy>oend-12)) { - if (cpy > oend-LASTLITERALS) goto _output_error; /* Error : last 5 bytes must be literals */ - if (op oend-LASTLITERALS) goto _output_error; /* Error : last LASTLITERALS bytes must be literals */ + if (op < oend-8) LZ4_wildCopy(op, match, oend-8); + match += oend-8 - op; + op = oend-8; + while (op chunkSize) { chunkP[i].origSize = chunkSize; remaining -= chunkSize; } else { chunkP[i].origSize = (int)remaining; remaining = 0; } + chunkP[i].compressedBuffer = out; out += maxCompressedChunkSize; + chunkP[i].compressedSize = 0; + } + } for (chunkNb=0; chunkNb Date: Fri, 28 Nov 2014 02:48:21 +0100 Subject: [PATCH 05/22] Fixed decompression bug --- lz4.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/lz4.c b/lz4.c index b3f1b2d..2a6f038 100644 --- a/lz4.c +++ b/lz4.c @@ -1033,9 +1033,12 @@ FORCE_INLINE int LZ4_decompress_generic( if (unlikely(cpy>oend-12)) { if (cpy > oend-LASTLITERALS) goto _output_error; /* Error : last LASTLITERALS bytes must be literals */ - if (op < oend-8) LZ4_wildCopy(op, match, oend-8); - match += oend-8 - op; - op = oend-8; + if (op < oend-8) + { + LZ4_wildCopy(op, match, oend-8); + match += oend-8 - op; + op = oend-8; + } while (op Date: Sat, 29 Nov 2014 16:41:28 +0100 Subject: [PATCH 06/22] Fixed : decompression issue on 32-bits CPU without unaligned memory access --- examples/Makefile | 2 +- lz4.c | 36 +++++++++++++++++++++++++++--------- lz4.h | 29 ++++++++--------------------- programs/lz4cli.c | 15 +-------------- 4 files changed, 37 insertions(+), 45 deletions(-) diff --git a/examples/Makefile b/examples/Makefile index 4474f59..df24ea9 100644 --- a/examples/Makefile +++ b/examples/Makefile @@ -32,7 +32,7 @@ CC := $(CC) CFLAGS ?= -O3 -CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wstrict-prototypes -Wno-missing-braces # Wno-missing-braces required due to GCC <4.8.3 bug +CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -Wno-missing-braces # Wno-missing-braces required due to GCC <4.8.3 bug FLAGS = -I.. $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) TESTFILE= Makefile diff --git a/lz4.c b/lz4.c index 2a6f038..f2a8120 100644 --- a/lz4.c +++ b/lz4.c @@ -44,10 +44,26 @@ /* * CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS : - * You can force the code to use unaligned memory access, should you know your CPU can handle it efficiently. - * If it effectively results in better speed (up to 50% improvement can be expected) + * By default, the source code expects the compiler to correctly optimize + * 4-bytes and 8-bytes read on architectures able to handle it efficiently. + * This is not always the case. In some circumstances (ARM notably), + * the compiler will issue cautious code even when target is able to correctly handle unaligned memory accesses. + * + * You can force the compiler to use unaligned memory access by uncommenting the line below. + * One of the below scenarios will happen : + * 1 - Your target CPU correctly handle unaligned access, and was not well optimized by compiler (good case). + * You will witness large performance improvements (+50% and up). + * Keep the line uncommented and send a word to upstream (https://groups.google.com/forum/#!forum/lz4c) + * The goal is to automatically detect such situations by adding your target CPU within an exception list. + * 2 - Your target CPU correctly handle unaligned access, and was already correctly optimized by compiler + * No change will be experienced. + * 3 - Your target CPU inefficiently handle unaligned access. + * You will experience a performance loss. Comment back the line. + * 4 - Your target CPU does not handle unaligned access. + * Program will crash. + * If it effectively results in better speed (case 1) * please report your configuration to upstream (https://groups.google.com/forum/#!forum/lz4c) - * so that an automatic detection macro can be added to mainline. + * so that an automatic detection macro can be added for future versions of the library. */ /* #define CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS 1 */ @@ -58,7 +74,7 @@ /* * Automated efficient unaligned memory access detection * Based on known hardware architectures - * This list will be updated thanks to Open Source community feedbacks + * This list will be updated thanks to feedbacks */ #if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \ || defined(__ARM_FEATURE_UNALIGNED) \ @@ -71,7 +87,10 @@ # define LZ4_UNALIGNED_ACCESS 0 #endif -/* Define this parameter if your target system or compiler does not support hardware bit count */ +/* + * LZ4_FORCE_SW_BITCOUNT + * Define this parameter if your target system or compiler does not support hardware bit count + */ #if defined(_MSC_VER) && defined(_WIN32_WCE) /* Visual Studio for Windows CE does not support Hardware bit count */ # define LZ4_FORCE_SW_BITCOUNT #endif @@ -88,7 +107,7 @@ #ifdef _MSC_VER /* Visual Studio */ # define FORCE_INLINE static __forceinline -# include /* For Visual 2005 */ +# include # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ #else # ifdef __GNUC__ @@ -961,7 +980,6 @@ FORCE_INLINE int LZ4_decompress_generic( } LZ4_wildCopy(op, ip, cpy); ip += length; op = cpy; - //LZ4_WILDCOPY(op, ip, cpy); ip -= (op-cpy); op = cpy; /* get offset */ match = cpy - LZ4_readLE16(ip); ip+=2; @@ -1018,7 +1036,7 @@ FORCE_INLINE int LZ4_decompress_generic( /* copy repeated sequence */ cpy = op + length; - if (unlikely((op-match)<(int)STEPSIZE)) + if (unlikely((op-match)<8)) { const size_t dec64 = dec64table[op-match]; op[0] = match[0]; @@ -1036,7 +1054,7 @@ FORCE_INLINE int LZ4_decompress_generic( if (op < oend-8) { LZ4_wildCopy(op, match, oend-8); - match += oend-8 - op; + match += (oend-8) - op; op = oend-8; } while (op on unix @@ -127,15 +123,6 @@ #define LZ4_BLOCKSIZEID_DEFAULT 7 -//************************************** -// Architecture Macros -//************************************** -static const int one = 1; -#define CPU_LITTLE_ENDIAN (*(char*)(&one)) -#define CPU_BIG_ENDIAN (!CPU_LITTLE_ENDIAN) -#define LITTLE_ENDIAN_32(i) (CPU_LITTLE_ENDIAN?(i):swap32(i)) - - //************************************** // Macros //************************************** @@ -462,7 +449,7 @@ int main(int argc, char** argv) } DISPLAYLEVEL(3, WELCOME_MESSAGE); - DISPLAYLEVEL(4, "Blocks size : %i KB\n", blockSize>>10); + if (!decode) DISPLAYLEVEL(4, "Blocks size : %i KB\n", blockSize>>10); // No input filename ==> use stdin if(!input_filename) { input_filename=stdinmark; } From 33dca250ee0afa3aec58bf3bf1a34b09bebf3fb5 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sat, 29 Nov 2014 17:12:26 +0100 Subject: [PATCH 07/22] minor : fixed warning under clang --- lz4hc.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/lz4hc.c b/lz4hc.c index 8f6f25b..3dbdf1d 100644 --- a/lz4hc.c +++ b/lz4hc.c @@ -50,7 +50,7 @@ Memory routines /************************************** -CPU Feature Detection + CPU Feature Detection **************************************/ /* 32 or 64 bits ? */ #if (defined(__x86_64__) || defined(_M_X64) || defined(_WIN64) \ @@ -102,7 +102,7 @@ CPU Feature Detection /************************************** -Compiler Options + Compiler Options **************************************/ #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */ /* "restrict" is a known keyword */ @@ -138,14 +138,14 @@ Compiler Options /************************************** -Includes + Includes **************************************/ -#include "lz4hc.h" #include "lz4.h" +#include "lz4hc.h" /************************************** -Basic Types + Basic Types **************************************/ #if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */ # include @@ -248,9 +248,12 @@ Architecture-specific macros **************************************/ typedef struct { - U32 hashTable[HASHTABLESIZE]; + union { + U64 alignedOn8Bytes; /* force 8-bytes alignment on 32-bits systems */ + U32 hashTable[HASHTABLESIZE]; + }; U16 chainTable[MAXD]; - const BYTE* end; /* next block here to keep current prefix as prefix */ + const BYTE* end; /* next block here to continue on current prefix */ const BYTE* base; /* All index relative to this position */ const BYTE* dictBase; /* alternate base for extDict */ U32 dictLimit; /* below that point, need extDict */ From 6658c49a971e0363bfa17de418b4512bfe12f0c5 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sat, 29 Nov 2014 17:44:33 +0100 Subject: [PATCH 08/22] Improved compression speed on big endian CPU --- lz4.c | 124 ++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 73 insertions(+), 51 deletions(-) diff --git a/lz4.c b/lz4.c index f2a8120..fbe73bd 100644 --- a/lz4.c +++ b/lz4.c @@ -55,15 +55,15 @@ * You will witness large performance improvements (+50% and up). * Keep the line uncommented and send a word to upstream (https://groups.google.com/forum/#!forum/lz4c) * The goal is to automatically detect such situations by adding your target CPU within an exception list. - * 2 - Your target CPU correctly handle unaligned access, and was already correctly optimized by compiler + * 2 - Your target CPU correctly handle unaligned access, and was already already optimized by compiler * No change will be experienced. * 3 - Your target CPU inefficiently handle unaligned access. * You will experience a performance loss. Comment back the line. * 4 - Your target CPU does not handle unaligned access. * Program will crash. - * If it effectively results in better speed (case 1) + * If uncommenting results in better performance (case 1) * please report your configuration to upstream (https://groups.google.com/forum/#!forum/lz4c) - * so that an automatic detection macro can be added for future versions of the library. + * An automatic detection macro will be added to match your case within future versions of the library. */ /* #define CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS 1 */ @@ -177,6 +177,7 @@ static unsigned LZ4_isLittleEndian(void) return one.c[0]; } + static U16 LZ4_readLE16(const void* memPtr) { if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) @@ -204,12 +205,10 @@ static void LZ4_writeLE16(void* memPtr, U16 value) } -static U32 LZ4_read16(const void* memPtr) +static U16 LZ4_read16(const void* memPtr) { if (LZ4_UNALIGNED_ACCESS) - { return *(U16*)memPtr; - } else { U16 val16; @@ -221,9 +220,7 @@ static U32 LZ4_read16(const void* memPtr) static U32 LZ4_read32(const void* memPtr) { if (LZ4_UNALIGNED_ACCESS) - { return *(U32*)memPtr; - } else { U32 val32; @@ -232,36 +229,24 @@ static U32 LZ4_read32(const void* memPtr) } } - -static U32 LZ4_readLE32(const void* memPtr) +static U64 LZ4_read64(const void* memPtr) { - if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) - return *(U32*)memPtr; - { - const BYTE* p = memPtr; - U32 result = (U32)((U32)p[0] + (p[1]<<8) + (p[2]<<16) + ((U32)p[3]<<24)); - return result; - } -} - -static U64 LZ4_readLE64(const void* memPtr) -{ - if ((LZ4_UNALIGNED_ACCESS) && (LZ4_isLittleEndian())) + if (LZ4_UNALIGNED_ACCESS) return *(U64*)memPtr; else { - const BYTE* p = memPtr; - return (U64)((U64)p[0] + (p[1]<<8) + (p[2]<<16) + ((U64)p[3]<<24) + - (((U64)p[4])<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); + U64 val64; + memcpy(&val64, memPtr, 8); + return val64; } } -static size_t LZ4_readLE_ARCH(const void* p) +static size_t LZ4_read_ARCH(const void* p) { if (LZ4_64bits()) - return (size_t)LZ4_readLE64(p); + return (size_t)LZ4_read64(p); else - return (size_t)LZ4_readLE32(p); + return (size_t)LZ4_read32(p); } @@ -365,31 +350,68 @@ int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } ********************************/ static unsigned LZ4_NbCommonBytes (register size_t val) { - if (LZ4_64bits()) + if (LZ4_isLittleEndian()) { -# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r = 0; - _BitScanForward64( &r, (U64)val ); - return (int)(r>>3); -# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_ctzll((U64)val) >> 3); -# else - static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; - return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; -# endif + if (LZ4_64bits()) + { +# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r = 0; + _BitScanForward64( &r, (U64)val ); + return (int)(r>>3); +# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (__builtin_ctzll((U64)val) >> 3); +# else + static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; + return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; +# endif + } + else /* 32 bits */ + { +# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r; + _BitScanForward( &r, (U32)val ); + return (int)(r>>3); +# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (__builtin_ctz((U32)val) >> 3); +# else + static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; + return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; +# endif + } } - /* 32 bits */ + else /* Big Endian CPU */ { -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r; - _BitScanForward( &r, (U32)val ); - return (int)(r>>3); -# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_ctz((U32)val) >> 3); -# else - static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; - return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; -# endif + if (LZ4_64bits()) + { +# if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r = 0; + _BitScanReverse64( &r, val ); + return (unsigned)(r>>3); +# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (__builtin_clzll(val) >> 3); +# else + unsigned r; + if (!(val>>32)) { r=4; } else { r=0; val>>=32; } + if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } + r += (!val); + return r; +# endif + } + else /* 32 bits */ + { +# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) + unsigned long r = 0; + _BitScanReverse( &r, val ); + return (unsigned)(r>>3); +# elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) + return (__builtin_clz(val) >> 3); +# else + unsigned r; + if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } + r += (!val); + return r; +# endif + } } } @@ -439,7 +461,7 @@ static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLi while (likely(pIn Date: Sat, 29 Nov 2014 20:19:39 +0100 Subject: [PATCH 09/22] Updated lz4hc : re-use most shared elements from lz4 (endianess / align / bus detection routines) --- lz4.c | 131 ++++++++++-------- lz4hc.c | 314 +++++-------------------------------------- programs/frametest.c | 2 +- 3 files changed, 109 insertions(+), 338 deletions(-) diff --git a/lz4.c b/lz4.c index fbe73bd..9439b36 100644 --- a/lz4.c +++ b/lz4.c @@ -285,12 +285,8 @@ static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd) /************************************** - Constants + Common Constants **************************************/ -#define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2) -#define HASHTABLESIZE (1 << LZ4_MEMORY_USAGE) -#define HASH_SIZE_U32 (1 << LZ4_HASHLOG) - #define MINMATCH 4 #define COPYLENGTH 8 @@ -298,13 +294,10 @@ static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd) #define MFLIMIT (COPYLENGTH+MINMATCH) static const int LZ4_minLength = (MFLIMIT+1); -#define KB *(1U<<10) -#define MB *(1U<<20) +#define KB *(1 <<10) +#define MB *(1 <<20) #define GB *(1U<<30) -#define LZ4_64KLIMIT ((64 KB) + (MFLIMIT-1)) -#define SKIPSTRENGTH 6 /* Increasing this value will make the compression run slower on incompressible data */ - #define MAXD_LOG 16 #define MAX_DISTANCE ((1 << MAXD_LOG) - 1) @@ -315,38 +308,13 @@ static const int LZ4_minLength = (MFLIMIT+1); /************************************** - Structures and local types -**************************************/ -typedef struct { - U32 hashTable[HASH_SIZE_U32]; - U32 currentOffset; - U32 initCheck; - const BYTE* dictionary; - const BYTE* bufferStart; - U32 dictSize; -} LZ4_stream_t_internal; - -typedef enum { notLimited = 0, limitedOutput = 1 } limitedOutput_directive; -typedef enum { byPtr, byU32, byU16 } tableType_t; - -typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive; -typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; - -typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive; -typedef enum { full = 0, partial = 1 } earlyEnd_directive; - - -/************************************** - Utils + Common Utils **************************************/ #define LZ4_STATIC_ASSERT(c) { enum { LZ4_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */ -int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; } -int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } - /******************************** - Compression functions + Common functions ********************************/ static unsigned LZ4_NbCommonBytes (register size_t val) { @@ -415,6 +383,73 @@ static unsigned LZ4_NbCommonBytes (register size_t val) } } +static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) +{ + const BYTE* const pStart = pIn; + + while (likely(pIn /* calloc, free */ -#define ALLOCATOR(s) calloc(1,s) -#define FREEMEM free -#include /* memset, memcpy */ -#define MEM_INIT memset - - -/************************************** - CPU Feature Detection -**************************************/ -/* 32 or 64 bits ? */ -#if (defined(__x86_64__) || defined(_M_X64) || defined(_WIN64) \ - || defined(__64BIT__) || defined(__mips64) \ - || defined(__powerpc64__) || defined(__powerpc64le__) \ - || defined(__ppc64__) || defined(__ppc64le__) \ - || defined(__PPC64__) || defined(__PPC64LE__) \ - || defined(__ia64) || defined(__itanium__) || defined(_M_IA64) \ - || defined(__s390x__) ) /* Detects 64 bits mode */ -# define LZ4_ARCH64 1 -#else -# define LZ4_ARCH64 0 -#endif - -/* -* Little Endian or Big Endian ? -* Overwrite the #define below if you know your architecture endianess -*/ -#include /* Apparently required to detect endianess */ -#if defined (__GLIBC__) -# include -# if (__BYTE_ORDER == __BIG_ENDIAN) -# define LZ4_BIG_ENDIAN 1 -# endif -#elif (defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN)) && !(defined(__LITTLE_ENDIAN__) || defined(__LITTLE_ENDIAN) || defined(_LITTLE_ENDIAN)) -# define LZ4_BIG_ENDIAN 1 -#elif defined(__sparc) || defined(__sparc__) \ - || defined(__powerpc__) || defined(__ppc__) || defined(__PPC__) \ - || defined(__hpux) || defined(__hppa) \ - || defined(_MIPSEB) || defined(__s390__) -# define LZ4_BIG_ENDIAN 1 -#else -/* Little Endian assumed. PDP Endian and other very rare endian format are unsupported. */ -#endif - -/* -* Unaligned memory access is automatically enabled for "common" CPU, such as x86. -* For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected -* If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance -*/ -#if defined(__ARM_FEATURE_UNALIGNED) -# define LZ4_FORCE_UNALIGNED_ACCESS 1 -#endif - -/* Define this parameter if your target system or compiler does not support hardware bit count */ -#if defined(_MSC_VER) && defined(_WIN32_WCE) /* Visual Studio for Windows CE does not support Hardware bit count */ -# define LZ4_FORCE_SW_BITCOUNT -#endif - - -/************************************** - Compiler Options -**************************************/ -#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */ -/* "restrict" is a known keyword */ -#else -# define restrict /* Disable restrict */ -#endif - -#ifdef _MSC_VER /* Visual Studio */ -# define FORCE_INLINE static __forceinline -# include /* For Visual 2005 */ -# if LZ4_ARCH64 /* 64-bits */ -# pragma intrinsic(_BitScanForward64) /* For Visual 2005 */ -# pragma intrinsic(_BitScanReverse64) /* For Visual 2005 */ -# else /* 32-bits */ -# pragma intrinsic(_BitScanForward) /* For Visual 2005 */ -# pragma intrinsic(_BitScanReverse) /* For Visual 2005 */ -# endif -# pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ -# pragma warning(disable : 4701) /* disable: C4701: potentially uninitialized local variable used */ -#else -# ifdef __GNUC__ -# define FORCE_INLINE static inline __attribute__((always_inline)) -# else -# define FORCE_INLINE static inline -# endif -#endif - -#ifdef _MSC_VER /* Visual Studio */ -# define lz4_bswap16(x) _byteswap_ushort(x) -#else -# define lz4_bswap16(x) ((unsigned short int) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8))) -#endif - - /************************************** Includes **************************************/ @@ -145,106 +47,40 @@ Memory routines /************************************** - Basic Types + Local Compiler Options **************************************/ -#if defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */ -# include -typedef uint8_t BYTE; -typedef uint16_t U16; -typedef uint32_t U32; -typedef int32_t S32; -typedef uint64_t U64; -#else -typedef unsigned char BYTE; -typedef unsigned short U16; -typedef unsigned int U32; -typedef signed int S32; -typedef unsigned long long U64; +#if defined(__GNUC__) +# pragma GCC diagnostic ignored "-Wunused-function" #endif -#if defined(__GNUC__) && !defined(LZ4_FORCE_UNALIGNED_ACCESS) -# define _PACKED __attribute__ ((packed)) -#else -# define _PACKED +#if defined (__clang__) +# pragma clang diagnostic ignored "-Wunused-function" #endif -#if !defined(LZ4_FORCE_UNALIGNED_ACCESS) && !defined(__GNUC__) -# ifdef __IBMC__ -# pragma pack(1) -# else -# pragma pack(push, 1) -# endif -#endif - -typedef struct _U16_S { U16 v; } _PACKED U16_S; -typedef struct _U32_S { U32 v; } _PACKED U32_S; -typedef struct _U64_S { U64 v; } _PACKED U64_S; - -#if !defined(LZ4_FORCE_UNALIGNED_ACCESS) && !defined(__GNUC__) -# pragma pack(pop) -#endif - -#define A64(x) (((U64_S *)(x))->v) -#define A32(x) (((U32_S *)(x))->v) -#define A16(x) (((U16_S *)(x))->v) - /************************************** -Constants + Common LZ4 definition **************************************/ -#define MINMATCH 4 +#define LZ4_COMMONDEFS_ONLY +#include "lz4.c" + +/************************************** + Local Constants +**************************************/ #define DICTIONARY_LOGSIZE 16 #define MAXD (1<> ((MINMATCH*8)-HASH_LOG)) #define DELTANEXT(p) chainTable[(size_t)(p) & MAXD_MASK] #define GETNEXT(p) ((p) - (size_t)DELTANEXT(p)) -static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(A32(ptr)); } +static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); } + + /************************************** -Private functions + HC Compression **************************************/ -#if LZ4_ARCH64 - -FORCE_INLINE int LZ4_NbCommonBytes (register U64 val) -{ -#if defined(LZ4_BIG_ENDIAN) -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r = 0; - _BitScanReverse64( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_clzll(val) >> 3); -# else - int r; - if (!(val>>32)) { r=4; } else { r=0; val>>=32; } - if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } - r += (!val); - return r; -# endif -#else -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r = 0; - _BitScanForward64( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_ctzll(val) >> 3); -# else - static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; - return DeBruijnBytePos[((U64)((val & -val) * 0x0218A392CDABBD3F)) >> 58]; -# endif -#endif -} - -#else - -FORCE_INLINE int LZ4_NbCommonBytes (register U32 val) -{ -#if defined(LZ4_BIG_ENDIAN) -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r; - _BitScanReverse( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_clz(val) >> 3); -# else - int r; - if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } - r += (!val); - return r; -# endif -#else -# if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) - unsigned long r; - _BitScanForward( &r, val ); - return (int)(r>>3); -# elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) - return (__builtin_ctz(val) >> 3); -# else - static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; - return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; -# endif -#endif -} - -#endif - - static void LZ4HC_init (LZ4HC_Data_Structure* hc4, const BYTE* base) { MEM_INIT((void*)hc4->hashTable, 0, sizeof(hc4->hashTable)); @@ -397,24 +166,6 @@ static void LZ4HC_setExternalDict(LZ4HC_Data_Structure* ctxPtr, const BYTE* newB } -static size_t LZ4HC_CommonLength (const BYTE* p1, const BYTE* p2, const BYTE* const p1Limit) -{ - const BYTE* const p1Start = p1; - - while (p1 <= p1Limit - STEPSIZE) - { - size_t diff = AARCH(p2) ^ AARCH(p1); - if (!diff) { p1+=STEPSIZE; p2+=STEPSIZE; continue; } - p1 += LZ4_NbCommonBytes(diff); - return (p1 - p1Start); - } - if (LZ4_ARCH64) if ((p1<(p1Limit-3)) && (A32(p2) == A32(p1))) { p1+=4; p2+=4; } - if ((p1<(p1Limit-1)) && (A16(p2) == A16(p1))) { p1+=2; p2+=2; } - if ((p1 ml) { ml = mlt; *matchpos = match; } } } else { match = dictBase + matchIndex; - if (A32(match) == A32(ip)) + if (LZ4_read32(match) == LZ4_read32(ip)) { size_t mlt; const BYTE* vLimit = ip + (dictLimit - matchIndex); if (vLimit > iLimit) vLimit = iLimit; - mlt = LZ4HC_CommonLength(ip+MINMATCH, match+MINMATCH, vLimit) + MINMATCH; + mlt = LZ4_count(ip+MINMATCH, match+MINMATCH, vLimit) + MINMATCH; if ((ip+mlt == vLimit) && (vLimit < iLimit)) - mlt += LZ4HC_CommonLength(ip+mlt, base+dictLimit, iLimit); + mlt += LZ4_count(ip+mlt, base+dictLimit, iLimit); if (mlt > ml) { ml = mlt; *matchpos = base + matchIndex; } // virtual matchpos } } @@ -502,11 +253,11 @@ FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch ( { match = base + matchIndex; if (*(iLowLimit + longest) == *(match - delta + longest)) - if (A32(match) == A32(ip)) + if (LZ4_read32(match) == LZ4_read32(ip)) { const BYTE* startt = ip; const BYTE* tmpMatch = match; - const BYTE* const matchEnd = ip + MINMATCH + LZ4HC_CommonLength(ip+MINMATCH, match+MINMATCH, iHighLimit); + const BYTE* const matchEnd = ip + MINMATCH + LZ4_count(ip+MINMATCH, match+MINMATCH, iHighLimit); while ((startt>iLowLimit) && (tmpMatch > iLowLimit) && (startt[-1] == tmpMatch[-1])) {startt--; tmpMatch--;} @@ -521,15 +272,15 @@ FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch ( else { match = dictBase + matchIndex; - if (A32(match) == A32(ip)) + if (LZ4_read32(match) == LZ4_read32(ip)) { size_t mlt; int back=0; const BYTE* vLimit = ip + (dictLimit - matchIndex); if (vLimit > iHighLimit) vLimit = iHighLimit; - mlt = LZ4HC_CommonLength(ip+MINMATCH, match+MINMATCH, vLimit) + MINMATCH; + mlt = LZ4_count(ip+MINMATCH, match+MINMATCH, vLimit) + MINMATCH; if ((ip+mlt == vLimit) && (vLimit < iHighLimit)) - mlt += LZ4HC_CommonLength(ip+mlt, base+dictLimit, iHighLimit); + mlt += LZ4_count(ip+mlt, base+dictLimit, iHighLimit); while ((ip+back > iLowLimit) && (matchIndex+back > lowLimit) && (ip[back-1] == match[back-1])) back--; mlt -= back; if ((int)mlt > longest) { longest = (int)mlt; *matchpos = base + matchIndex + back; *startpos = ip+back; } @@ -568,10 +319,11 @@ FORCE_INLINE int LZ4HC_encodeSequence ( else *token = (BYTE)(length< Date: Sun, 30 Nov 2014 12:58:00 +0100 Subject: [PATCH 10/22] Fixed : some minor Visual warnings --- lz4.c | 2 +- lz4hc.c | 4 ++++ programs/Makefile | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/lz4.c b/lz4.c index 9439b36..fb84955 100644 --- a/lz4.c +++ b/lz4.c @@ -369,7 +369,7 @@ static unsigned LZ4_NbCommonBytes (register size_t val) { # if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) unsigned long r = 0; - _BitScanReverse( &r, val ); + _BitScanReverse( &r, (unsigned long)val ); return (unsigned)(r>>3); # elif defined(__GNUC__) && (GCC_VERSION >= 304) && !defined(LZ4_FORCE_SW_BITCOUNT) return (__builtin_clz(val) >> 3); diff --git a/lz4hc.c b/lz4hc.c index a798cab..89f0db0 100644 --- a/lz4hc.c +++ b/lz4hc.c @@ -57,6 +57,10 @@ You can contact the author at : # pragma clang diagnostic ignored "-Wunused-function" #endif +#if defined(_MSC_VER) /* Visual Studio */ +# pragma warning(disable : 4201) /* disable: C4201: unnamed struct/union*/ +#endif + /************************************** Common LZ4 definition diff --git a/programs/Makefile b/programs/Makefile index fcfb32c..8a3ed95 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -193,7 +193,7 @@ test-mem: lz4 datagen fuzzer frametest ./datagen -g16MB > tmp valgrind --leak-check=yes ./lz4 -9 -B5D -f tmp /dev/null ./datagen -g256MB > tmp - valgrind --leak-check=yes ./lz4 -B4D -f tmp /dev/null + valgrind --leak-check=yes ./lz4 -B4D -f -vq tmp /dev/null rm tmp valgrind --leak-check=yes ./fuzzer -i50 -t0 valgrind --leak-check=yes ./frametest -i100 From 6de52c2a8c40b7381e364ad87af9e80a60d95229 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 30 Nov 2014 17:59:31 +0100 Subject: [PATCH 11/22] LZ4IO : modified to use lz4frame instead --- lz4frame.h | 2 +- programs/Makefile | 19 +- programs/lz4cli.c | 3 +- programs/lz4io.c | 595 ++++++++++++---------------------------------- programs/lz4io.h | 4 +- 5 files changed, 167 insertions(+), 456 deletions(-) diff --git a/lz4frame.h b/lz4frame.h index d31203d..a4f5e36 100644 --- a/lz4frame.h +++ b/lz4frame.h @@ -201,7 +201,7 @@ size_t LZ4F_compressEnd(LZ4F_compressionContext_t compressionContext, void* dstB typedef void* LZ4F_decompressionContext_t; typedef struct { - unsigned stableDst; /* unused for the time being, must be 0 */ + unsigned stableDst; /* guarantee that decompressed data will still be there on next function calls (avoid storage into tmp buffers) */ unsigned reserved[3]; } LZ4F_decompressOptions_t; diff --git a/programs/Makefile b/programs/Makefile index 8a3ed95..9001e2c 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -65,13 +65,13 @@ default: lz4 lz4c all: lz4 lz4c lz4c32 fullbench fullbench32 fuzzer fuzzer32 frametest frametest32 datagen -lz4: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c +lz4: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c $(CC) $(FLAGS) -DDISABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) -lz4c : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c +lz4c : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c $(CC) $(FLAGS) $^ -o $@$(EXT) -lz4c32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c +lz4c32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) fullbench : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c fullbench.c @@ -80,16 +80,16 @@ fullbench : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xx fullbench32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c fullbench.c $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) -fuzzer : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c fuzzer.c +fuzzer : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c fuzzer.c $(CC) $(FLAGS) $^ -o $@$(EXT) fuzzer32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c fuzzer.c $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) -frametest: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c +frametest: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c $(CC) $(FLAGS) $^ -o $@$(EXT) -frametest32: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c +frametest32: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) datagen : datagen.c @@ -156,9 +156,10 @@ test-lz4: lz4 datagen @rm *.test @echo frame concatenation test completed # test frame concatenation with null-length frame - + test-lz4c: lz4c datagen + ./datagen -g256MB | ./lz4c -l -v -B4D | ./lz4c -vdq > $(VOID) test-lz4c32: lz4 lz4c32 lz4 datagen ./datagen -g16KB | ./lz4c32 -9 | ./lz4c32 -vdq > $(VOID) @@ -195,8 +196,8 @@ test-mem: lz4 datagen fuzzer frametest ./datagen -g256MB > tmp valgrind --leak-check=yes ./lz4 -B4D -f -vq tmp /dev/null rm tmp - valgrind --leak-check=yes ./fuzzer -i50 -t0 - valgrind --leak-check=yes ./frametest -i100 + valgrind --leak-check=yes ./fuzzer -i64 -t0 + valgrind --leak-check=yes ./frametest -i256 test-mem32: lz4c32 datagen # unfortunately, valgrind doesn't seem to work with non-native binary. If someone knows how to do a valgrind-test on a 32-bits exe with a 64-bits system... diff --git a/programs/lz4cli.c b/programs/lz4cli.c index 6e52ec6..8a8fc27 100644 --- a/programs/lz4cli.c +++ b/programs/lz4cli.c @@ -48,7 +48,6 @@ # pragma warning(disable : 4127) // disable: C4127: conditional expression is constant #endif -#define _FILE_OFFSET_BITS 64 // Large file support on 32-bits unix #define _POSIX_SOURCE 1 // for fileno() within on unix @@ -400,7 +399,7 @@ int main(int argc, char** argv) argument++; break; } - case 'D': LZ4IO_setBlockMode(chainedBlocks); argument++; break; + case 'D': LZ4IO_setBlockMode(LZ4IO_blockLinked); argument++; break; case 'X': LZ4IO_setBlockChecksumMode(1); argument ++; break; default : exitBlockProperties=1; } diff --git a/programs/lz4io.c b/programs/lz4io.c index afaa59f..a9c3c97 100644 --- a/programs/lz4io.c +++ b/programs/lz4io.c @@ -38,6 +38,12 @@ # pragma warning(disable : 4127) // disable: C4127: conditional expression is constant #endif +#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wmissing-braces" /* GCC bug 53119 : doesn't accept { 0 } as initializer (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119) */ +# pragma GCC diagnostic ignored "-Wmissing-field-initializers" /* GCC bug 53119 : doesn't accept { 0 } as initializer (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119) */ +#endif + #define _LARGE_FILES // Large file support on 32-bits AIX #define _FILE_OFFSET_BITS 64 // Large file support on 32-bits unix #define _POSIX_SOURCE 1 // for fileno() within on unix @@ -47,13 +53,13 @@ // Includes //**************************** #include // fprintf, fopen, fread, _fileno, stdin, stdout -#include // malloc +#include // malloc, free #include // strcmp, strlen #include // clock #include "lz4io.h" -#include "lz4.h" -#include "lz4hc.h" -#include "xxhash.h" +#include "lz4.h" // still required for legacy format +#include "lz4hc.h" // still required for legacy format +#include "lz4frame.h" //**************************** @@ -74,31 +80,11 @@ #endif -//************************************** -// Compiler-specific functions -//************************************** -#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) - -#if defined(_MSC_VER) // Visual Studio -# define swap32 _byteswap_ulong -#elif GCC_VERSION >= 403 -# define swap32 __builtin_bswap32 -#else - static unsigned int swap32(unsigned int x) - { - return ((x << 24) & 0xff000000 ) | - ((x << 8) & 0x00ff0000 ) | - ((x >> 8) & 0x0000ff00 ) | - ((x >> 24) & 0x000000ff ); - } -#endif - - //**************************** // Constants //**************************** -#define KB *(1U<<10) -#define MB *(1U<<20) +#define KB *(1 <<10) +#define MB *(1 <<20) #define GB *(1U<<30) #define _1BIT 0x01 @@ -122,20 +108,17 @@ #define LZ4S_MAXHEADERSIZE (MAGICNUMBER_SIZE+2+8+4+1) -//************************************** -// Architecture Macros -//************************************** -static const int one = 1; -#define CPU_LITTLE_ENDIAN (*(char*)(&one)) -#define CPU_BIG_ENDIAN (!CPU_LITTLE_ENDIAN) -#define LITTLE_ENDIAN_32(i) (CPU_LITTLE_ENDIAN?(i):swap32(i)) - - //************************************** // Macros //************************************** #define DISPLAY(...) fprintf(stderr, __VA_ARGS__) #define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); } +#define DISPLAYUPDATE(l, ...) if (displayLevel>=l) { \ + if ((LZ4IO_GetMilliSpan(g_time) > refreshRate) || (displayLevel>=4)) \ + { g_time = clock(); DISPLAY(__VA_ARGS__); \ + if (displayLevel>=4) fflush(stdout); } } +static const unsigned refreshRate = 150; +static clock_t g_time = 0; //************************************** @@ -196,9 +179,9 @@ int LZ4IO_setBlockSizeID(int bsid) return blockSizeTable[globalBlockSizeId-minBlockSizeID]; } -int LZ4IO_setBlockMode(blockMode_t blockMode) +int LZ4IO_setBlockMode(LZ4IO_blockMode_t blockMode) { - blockIndependence = (blockMode == independentBlocks); + blockIndependence = (blockMode == LZ4IO_blockIndependent); return blockIndependence; } @@ -223,6 +206,13 @@ int LZ4IO_setNotificationLevel(int level) return displayLevel; } +static unsigned LZ4IO_GetMilliSpan(clock_t nPrevious) +{ +#define CLOCKS_PER_MSEC (CLOCKS_PER_SEC/1000) + clock_t nCurrent = clock(); + unsigned nSpan = (unsigned)((nCurrent - nPrevious) / CLOCKS_PER_MSEC); + return nSpan; +} /* ************************************************************************ */ @@ -230,7 +220,6 @@ int LZ4IO_setNotificationLevel(int level) /* ************************************************************************ */ static int LZ4S_GetBlockSize_FromBlockId (int id) { return (1 << (8 + (2 * id))); } -static unsigned int LZ4S_GetCheckBits_FromXXH (unsigned int xxh) { return (xxh >> 8) & _8BITS; } static int LZ4S_isSkippableMagicNumber(unsigned int magic) { return (magic & LZ4S_SKIPPABLEMASK) == LZ4S_SKIPPABLE0; } @@ -282,8 +271,25 @@ static int get_fileHandle(char* input_filename, char* output_filename, FILE** pf } -// LZ4IO_compressFilename_Legacy : This function is intentionally "hidden" (not published in .h) -// It generates compressed streams using the old 'legacy' format + + +/*************************************** + * Legacy Compression + * *************************************/ + +/* unoptimized version; solves endianess & alignment issues */ +static void LZ4IO_writeLE32 (void* p, unsigned value32) +{ + unsigned char* dstPtr = p; + dstPtr[0] = (unsigned char)value32; + dstPtr[1] = (unsigned char)(value32 >> 8); + dstPtr[2] = (unsigned char)(value32 >> 16); + dstPtr[3] = (unsigned char)(value32 >> 24); +} + +/* LZ4IO_compressFilename_Legacy : + * This function is intentionally "hidden" (not published in .h) + * It generates compressed streams using the old 'legacy' format */ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, int compressionlevel) { int (*compressionFunction)(const char*, char*, int); @@ -298,8 +304,9 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i // Init - if (compressionlevel < 3) compressionFunction = LZ4_compress; else compressionFunction = LZ4_compressHC; start = clock(); + if (compressionlevel < 3) compressionFunction = LZ4_compress; else compressionFunction = LZ4_compressHC; + get_fileHandle(input_filename, output_filename, &finput, &foutput); if ((displayLevel==2) && (compressionlevel==1)) displayLevel=3; @@ -309,7 +316,7 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i if (!in_buff || !out_buff) EXM_THROW(21, "Allocation error : not enough memory"); // Write Archive Header - *(unsigned int*)out_buff = LITTLE_ENDIAN_32(LEGACY_MAGICNUMBER); + LZ4IO_writeLE32(out_buff, LEGACY_MAGICNUMBER); sizeCheck = fwrite(out_buff, 1, MAGICNUMBER_SIZE, foutput); if (sizeCheck!=MAGICNUMBER_SIZE) EXM_THROW(22, "Write error : cannot write header"); @@ -321,15 +328,14 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i int inSize = (int) fread(in_buff, (size_t)1, (size_t)LEGACY_BLOCKSIZE, finput); if( inSize<=0 ) break; filesize += inSize; - DISPLAYLEVEL(3, "\rRead : %i MB ", (int)(filesize>>20)); // Compress Block outSize = compressionFunction(in_buff, out_buff+4, inSize); compressedfilesize += outSize+4; - DISPLAYLEVEL(3, "\rRead : %i MB ==> %.2f%% ", (int)(filesize>>20), (double)compressedfilesize/filesize*100); + DISPLAYUPDATE(3, "\rRead : %i MB ==> %.2f%% ", (int)(filesize>>20), (double)compressedfilesize/filesize*100); // Write Block - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(outSize); + LZ4IO_writeLE32(out_buff, outSize); sizeCheck = fwrite(out_buff, 1, outSize+4, foutput); if (sizeCheck!=(size_t)(outSize+4)) EXM_THROW(23, "Write error : cannot write compressed block"); } @@ -354,320 +360,93 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i } -static void* LZ4IO_LZ4_createStream (const char* inputBuffer) -{ - (void)inputBuffer; - return calloc(8, LZ4_STREAMSIZE_U64); -} - -static int LZ4IO_LZ4_compress_limitedOutput_continue (void* ctx, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel) -{ - (void)compressionLevel; - return LZ4_compress_limitedOutput_continue(ctx, source, dest, inputSize, maxOutputSize); -} - -static int LZ4IO_LZ4_saveDict (void* LZ4_stream, char* safeBuffer, int dictSize) -{ - return LZ4_saveDict ((LZ4_stream_t*) LZ4_stream, safeBuffer, dictSize); -} - -static int LZ4IO_LZ4_slideInputBufferHC (void* ctx, char* buffer, int size) -{ - (void)size; (void)buffer; - LZ4_slideInputBufferHC (ctx); - return 1; -} - - -static int LZ4IO_free (void* ptr) -{ - free(ptr); - return 0; -} - -static int compress_file_blockDependency(char* input_filename, char* output_filename, int compressionlevel) -{ - void* (*initFunction) (const char*); - int (*compressionFunction)(void*, const char*, char*, int, int, int); - int (*nextBlockFunction) (void*, char*, int); - int (*freeFunction) (void*); - void* ctx; - unsigned long long filesize = 0; - unsigned long long compressedfilesize = 0; - unsigned int checkbits; - char* in_buff, *in_blockStart; - char* out_buff; - FILE* finput; - FILE* foutput; - clock_t start, end; - unsigned int blockSize, inputBufferSize; - size_t sizeCheck, header_size; - XXH32_state_t streamCRC; - - // Init - start = clock(); - if ((displayLevel==2) && (compressionlevel>=3)) displayLevel=3; - - if (compressionlevel<3) - { - initFunction = LZ4IO_LZ4_createStream; - compressionFunction = LZ4IO_LZ4_compress_limitedOutput_continue; - nextBlockFunction = LZ4IO_LZ4_saveDict; - freeFunction = LZ4IO_free; - } - else - { - initFunction = LZ4_createHC; - compressionFunction = LZ4_compressHC2_limitedOutput_continue; - nextBlockFunction = LZ4IO_LZ4_slideInputBufferHC; - freeFunction = LZ4IO_free; - } - - get_fileHandle(input_filename, output_filename, &finput, &foutput); - blockSize = LZ4S_GetBlockSize_FromBlockId (globalBlockSizeId); - - // Allocate Memory - inputBufferSize = 64 KB + blockSize; - in_buff = (char*)malloc(inputBufferSize); - out_buff = (char*)malloc(blockSize+CACHELINE); - if (!in_buff || !out_buff) EXM_THROW(31, "Allocation error : not enough memory"); - in_blockStart = in_buff + 64 KB; - if (compressionlevel>=3) in_blockStart = in_buff; - if (streamChecksum) XXH32_reset(&streamCRC, LZ4S_CHECKSUM_SEED); - ctx = initFunction(in_buff); - - // Write Archive Header - *(unsigned int*)out_buff = LITTLE_ENDIAN_32(LZ4S_MAGICNUMBER); // Magic Number, in Little Endian convention - *(out_buff+4) = (1 & _2BITS) << 6 ; // Version('01') - *(out_buff+4) |= (blockIndependence & _1BIT) << 5; - *(out_buff+4) |= (blockChecksum & _1BIT) << 4; - *(out_buff+4) |= (streamChecksum & _1BIT) << 2; - *(out_buff+5) = (char)((globalBlockSizeId & _3BITS) << 4); - checkbits = XXH32((out_buff+4), 2, LZ4S_CHECKSUM_SEED); - checkbits = LZ4S_GetCheckBits_FromXXH(checkbits); - *(out_buff+6) = (unsigned char) checkbits; - header_size = 7; - sizeCheck = fwrite(out_buff, 1, header_size, foutput); - if (sizeCheck!=header_size) EXM_THROW(32, "Write error : cannot write header"); - compressedfilesize += header_size; - - // Main Loop - while (1) - { - unsigned int outSize; - unsigned int inSize; - - // Read Block - inSize = (unsigned int) fread(in_blockStart, (size_t)1, (size_t)blockSize, finput); - if( inSize==0 ) break; // No more input : end of compression - filesize += inSize; - DISPLAYLEVEL(3, "\rRead : %i MB ", (int)(filesize>>20)); - if (streamChecksum) XXH32_update(&streamCRC, in_blockStart, inSize); - - // Compress Block - outSize = compressionFunction(ctx, in_blockStart, out_buff+4, inSize, inSize-1, compressionlevel); - if (outSize > 0) compressedfilesize += outSize+4; else compressedfilesize += inSize+4; - if (blockChecksum) compressedfilesize+=4; - DISPLAYLEVEL(3, "==> %.2f%% ", (double)compressedfilesize/filesize*100); - - // Write Block - if (outSize > 0) - { - int sizeToWrite; - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(outSize); - if (blockChecksum) - { - unsigned int checksum = XXH32(out_buff+4, outSize, LZ4S_CHECKSUM_SEED); - * (unsigned int*) (out_buff+4+outSize) = LITTLE_ENDIAN_32(checksum); - } - sizeToWrite = 4 + outSize + (4*blockChecksum); - sizeCheck = fwrite(out_buff, 1, sizeToWrite, foutput); - if (sizeCheck!=(size_t)(sizeToWrite)) EXM_THROW(33, "Write error : cannot write compressed block"); - } - else // Copy Original - { - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(inSize|0x80000000); // Add Uncompressed flag - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(34, "Write error : cannot write block header"); - sizeCheck = fwrite(in_blockStart, 1, inSize, foutput); - if (sizeCheck!=(size_t)(inSize)) EXM_THROW(35, "Write error : cannot write block"); - if (blockChecksum) - { - unsigned int checksum = XXH32(in_blockStart, inSize, LZ4S_CHECKSUM_SEED); - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(checksum); - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(36, "Write error : cannot write block checksum"); - } - } - { - size_t sizeToMove = 64 KB; - if (inSize < 64 KB) sizeToMove = inSize; - nextBlockFunction(ctx, in_blockStart - sizeToMove, (int)sizeToMove); - if (compressionlevel>=3) in_blockStart = in_buff + 64 KB; - } - } - - // End of Stream mark - * (unsigned int*) out_buff = LZ4S_EOS; - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(37, "Write error : cannot write end of stream"); - compressedfilesize += 4; - if (streamChecksum) - { - unsigned int checksum = XXH32_digest(&streamCRC); - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(checksum); - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(37, "Write error : cannot write stream checksum"); - compressedfilesize += 4; - } - - // Status - end = clock(); - DISPLAYLEVEL(2, "\r%79s\r", ""); - DISPLAYLEVEL(2, "Compressed %llu bytes into %llu bytes ==> %.2f%%\n", - (unsigned long long) filesize, (unsigned long long) compressedfilesize, (double)compressedfilesize/filesize*100); - { - double seconds = (double)(end - start)/CLOCKS_PER_SEC; - DISPLAYLEVEL(4, "Done in %.2f s ==> %.2f MB/s\n", seconds, (double)filesize / seconds / 1024 / 1024); - } - - // Close & Free - freeFunction(ctx); - free(in_buff); - free(out_buff); - fclose(finput); - fclose(foutput); - - return 0; -} - - -static int LZ4_compress_limitedOutput_local(const char* src, char* dst, int size, int maxOut, int clevel) -{ (void)clevel; return LZ4_compress_limitedOutput(src, dst, size, maxOut); } +/*********************************************** + * Compression using Frame format + * ********************************************/ int LZ4IO_compressFilename(char* input_filename, char* output_filename, int compressionLevel) { - int (*compressionFunction)(const char*, char*, int, int, int); unsigned long long filesize = 0; unsigned long long compressedfilesize = 0; - unsigned int checkbits; char* in_buff; char* out_buff; - char* headerBuffer; FILE* finput; FILE* foutput; clock_t start, end; int blockSize; - size_t sizeCheck, header_size, readSize; - XXH32_state_t streamCRC; + size_t sizeCheck, headerSize, readSize, outBuffSize; + LZ4F_compressionContext_t ctx; + LZ4F_errorCode_t errorCode; + LZ4F_preferences_t prefs = {0}; - // Branch out - if (blockIndependence==0) return compress_file_blockDependency(input_filename, output_filename, compressionLevel); // Init start = clock(); if ((displayLevel==2) && (compressionLevel>=3)) displayLevel=3; - if (compressionLevel <= 3) compressionFunction = LZ4_compress_limitedOutput_local; - else { compressionFunction = LZ4_compressHC2_limitedOutput; } + errorCode = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION); + if (LZ4F_isError(errorCode)) EXM_THROW(30, "Allocation error : can't create LZ4F context : %s", LZ4F_getErrorName(errorCode)); get_fileHandle(input_filename, output_filename, &finput, &foutput); blockSize = LZ4S_GetBlockSize_FromBlockId (globalBlockSizeId); + // Set compression parameters + prefs.autoFlush = 1; + prefs.compressionLevel = compressionLevel; + prefs.frameInfo.blockMode = blockIndependence; + prefs.frameInfo.blockSizeID = globalBlockSizeId; + prefs.frameInfo.contentChecksumFlag = streamChecksum; + // Allocate Memory in_buff = (char*)malloc(blockSize); - out_buff = (char*)malloc(blockSize+CACHELINE); - headerBuffer = (char*)malloc(LZ4S_MAXHEADERSIZE); - if (!in_buff || !out_buff || !(headerBuffer)) EXM_THROW(31, "Allocation error : not enough memory"); - if (streamChecksum) XXH32_reset(&streamCRC, LZ4S_CHECKSUM_SEED); + outBuffSize = LZ4F_compressBound(blockSize, &prefs); + out_buff = (char*)malloc(outBuffSize); + if (!in_buff || !out_buff) EXM_THROW(31, "Allocation error : not enough memory"); // Write Archive Header - *(unsigned int*)headerBuffer = LITTLE_ENDIAN_32(LZ4S_MAGICNUMBER); // Magic Number, in Little Endian convention - *(headerBuffer+4) = (1 & _2BITS) << 6 ; // Version('01') - *(headerBuffer+4) |= (blockIndependence & _1BIT) << 5; - *(headerBuffer+4) |= (blockChecksum & _1BIT) << 4; - *(headerBuffer+4) |= (streamChecksum & _1BIT) << 2; - *(headerBuffer+5) = (char)((globalBlockSizeId & _3BITS) << 4); - checkbits = XXH32((headerBuffer+4), 2, LZ4S_CHECKSUM_SEED); - checkbits = LZ4S_GetCheckBits_FromXXH(checkbits); - *(headerBuffer+6) = (unsigned char) checkbits; - header_size = 7; - - // Write header - sizeCheck = fwrite(headerBuffer, 1, header_size, foutput); - if (sizeCheck!=header_size) EXM_THROW(32, "Write error : cannot write header"); - compressedfilesize += header_size; + headerSize = LZ4F_compressBegin(ctx, out_buff, outBuffSize, &prefs); + if (LZ4F_isError(headerSize)) EXM_THROW(32, "File header generation failed : %s", LZ4F_getErrorName(headerSize)); + sizeCheck = fwrite(out_buff, 1, headerSize, foutput); + if (sizeCheck!=headerSize) EXM_THROW(33, "Write error : cannot write header"); + compressedfilesize += headerSize; // read first block readSize = fread(in_buff, (size_t)1, (size_t)blockSize, finput); + filesize += readSize; // Main Loop while (readSize>0) { - unsigned int outSize; - - filesize += readSize; - DISPLAYLEVEL(3, "\rRead : %i MB ", (int)(filesize>>20)); - if (streamChecksum) XXH32_update(&streamCRC, in_buff, (int)readSize); + size_t outSize; // Compress Block - outSize = compressionFunction(in_buff, out_buff+4, (int)readSize, (int)readSize-1, compressionLevel); - if (outSize > 0) compressedfilesize += outSize+4; else compressedfilesize += readSize+4; - if (blockChecksum) compressedfilesize+=4; - DISPLAYLEVEL(3, "==> %.2f%% ", (double)compressedfilesize/filesize*100); + outSize = LZ4F_compressUpdate(ctx, out_buff, outBuffSize, in_buff, readSize, NULL); + if (LZ4F_isError(outSize)) EXM_THROW(34, "Compression failed : %s", LZ4F_getErrorName(outSize)); + compressedfilesize += outSize; + DISPLAYUPDATE(3, "\rRead : %i MB ==> %.2f%% ", (int)(filesize>>20), (double)compressedfilesize/filesize*100); // Write Block - if (outSize > 0) - { - int sizeToWrite; - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(outSize); - if (blockChecksum) - { - unsigned int checksum = XXH32(out_buff+4, outSize, LZ4S_CHECKSUM_SEED); - * (unsigned int*) (out_buff+4+outSize) = LITTLE_ENDIAN_32(checksum); - } - sizeToWrite = 4 + outSize + (4*blockChecksum); - sizeCheck = fwrite(out_buff, 1, sizeToWrite, foutput); - if (sizeCheck!=(size_t)(sizeToWrite)) EXM_THROW(33, "Write error : cannot write compressed block"); - } - else // Copy Original Uncompressed - { - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(((unsigned long)readSize)|0x80000000); // Add Uncompressed flag - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(34, "Write error : cannot write block header"); - sizeCheck = fwrite(in_buff, 1, readSize, foutput); - if (sizeCheck!=readSize) EXM_THROW(35, "Write error : cannot write block"); - if (blockChecksum) - { - unsigned int checksum = XXH32(in_buff, (int)readSize, LZ4S_CHECKSUM_SEED); - * (unsigned int*) out_buff = LITTLE_ENDIAN_32(checksum); - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(36, "Write error : cannot write block checksum"); - } - } + sizeCheck = fwrite(out_buff, 1, outSize, foutput); + if (sizeCheck!=outSize) EXM_THROW(35, "Write error : cannot write compressed block"); // Read next block readSize = fread(in_buff, (size_t)1, (size_t)blockSize, finput); + filesize += readSize; } // End of Stream mark - * (unsigned int*) out_buff = LZ4S_EOS; - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(37, "Write error : cannot write end of stream"); - compressedfilesize += 4; - if (streamChecksum) - { - unsigned int checksum = XXH32_digest(&streamCRC); - *(unsigned int*) out_buff = LITTLE_ENDIAN_32(checksum); - sizeCheck = fwrite(out_buff, 1, 4, foutput); - if (sizeCheck!=(size_t)(4)) EXM_THROW(37, "Write error : cannot write stream checksum"); - compressedfilesize += 4; - } + headerSize = LZ4F_compressEnd(ctx, out_buff, outBuffSize, NULL); + if (LZ4F_isError(headerSize)) EXM_THROW(36, "End of file generation failed : %s", LZ4F_getErrorName(headerSize)); + + sizeCheck = fwrite(out_buff, 1, headerSize, foutput); + if (sizeCheck!=headerSize) EXM_THROW(37, "Write error : cannot write end of stream"); + compressedfilesize += headerSize; // Close & Free free(in_buff); free(out_buff); - free(headerBuffer); fclose(finput); fclose(foutput); + errorCode = LZ4F_freeCompressionContext(ctx); + if (LZ4F_isError(errorCode)) EXM_THROW(38, "Error : can't free LZ4F context resource : %s", LZ4F_getErrorName(errorCode)); // Final Status end = clock(); @@ -687,6 +466,16 @@ int LZ4IO_compressFilename(char* input_filename, char* output_filename, int comp /* ********************** LZ4 File / Stream decoding ******************* */ /* ********************************************************************* */ +static unsigned LZ4IO_readLE32 (const void* s) +{ + const unsigned char* srcPtr = s; + unsigned value32 = srcPtr[0]; + value32 += (srcPtr[1]<<8); + value32 += (srcPtr[2]<<16); + value32 += (srcPtr[3]<<24); + return value32; +} + static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput) { unsigned long long filesize = 0; @@ -694,7 +483,6 @@ static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput) char* out_buff; unsigned int blockSize; - // Allocate Memory in_buff = (char*)malloc(LZ4_compressBound(LEGACY_BLOCKSIZE)); out_buff = (char*)malloc(LEGACY_BLOCKSIZE); @@ -707,9 +495,9 @@ static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput) size_t sizeCheck; // Block Size - sizeCheck = fread(&blockSize, 1, 4, finput); + sizeCheck = fread(in_buff, 1, 4, finput); if (sizeCheck==0) break; // Nothing to read : file read is completed - blockSize = LITTLE_ENDIAN_32(blockSize); // Convert to Little Endian + blockSize = LZ4IO_readLE32(in_buff); // Convert to Little Endian if (blockSize > LZ4_COMPRESSBOUND(LEGACY_BLOCKSIZE)) { // Cannot read next block : maybe new stream ? fseek(finput, -4, SEEK_CUR); @@ -740,142 +528,64 @@ static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput) static unsigned long long decodeLZ4S(FILE* finput, FILE* foutput) { unsigned long long filesize = 0; - char* in_buff; - char* out_buff, *out_start, *out_end; - unsigned char descriptor[LZ4S_MAXHEADERSIZE]; - size_t nbReadBytes; - int decodedBytes=0; - unsigned int maxBlockSize; - size_t sizeCheck; - int blockChecksumFlag, streamChecksumFlag, blockIndependenceFlag; - XXH32_state_t streamCRC; - int (*decompressionFunction)(LZ4_streamDecode_t* ctx, const char* src, char* dst, int cSize, int maxOSize) = LZ4_decompress_safe_continue; - LZ4_streamDecode_t ctx; + char* inBuff; + char* outBuff; +# define HEADERMAX 20 + char headerBuff[HEADERMAX]; + size_t sizeCheck, nextToRead, outBuffSize, inBuffSize; + LZ4F_decompressionContext_t ctx; + LZ4F_errorCode_t errorCode; + LZ4F_frameInfo_t frameInfo; // init - memset(&ctx, 0, sizeof(ctx)); + errorCode = LZ4F_createDecompressionContext(&ctx, LZ4F_VERSION); + if (LZ4F_isError(errorCode)) EXM_THROW(60, "Allocation error : can't create context : %s", LZ4F_getErrorName(errorCode)); + LZ4IO_writeLE32(headerBuff, LZ4S_MAGICNUMBER); /* regenerated here, as it was already read from finput */ // Decode stream descriptor - nbReadBytes = fread(descriptor, 1, 3, finput); - if (nbReadBytes != 3) EXM_THROW(61, "Unreadable header"); - { - int version = (descriptor[0] >> 6) & _2BITS; - int streamSize = (descriptor[0] >> 3) & _1BIT; - int reserved1 = (descriptor[0] >> 1) & _1BIT; - int dictionary = (descriptor[0] >> 0) & _1BIT; - - int reserved2 = (descriptor[1] >> 7) & _1BIT; - int blockSizeId = (descriptor[1] >> 4) & _3BITS; - int reserved3 = (descriptor[1] >> 0) & _4BITS; - int checkBits = (descriptor[2] >> 0) & _8BITS; - int checkBits_xxh32; - - blockIndependenceFlag=(descriptor[0] >> 5) & _1BIT; - blockChecksumFlag = (descriptor[0] >> 4) & _1BIT; - streamChecksumFlag= (descriptor[0] >> 2) & _1BIT; - - if (version != 1) EXM_THROW(62, "Wrong version number"); - if (streamSize == 1) EXM_THROW(64, "Does not support stream size"); - if (reserved1 != 0) EXM_THROW(65, "Wrong value for reserved bits"); - if (dictionary == 1) EXM_THROW(66, "Does not support dictionary"); - if (reserved2 != 0) EXM_THROW(67, "Wrong value for reserved bits"); - if (blockSizeId < 4) EXM_THROW(68, "Unsupported block size"); - if (reserved3 != 0) EXM_THROW(67, "Wrong value for reserved bits"); - maxBlockSize = LZ4S_GetBlockSize_FromBlockId(blockSizeId); - // Checkbits verification - descriptor[1] &= 0xF0; - checkBits_xxh32 = XXH32(descriptor, 2, LZ4S_CHECKSUM_SEED); - checkBits_xxh32 = LZ4S_GetCheckBits_FromXXH(checkBits_xxh32); - if (checkBits != checkBits_xxh32) EXM_THROW(69, "Stream descriptor error detected"); - } + outBuffSize = 0; inBuffSize = 0; sizeCheck = MAGICNUMBER_SIZE; + nextToRead = LZ4F_decompress(ctx, NULL, &outBuffSize, headerBuff, &sizeCheck, NULL); + if (LZ4F_isError(nextToRead)) EXM_THROW(61, "Decompression error : %s", LZ4F_getErrorName(nextToRead)); + if (nextToRead > HEADERMAX) EXM_THROW(62, "Header too large (%i>%i)", (int)nextToRead, HEADERMAX); + sizeCheck = fread(headerBuff, 1, nextToRead, finput); + if (sizeCheck!=nextToRead) EXM_THROW(63, "Read error "); + nextToRead = LZ4F_decompress(ctx, NULL, &outBuffSize, headerBuff, &sizeCheck, NULL); + errorCode = LZ4F_getFrameInfo(ctx, &frameInfo, NULL, &inBuffSize); + if (LZ4F_isError(errorCode)) EXM_THROW(64, "can't decode frame header : %s", LZ4F_getErrorName(errorCode)); // Allocate Memory - { - size_t outBuffSize = maxBlockSize + 64 KB; - if (outBuffSize < MIN_STREAM_BUFSIZE) outBuffSize = MIN_STREAM_BUFSIZE; - in_buff = (char*)malloc(maxBlockSize); - out_buff = (char*)malloc(outBuffSize); - out_start = out_buff; - out_end = out_start + outBuffSize; - if (!in_buff || !out_buff) EXM_THROW(70, "Allocation error : not enough memory"); - if (streamChecksumFlag) XXH32_reset(&streamCRC, LZ4S_CHECKSUM_SEED); - } + outBuffSize = LZ4IO_setBlockSizeID(frameInfo.blockSizeID); + inBuffSize = outBuffSize + 4; + inBuff = (char*)malloc(inBuffSize); + outBuff = (char*)malloc(outBuffSize); + if (!inBuff || !outBuff) EXM_THROW(65, "Allocation error : not enough memory"); // Main Loop - while (1) + while (nextToRead != 0) { - unsigned int blockSize, uncompressedFlag; - - // Block Size - nbReadBytes = fread(&blockSize, 1, 4, finput); - if( nbReadBytes != 4 ) EXM_THROW(71, "Read error : cannot read next block size"); - if (blockSize == LZ4S_EOS) break; // End of Stream Mark : stream is completed - blockSize = LITTLE_ENDIAN_32(blockSize); // Convert to little endian - uncompressedFlag = blockSize >> 31; - blockSize &= 0x7FFFFFFF; - if (blockSize > maxBlockSize) EXM_THROW(72, "Error : invalid block size"); + size_t decodedBytes = outBuffSize; // Read Block - nbReadBytes = fread(in_buff, 1, blockSize, finput); - if( nbReadBytes != blockSize ) EXM_THROW(73, "Read error : cannot read data block" ); + sizeCheck = fread(inBuff, 1, nextToRead, finput); + if (sizeCheck!=nextToRead) EXM_THROW(66, "Read error "); - // Check Block - if (blockChecksumFlag) - { - unsigned int checksum = XXH32(in_buff, blockSize, LZ4S_CHECKSUM_SEED); - unsigned int readChecksum; - sizeCheck = fread(&readChecksum, 1, 4, finput); - if( sizeCheck != 4 ) EXM_THROW(74, "Read error : cannot read next block size"); - readChecksum = LITTLE_ENDIAN_32(readChecksum); // Convert to little endian - if (checksum != readChecksum) EXM_THROW(75, "Error : invalid block checksum detected"); - } + // Decode Block + errorCode = LZ4F_decompress(ctx, outBuff, &decodedBytes, inBuff, &sizeCheck, NULL); + if (LZ4F_isError(errorCode)) EXM_THROW(67, "Decompression error : %s", LZ4F_getErrorName(errorCode)); + if (sizeCheck!=nextToRead) EXM_THROW(67, "Synchronization error"); + nextToRead = errorCode; + filesize += decodedBytes; - if (uncompressedFlag) - { - // Write uncompressed Block - sizeCheck = fwrite(in_buff, 1, blockSize, foutput); - if (sizeCheck != (size_t)blockSize) EXM_THROW(76, "Write error : cannot write data block"); - filesize += blockSize; - if (streamChecksumFlag) XXH32_update(&streamCRC, in_buff, blockSize); - if (!blockIndependenceFlag) - { - // handle dictionary for streaming - memcpy(in_buff + blockSize - 64 KB, out_buff, 64 KB); - LZ4_setStreamDecode(&ctx, out_buff, 64 KB); - out_start = out_buff + 64 KB; - } - } - else - { - // Decode Block - if (out_start + maxBlockSize > out_end) out_start = out_buff; - decodedBytes = decompressionFunction(&ctx, in_buff, out_start, blockSize, maxBlockSize); - if (decodedBytes < 0) EXM_THROW(77, "Decoding Failed ! Corrupted input detected !"); - filesize += decodedBytes; - if (streamChecksumFlag) XXH32_update(&streamCRC, out_start, decodedBytes); - - // Write Block - sizeCheck = fwrite(out_start, 1, decodedBytes, foutput); - if (sizeCheck != (size_t)decodedBytes) EXM_THROW(78, "Write error : cannot write decoded block\n"); - out_start += decodedBytes; - } - - } - - // Stream Checksum - if (streamChecksumFlag) - { - unsigned int checksum = XXH32_digest(&streamCRC); - unsigned int readChecksum; - sizeCheck = fread(&readChecksum, 1, 4, finput); - if (sizeCheck != 4) EXM_THROW(74, "Read error : cannot read stream checksum"); - readChecksum = LITTLE_ENDIAN_32(readChecksum); // Convert to little endian - if (checksum != readChecksum) EXM_THROW(79, "Error : invalid stream checksum detected"); + // Write Block + sizeCheck = fwrite(outBuff, 1, decodedBytes, foutput); + if (sizeCheck != decodedBytes) EXM_THROW(68, "Write error : cannot write decoded block\n"); } // Free - free(in_buff); - free(out_buff); + free(inBuff); + free(outBuff); + errorCode = LZ4F_freeDecompressionContext(ctx); + if (LZ4F_isError(errorCode)) EXM_THROW(69, "Error : can't free LZ4F context resource : %s", LZ4F_getErrorName(errorCode)); return filesize; } @@ -884,15 +594,16 @@ static unsigned long long decodeLZ4S(FILE* finput, FILE* foutput) #define ENDOFSTREAM ((unsigned long long)-1) static unsigned long long selectDecoder( FILE* finput, FILE* foutput) { - unsigned int magicNumber, size; + unsigned char U32store[MAGICNUMBER_SIZE]; + unsigned magicNumber, size; int errorNb; size_t nbReadBytes; // Check Archive Header - nbReadBytes = fread(&magicNumber, 1, MAGICNUMBER_SIZE, finput); + nbReadBytes = fread(U32store, 1, MAGICNUMBER_SIZE, finput); if (nbReadBytes==0) return ENDOFSTREAM; // EOF - if (nbReadBytes != MAGICNUMBER_SIZE) EXM_THROW(41, "Unrecognized header : Magic Number unreadable"); - magicNumber = LITTLE_ENDIAN_32(magicNumber); // Convert to Little Endian format + if (nbReadBytes != MAGICNUMBER_SIZE) EXM_THROW(40, "Unrecognized header : Magic Number unreadable"); + magicNumber = LZ4IO_readLE32(U32store); // Convert to Little Endian format if (LZ4S_isSkippableMagicNumber(magicNumber)) magicNumber = LZ4S_SKIPPABLE0; // fold skippable magic numbers switch(magicNumber) @@ -904,9 +615,9 @@ static unsigned long long selectDecoder( FILE* finput, FILE* foutput) return decodeLegacyStream(finput, foutput); case LZ4S_SKIPPABLE0: DISPLAYLEVEL(4, "Skipping detected skippable area \n"); - nbReadBytes = fread(&size, 1, 4, finput); + nbReadBytes = fread(U32store, 1, 4, finput); if (nbReadBytes != 4) EXM_THROW(42, "Stream error : skippable size unreadable"); - size = LITTLE_ENDIAN_32(size); // Convert to Little Endian format + size = LZ4IO_readLE32(U32store); // Convert to Little Endian format errorNb = fseek(finput, size, SEEK_CUR); if (errorNb != 0) EXM_THROW(43, "Stream error : cannot skip skippable area"); return selectDecoder(finput, foutput); diff --git a/programs/lz4io.h b/programs/lz4io.h index 9c3b217..7869a43 100644 --- a/programs/lz4io.h +++ b/programs/lz4io.h @@ -64,8 +64,8 @@ int LZ4IO_setOverwrite(int yes); int LZ4IO_setBlockSizeID(int blockSizeID); /* Default setting : independent blocks */ -typedef enum { chainedBlocks, independentBlocks } blockMode_t; -int LZ4IO_setBlockMode(blockMode_t blockMode); +typedef enum { LZ4IO_blockLinked=0, LZ4IO_blockIndependent} LZ4IO_blockMode_t; +int LZ4IO_setBlockMode(LZ4IO_blockMode_t blockMode); /* Default setting : no checksum */ int LZ4IO_setBlockChecksumMode(int xxhash); From 80030c16fff7a8a5dae18cf2b1ab5da508137847 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 30 Nov 2014 18:04:32 +0100 Subject: [PATCH 12/22] Update cmakelist to support new lz4io version --- cmake_unofficial/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmake_unofficial/CMakeLists.txt b/cmake_unofficial/CMakeLists.txt index 1d70590..38d10b1 100644 --- a/cmake_unofficial/CMakeLists.txt +++ b/cmake_unofficial/CMakeLists.txt @@ -2,7 +2,7 @@ PROJECT(LZ4 C) set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "LZ4 compression library") set(CPACK_PACKAGE_VERSION_MAJOR 1) set(CPACK_PACKAGE_VERSION_MINOR 4) -set(CPACK_PACKAGE_VERSION_PATCH r124) +set(CPACK_PACKAGE_VERSION_PATCH r125) set(VERSION_STRING " \"${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}\" ") include(CPack) @@ -26,7 +26,7 @@ endif() set(LZ4_DIR ../) set(PRG_DIR ../programs/) set(LZ4_SRCS_LIB ${LZ4_DIR}lz4.c ${LZ4_DIR}lz4hc.c ${LZ4_DIR}lz4.h ${LZ4_DIR}lz4hc.h) -set(LZ4_SRCS ${LZ4_DIR}xxhash.c ${PRG_DIR}bench.c ${PRG_DIR}lz4cli.c ${PRG_DIR}lz4io.c) +set(LZ4_SRCS ${LZ4_DIR}lz4frame.c ${LZ4_DIR}xxhash.c ${PRG_DIR}bench.c ${PRG_DIR}lz4cli.c ${PRG_DIR}lz4io.c) if(BUILD_TOOLS AND NOT BUILD_LIBS) set(LZ4_SRCS ${LZ4_SRCS} ${LZ4_SRCS_LIB}) From d008c87151abf8c36a9f98d28461bf6f3dfdc6ae Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 30 Nov 2014 23:32:12 +0100 Subject: [PATCH 13/22] New directory structure : library source files into /lib directory --- .travis.yml | 2 +- Makefile | 77 ++++----------------- NEWS | 2 + cmake_unofficial/CMakeLists.txt | 2 +- examples/Makefile | 4 +- LICENSE => lib/LICENSE | 0 lib/Makefile | 118 ++++++++++++++++++++++++++++++++ lib/liblz4.pc | 14 ++++ lib/liblz4.pc.in | 14 ++++ lib/liblz4.so | 1 + lib/liblz4.so.1 | 1 + lib/liblz4.so.1.4.1 | Bin 0 -> 68571 bytes lz4.c => lib/lz4.c | 0 lz4.h => lib/lz4.h | 0 lib/lz4.o | Bin 0 -> 47472 bytes lz4frame.c => lib/lz4frame.c | 0 lz4frame.h => lib/lz4frame.h | 0 lz4hc.c => lib/lz4hc.c | 0 lz4hc.h => lib/lz4hc.h | 0 lib/lz4hc.o | Bin 0 -> 15888 bytes xxhash.c => lib/xxhash.c | 0 xxhash.h => lib/xxhash.h | 0 programs/Makefile | 4 +- programs/lz4cli.c | 6 +- 24 files changed, 173 insertions(+), 72 deletions(-) rename LICENSE => lib/LICENSE (100%) create mode 100644 lib/Makefile create mode 100644 lib/liblz4.pc create mode 100644 lib/liblz4.pc.in create mode 120000 lib/liblz4.so create mode 120000 lib/liblz4.so.1 create mode 100755 lib/liblz4.so.1.4.1 rename lz4.c => lib/lz4.c (100%) rename lz4.h => lib/lz4.h (100%) create mode 100644 lib/lz4.o rename lz4frame.c => lib/lz4frame.c (100%) rename lz4frame.h => lib/lz4frame.h (100%) rename lz4hc.c => lib/lz4hc.c (100%) rename lz4hc.h => lib/lz4hc.h (100%) create mode 100644 lib/lz4hc.o rename xxhash.c => lib/xxhash.c (100%) rename xxhash.h => lib/xxhash.h (100%) diff --git a/.travis.yml b/.travis.yml index 67bde9b..a8866a1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,7 +7,7 @@ before_install: - sudo apt-get install -qq valgrind env: - - LZ4_TRAVIS_CI_ENV=liblz4 + - LZ4_TRAVIS_CI_ENV=install - LZ4_TRAVIS_CI_ENV=streaming-examples - LZ4_TRAVIS_CI_ENV=cmake - LZ4_TRAVIS_CI_ENV=dist diff --git a/Makefile b/Makefile index c2bbd57..60f8ce1 100644 --- a/Makefile +++ b/Makefile @@ -33,10 +33,6 @@ # Version numbers VERSION=125 export RELEASE=r$(VERSION) -LIBVER_MAJOR=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` -LIBVER_MINOR=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` -LIBVER_PATCH=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` -LIBVER=$(LIBVER_MAJOR).$(LIBVER_MINOR).$(LIBVER_PATCH) DESTDIR?= PREFIX ?= /usr @@ -47,27 +43,13 @@ CFLAGS += -I. -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prot LIBDIR?= $(PREFIX)/lib INCLUDEDIR=$(PREFIX)/include PRGDIR = programs +LZ4DIR = lib DISTRIBNAME=lz4-$(RELEASE).tar.gz - -# OS X linker doesn't support -soname, and use different extension -# see : https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html -ifeq ($(shell uname), Darwin) - SHARED_EXT = dylib - SHARED_EXT_MAJOR = $(LIBVER_MAJOR).$(SHARED_EXT) - SHARED_EXT_VER = $(LIBVER).$(SHARED_EXT) - SONAME_FLAGS = -install_name $(PREFIX)/lib/liblz4.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER) -else - SONAME_FLAGS = -Wl,-soname=liblz4.$(SHARED_EXT).$(LIBVER_MAJOR) - SHARED_EXT = so - SHARED_EXT_MAJOR = $(SHARED_EXT).$(LIBVER_MAJOR) - SHARED_EXT_VER = $(SHARED_EXT).$(LIBVER) -endif - -TEXT = lz4.c lz4.h lz4hc.c lz4hc.h \ - lz4frame.c lz4frame.h xxhash.c xxhash.h \ - liblz4.pc.in Makefile \ - lz4_format_description.txt NEWS LICENSE README.md \ +TEXT = $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4.h $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4hc.h \ + $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4frame.h $(LZ4DIR)/xxhash.c $(LZ4DIR)/xxhash.h \ + $(LZ4DIR)/liblz4.pc.in $(LZ4DIR)/Makefile $(LZ4DIR)/LICENSE \ + Makefile lz4_format_description.txt NEWS README.md \ cmake_unofficial/CMakeLists.txt \ $(PRGDIR)/fullbench.c $(PRGDIR)/lz4cli.c \ $(PRGDIR)/datagen.c $(PRGDIR)/fuzzer.c \ @@ -90,27 +72,18 @@ TRAVIS_TARGET=$(LZ4_TRAVIS_CI_ENV) endif -default: liblz4 +default: lz4programs @cd $(PRGDIR); $(MAKE) -e -all: liblz4 lz4programs +all: lz4programs -lz4programs: lz4.c lz4hc.c +lz4programs: @cd $(PRGDIR); $(MAKE) -e all -liblz4: lz4.c lz4hc.c - @echo compiling static library - @$(CC) $(CPPFLAGS) $(CFLAGS) -c $^ - @$(AR) rcs liblz4.a lz4.o lz4hc.o - @echo compiling dynamic library $(LIBVER) - @$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -shared $^ -fPIC $(SONAME_FLAGS) -o $@.$(SHARED_EXT_VER) - @echo creating versioned links - @ln -sf $@.$(SHARED_EXT_VER) $@.$(SHARED_EXT_MAJOR) - @ln -sf $@.$(SHARED_EXT_VER) $@.$(SHARED_EXT) - clean: - @rm -f core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* $(DISTRIBNAME) *.sha1 liblz4.pc + @rm -f $(DISTRIBNAME) *.sha1 @cd $(PRGDIR); $(MAKE) clean + @cd $(LZ4DIR); $(MAKE) clean @cd examples; $(MAKE) clean @echo Cleaning completed @@ -119,38 +92,16 @@ clean: #make install is validated only for Linux, OSX, kFreeBSD and Hurd targets ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU)) -liblz4.pc: liblz4.pc.in Makefile - @echo creating pkgconfig - @sed -e 's|@PREFIX@|$(PREFIX)|' \ - -e 's|@LIBDIR@|$(LIBDIR)|' \ - -e 's|@INCLUDEDIR@|$(INCLUDEDIR)|' \ - -e 's|@VERSION@|$(VERSION)|' \ - $< >$@ - -install: liblz4 liblz4.pc - @install -d -m 755 $(DESTDIR)$(LIBDIR)/pkgconfig/ $(DESTDIR)$(INCLUDEDIR)/ - @install -m 755 liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) - @cp -a liblz4.$(SHARED_EXT_MAJOR) $(DESTDIR)$(LIBDIR) - @cp -a liblz4.$(SHARED_EXT) $(DESTDIR)$(LIBDIR) - @cp -a liblz4.pc $(DESTDIR)$(LIBDIR)/pkgconfig/ - @install -m 644 liblz4.a $(DESTDIR)$(LIBDIR)/liblz4.a - @install -m 644 lz4.h $(DESTDIR)$(INCLUDEDIR)/lz4.h - @install -m 644 lz4hc.h $(DESTDIR)$(INCLUDEDIR)/lz4hc.h - @echo lz4 static and shared library installed +install: + @cd $(LZ4DIR); $(MAKE) -e install @cd $(PRGDIR); $(MAKE) -e install uninstall: - rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT) - rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR) - rm -f $(DESTDIR)$(LIBDIR)/pkgconfig/liblz4.pc - [ -x $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) ] && rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) - [ -f $(DESTDIR)$(LIBDIR)/liblz4.a ] && rm -f $(DESTDIR)$(LIBDIR)/liblz4.a - [ -f $(DESTDIR)$(INCLUDEDIR)/lz4.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4.h - [ -f $(DESTDIR)$(INCLUDEDIR)/lz4hc.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4hc.h - @echo lz4 libraries successfully uninstalled + @cd $(LZ4DIR); $(MAKE) uninstall @cd $(PRGDIR); $(MAKE) uninstall dist: clean + @install -dD -m 700 lz4-$(RELEASE)/lib/ @install -dD -m 700 lz4-$(RELEASE)/programs/ @install -dD -m 700 lz4-$(RELEASE)/cmake_unofficial/ @install -dD -m 700 lz4-$(RELEASE)/images/ diff --git a/NEWS b/NEWS index 763fa5a..f49535d 100644 --- a/NEWS +++ b/NEWS @@ -1,5 +1,7 @@ r125: Changed : endian and alignment code +Changed : directory structure : new "lib" directory +Updated : lz4io, now uses lz4frame Fixed : some alignment warnings under clang r124: diff --git a/cmake_unofficial/CMakeLists.txt b/cmake_unofficial/CMakeLists.txt index 38d10b1..cacaca1 100644 --- a/cmake_unofficial/CMakeLists.txt +++ b/cmake_unofficial/CMakeLists.txt @@ -23,7 +23,7 @@ if(UNIX AND BUILD_LIBS) endif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64") endif() -set(LZ4_DIR ../) +set(LZ4_DIR ../lib/) set(PRG_DIR ../programs/) set(LZ4_SRCS_LIB ${LZ4_DIR}lz4.c ${LZ4_DIR}lz4hc.c ${LZ4_DIR}lz4.h ${LZ4_DIR}lz4hc.h) set(LZ4_SRCS ${LZ4_DIR}lz4frame.c ${LZ4_DIR}xxhash.c ${PRG_DIR}bench.c ${PRG_DIR}lz4cli.c ${PRG_DIR}lz4io.c) diff --git a/examples/Makefile b/examples/Makefile index df24ea9..0c4cf13 100644 --- a/examples/Makefile +++ b/examples/Makefile @@ -33,10 +33,10 @@ CC := $(CC) CFLAGS ?= -O3 CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -Wno-missing-braces # Wno-missing-braces required due to GCC <4.8.3 bug -FLAGS = -I.. $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) +FLAGS = -I../lib $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) TESTFILE= Makefile -LZ4DIR=.. +LZ4DIR = ../lib # Minimize test target for Travis CI's Build Matrix diff --git a/LICENSE b/lib/LICENSE similarity index 100% rename from LICENSE rename to lib/LICENSE diff --git a/lib/Makefile b/lib/Makefile new file mode 100644 index 0000000..f2d585f --- /dev/null +++ b/lib/Makefile @@ -0,0 +1,118 @@ +# ################################################################ +# LZ4 library - Makefile +# Copyright (C) Yann Collet 2011-2014 +# All rights reserved. +# +# BSD license +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, this +# list of conditions and the following disclaimer in the documentation and/or +# other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# You can contact the author at : +# - LZ4 source repository : http://code.google.com/p/lz4/ +# - LZ4 source mirror : https://github.com/Cyan4973/lz4 +# - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c +# ################################################################ + +# Version numbers +RELEASE=r125 +LIBVER_MAJOR=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` +LIBVER_MINOR=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` +LIBVER_PATCH=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h` +LIBVER=$(LIBVER_MAJOR).$(LIBVER_MINOR).$(LIBVER_PATCH) + +DESTDIR?= +PREFIX ?= /usr +CC := $(CC) +CFLAGS ?= -O3 +CFLAGS += -I. -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -DLZ4_VERSION=\"$(RELEASE)\" + +LIBDIR?= $(PREFIX)/lib +INCLUDEDIR=$(PREFIX)/include + + +# OS X linker doesn't support -soname, and use different extension +# see : https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html +ifeq ($(shell uname), Darwin) + SHARED_EXT = dylib + SHARED_EXT_MAJOR = $(LIBVER_MAJOR).$(SHARED_EXT) + SHARED_EXT_VER = $(LIBVER).$(SHARED_EXT) + SONAME_FLAGS = -install_name $(PREFIX)/lib/liblz4.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER) +else + SONAME_FLAGS = -Wl,-soname=liblz4.$(SHARED_EXT).$(LIBVER_MAJOR) + SHARED_EXT = so + SHARED_EXT_MAJOR = $(SHARED_EXT).$(LIBVER_MAJOR) + SHARED_EXT_VER = $(SHARED_EXT).$(LIBVER) +endif + +default: liblz4 + @cd $(PRGDIR); $(MAKE) -e + +all: liblz4 + +liblz4: lz4.c lz4hc.c + @echo compiling static library + @$(CC) $(CPPFLAGS) $(CFLAGS) -c $^ + @$(AR) rcs liblz4.a lz4.o lz4hc.o + @echo compiling dynamic library $(LIBVER) + @$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -shared $^ -fPIC $(SONAME_FLAGS) -o $@.$(SHARED_EXT_VER) + @echo creating versioned links + @ln -sf $@.$(SHARED_EXT_VER) $@.$(SHARED_EXT_MAJOR) + @ln -sf $@.$(SHARED_EXT_VER) $@.$(SHARED_EXT) + +clean: + @rm -f core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* liblz4.pc + @echo Cleaning library completed + + +#------------------------------------------------------------------------ +#make install is validated only for Linux, OSX, kFreeBSD and Hurd targets +ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU)) + +liblz4.pc: liblz4.pc.in Makefile + @echo creating pkgconfig + @sed -e 's|@PREFIX@|$(PREFIX)|' \ + -e 's|@LIBDIR@|$(LIBDIR)|' \ + -e 's|@INCLUDEDIR@|$(INCLUDEDIR)|' \ + -e 's|@VERSION@|$(VERSION)|' \ + $< >$@ + +install: liblz4 liblz4.pc + @install -d -m 755 $(DESTDIR)$(LIBDIR)/pkgconfig/ $(DESTDIR)$(INCLUDEDIR)/ + @install -m 755 liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) + @cp -a liblz4.$(SHARED_EXT_MAJOR) $(DESTDIR)$(LIBDIR) + @cp -a liblz4.$(SHARED_EXT) $(DESTDIR)$(LIBDIR) + @cp -a liblz4.pc $(DESTDIR)$(LIBDIR)/pkgconfig/ + @install -m 644 liblz4.a $(DESTDIR)$(LIBDIR)/liblz4.a + @install -m 644 lz4.h $(DESTDIR)$(INCLUDEDIR)/lz4.h + @install -m 644 lz4hc.h $(DESTDIR)$(INCLUDEDIR)/lz4hc.h + @echo lz4 static and shared library installed + +uninstall: + @rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT) + @rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR) + @rm -f $(DESTDIR)$(LIBDIR)/pkgconfig/liblz4.pc + @[ -x $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) ] && rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) + @[ -f $(DESTDIR)$(LIBDIR)/liblz4.a ] && rm -f $(DESTDIR)$(LIBDIR)/liblz4.a + @[ -f $(DESTDIR)$(INCLUDEDIR)/lz4.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4.h + @[ -f $(DESTDIR)$(INCLUDEDIR)/lz4hc.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4hc.h + @echo lz4 libraries successfully uninstalled + +endif diff --git a/lib/liblz4.pc b/lib/liblz4.pc new file mode 100644 index 0000000..39983ba --- /dev/null +++ b/lib/liblz4.pc @@ -0,0 +1,14 @@ +# LZ4 - Fast LZ compression algorithm +# Copyright (C) 2011-2014, Yann Collet. +# BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + +prefix=/usr +libdir=/usr/lib +includedir=/usr/include + +Name: lz4 +Description: fast lossless compression algorithm library +URL: http://code.google.com/p/lz4/ +Version: +Libs: -L/usr/lib -llz4 +Cflags: -I/usr/include diff --git a/lib/liblz4.pc.in b/lib/liblz4.pc.in new file mode 100644 index 0000000..0d05152 --- /dev/null +++ b/lib/liblz4.pc.in @@ -0,0 +1,14 @@ +# LZ4 - Fast LZ compression algorithm +# Copyright (C) 2011-2014, Yann Collet. +# BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + +prefix=@PREFIX@ +libdir=@LIBDIR@ +includedir=@INCLUDEDIR@ + +Name: lz4 +Description: fast lossless compression algorithm library +URL: http://code.google.com/p/lz4/ +Version: @VERSION@ +Libs: -L@LIBDIR@ -llz4 +Cflags: -I@INCLUDEDIR@ diff --git a/lib/liblz4.so b/lib/liblz4.so new file mode 120000 index 0000000..3c57595 --- /dev/null +++ b/lib/liblz4.so @@ -0,0 +1 @@ +liblz4.so.1.4.1 \ No newline at end of file diff --git a/lib/liblz4.so.1 b/lib/liblz4.so.1 new file mode 120000 index 0000000..3c57595 --- /dev/null +++ b/lib/liblz4.so.1 @@ -0,0 +1 @@ +liblz4.so.1.4.1 \ No newline at end of file diff --git a/lib/liblz4.so.1.4.1 b/lib/liblz4.so.1.4.1 new file mode 100755 index 0000000000000000000000000000000000000000..6ff6fcf46169369c6f1c4cc577e222d06cc7d7a1 GIT binary patch literal 68571 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 PN&o z4|a$Fuv3f0cZlKfW$_(icB0k_j4xPJW$j0>i72q4BfO2-&?&y`r0RmJ9l<5E4>eg} zvdI}kG5}K++V&(zbM1}Z-h@F6vpGD2G?TfE>C&_x0piPW$XR^vEWf)u=0`_-**gjG zW$(n=hcB_KSfJKwb||{7Lxh<%Vg%7{B{y)uHwfzxcBt#5Fe&960r(`;U?6i&1G zw2lF(lQ$@MkJD`atQJP&p&hTWYwQ4Ecc;Q*#GI-4Wv*2GvQ^~FkxJ1(TgZ+21u7AD z=l>V(sPhXF{rUAoWG<-q{smJ}Cf~onoQ^}N6VA&pe`3FXHK)LKUSSbi2{DVGgOgEk zrZu$+QslICj8OCggm>YnlT5tCH=w&?zI}hWB6hwI_E%?n*3Dwu)xC*_p+AAT@w4GyOn zrx}y5AP(|x7HNOs{CY&C0rXrnmhU-jRpKJ9tIOxwCs(=as;S@Vx?L#E{Gd@ck zs%V|BcER%$FGf8y1KIUHQ1N|spyEf!FyTPOSF8gSU$o9xJC|^v;xot#0TycFfr|G4 z1di@^*DaxyMp~Z2gV(ipJ9V!)_rnq1C{=pG) z;}}DTc7Eh7^&>TSC|}Q2Bt*+Wb;1YInTnrKE|R;y+(7QG_?c;cg}IH#=WH5F7_1+^ zV?LIH@pBG5^E~rC-}5Xm8=Z#~-Xbq8SAMAq4pF(;Hi(lOHBO$JO~h*Qe%oh^D@dUQ-|d*)eB6 zag<{Fo3y3P|Fd%x&ydVbJV)_XB4DrohDo?Ez4%{D|BRpiBZhlE8}2xb*LK2jOn*!q z?_S8&EH>!VAF>8LJ405C{57$WFE`zTYb-b#&)Y|Er^VpcR()jPmgaa@2diS-Mf(w+Rk#E&9o)|&-jDt=%~`yh^sdK->9 z@#@>WIR2fTyV#5)rBs|!0IexZNv{9}IjF;@4;tNI}moPjJ(InENNAHS#1 zHXPV|M2}#BZ|Pok?&uM;`|QUZp=tfI>8QL)Lb7cE^JA=2cJDm zGD00xlKguF@0nL23Y&HkS@R#rkq$n`Uiz_f&-=hBe%yH+r#!%^Jmz?9(V##)z8vG# zNXz!R4w@GMr}X#yIFuYyD^GAl`+n;n=uUn#28^86LC|>~cU~3zS#%I|Bz_Qd9u8gP zbnA#$=-71VVxA{IFMjAE_{|Iv5MkqIB|wKRB1~)tsqgL&<%SKoFvIvCJ6h#;&( zS5St71%WIh22=9)Sv@d` z#3rFMlY}-x(ct(W%pMhLTE06mR0}66ulx#*Y*GCrvE-IPc}}o_An7 z?C|PG);7_+LQri}O<7QFlg%!SYLrLkbjiMV5S z-oDR!8O0OxILKNWfq{SJyq8i|iWiyyop1fs=N-7eX<=Fp0n$WqmrHk(#a)3wJr?9> z?PB&V@f66nEIp6k37hb;^jtw$OW5%5^A7&W^A0@sb3n)-!|?y^yo2g;nw4N{W41_u zto#5P9!Bx+^A2q8qJN)vU_bAG&Wl1ADPmps#&)gH&*514{y3%}n{*8QF=v!;%9w-W zquy{b9TVp>dG&fHZM;PDtTJ}$z#GmWrNfrfIC~|~l}V`&5;CmGyO?c)AvZjgjgtcF zouqldu!Nlt0}e+T)bVN9R0@lSNo3BH8>e1^N1=LFtT*%sORgC|aX3nA(* z8_rHVR`rc)s4){2^o5=qMfD7=&cF|ivYDRHo7uQ#>Z8ZN>v&&vZS}gh)b#fmaKl0- zgc@^@1f&XYOrO!4^_JIZTH+0*4fB+?k%Et162p-r!&D>diE-B|b(j&Lj`FlqC58Hg zX?hB5jmV>FGaYR{)2FXynTEz$cCbivm?xCh=*6*qtA3V&7Xus9^3K%0!M+rSEq2ld zz!AyaTHQ*u%kbz3z)TzDn>e;=yApbuF@#4y?>APF_kBWF|~3T9A4W7YBBs62d1 zk>B_%@@1+jMZM#Ia-Kjq?Pdhm`mu*|{Y@7kA?;H*1KJ!u6kE>1HZae5w>g>VhV|6r z4pdEUxEchiZyBot)ei9)BdDCYsK*_s2O`U=F2kgS)kDK{rc4ez$5M<`$6s3cDb?it z$T`&HfOi}cduWd1Mx^a7^d2dFcVi8exrt5gYN_0YGaB=hq0}5SI3iO|vPerXyk9>} zUEoJM5%b}@$mV=EG36G#sT7mr0X!L|8xY&@8{;Q>id8viN^G@8pMyd4wDWl+ksHB$ zV1GRFhn^wE^@aY#c-B~&dfpRiAePq1u&PH5j1&>)7SuSSm%D9J|3i$myVD~wb{E(MF7<=WwDI%PXfwyTRU=_ip*b>^19r=S^?0s@F4e}5 z1iSmeWFBytCcQTfNxjDR({3_me-rT{7<*IDyL8-L;0at%RRacHVAV6MOAo{AODil; zDQXe~8TH_JbFh667^oH$FP#r~c2E1)t#;Ae2P#M7Wp4&1+(#tMxTPn5T2Iv=xTZ8W z`hH*42LMufQ+2)VowyYHAgfWUpvnL~;-^o^wJ&Ox@{p~&Z^U+OD;Ra^w_Tg+iVFQ$k5$xFl9BoQn0edDQ zxOSC)3N7F7YDV2)s)Lbm#%z3)JOeG{k#ByF1_6m;d?zU8^_W?){It;195@Kl{E+kL zMG}h;2s6>}e*Kt6`{RYBhTTf>iOL*(TckUK4mmPrkAU&9S#dwch4`v0EZ8VnONPJI z1w*J&pJo}s`h~R_-0;$p?A0u_Oo9EITfMM>#uO=tUFEWJg?(5J4MOQ? zOT?_}3hbB7HAgu&pbzgRYoiyOLRBr%r<_NxWe1{ZzJ|{#FViEDF4T0ZVrT=gi~l25 zHSa|@eV`MkK=JCytDnURlt5IjO_e8;L2|_?)-K;XkL#8cFneW**&V_0II21Z?pmR6)7R503Z5jYopXE8(`40z+XT4gH8pX?zA#jF(9m5=ymZuq1L|a_kWohFc?DVEA3GU5NQ- zhj4zMImM6XZ8f*!DlV@A7~~T5@J#bnpaPR$G+RMnNL<9#qIjH%EXMILdG&1=$5dY$ zw@NX5M>OyO?35FB&TdQ8AD0987~PV4sd@|C{xT*9aSk`ZC6|K*Se}{h$)7Y(uBQ`B z~Zgtn~E`BNDkhCU&ulCp6WNKjdMNvyHNSY;u3PuL2|I(Qu_{YIS7t0 zu_z02aEod@Amm`pphP+7<#G^s%H&|D9GHjaS|~eN4(=a^q|o|E4_b#$RHUee4a4i- z#@1LGoHLCs@HN#pkV6-A*j7H)nlxO5J5-G64Tir5bDHPzHiTfN(i$eQNV4!s*ljfE zob^{BH@rLB0eCPW3zeSyImjfF3c;d2_d&E+)w>wClnKSNV3NXWiiU5us3YuuSqt>{Of2(l8=Zq;eAS@Vhg=g{|hucwK%lHr=7JRDTX&2 zr=MUhBL^P0SRPv7embIOx!ib?xCq}&MbZFUPQ0?vHmcVA4#E#ylKmRA4#3St@{B!7 zF-el*lQ<}k9O~Mo*cXt-nR|y0H|*D-v{Dsa+mKm4rU0wyykvwZx@czt2?eN-8PG{F zIx#TK`NB>`deX#vx#2koCX%6$uaJ%Khe9s?5Ryd;DUh%J3&__>mO}QA&*1WPtB1kO zPA*@u%dJN8^;L8-V}jq~BCZGh9CsvOvxx7ZkyT{F$Ue8no6jXIc^62+HkW_GBy2== zZ^hD0h*sWqUP#UiCTN%Y^ZUmkA(z= z$VD`dYa2?WbR=BlLbxzV4j1E;9f;!hku}u2#iY z?*T&uj>xqRXaSvd-9o}T>W(l0OCuBBNj~Zk%g6OK zOTQKVc)OnqkqG4Hy2%&};Zlp9Kr>!T`Uum>b?ZC>8g)#kT!>+mPZkNTkHC-YNeLW* zI)cs6c!N}a4eD#W=~5G#?j7Wgrju9y7kZ1DtiLRp@tx<}%?fR1>a}n0M2z z4(>L_Xw_ebR;Iaj)3^*^1LahC^~>}oG&>1=NdH?%ZH}hqI*Z^R&2`>~W5A2gE5!#p)&cRH5EB?1pyR9M{9aL_!H)17Ts)ZpoCEsNIgX z_?YXr{V@DmEd3T|kX!ogioq@YdcMiE#uhN~_oN_9VEl85*B5HV=oT&YA->lUv`A9L z3Dj|sO{`vvQq7+s=xwbf1kEm5XhZrLq=zv(^$UH!xu2d3wql@U9wJ#M)4qj{R7HP< zfnWP0^d9AG-iXJs`RF5-UU~&`W)>LIOWW|K99RxcRzm|wFC9&mt1`0GkaFtBv6X?_ zV^6uoh^wYsUGNEWF-tNFkcQV0^_TpYn1Whs&a^)&la#_62nr;fl0CFTs{7P&EijaUD!5!zga{ZR#CH``6bo^EU1X2K+CR> zvB_RRzFU4QBCp4Slr7_skGYJtcL4(+#|M#PH*)+Af3exh@j>L+O*wwY$`KJnEXUoH z<98Br+y>s7YhFyFgFa20_zE+`SK#cErOtd$XtaC2qiUcM01_dhq$Q0Kz;5ZN7|9dJ z8%CGJlOVXH1@-3RxcXu%$@N?-u6}GU&?ivgc;FKMsArdwk*-#>3m+V?AdnMLJ_y-8kuGZ4ZR?%OzD7RKK~xQ6AxBny zCKkti?VN`?C-9jIr<6J)FUv_vA3#R4!ddmu*wB z{h{o+p}O-(IPJmN2jSba+7Ny&_Ti{JsJ#!;RmdGU6VlHO)t(2n_d)HKSG!)4i`Kx_OeGr^CPTNKX8=L3^(ykqZ3U-p7fUAaR)&htHb z0VJy|Yd2zR(gmT~a(gdch|n>Lhh~|d;H9k0tBBWbK`&?hX30^!o|X9&572_NdN9(7 zSd{rFKW`nB8F`Y}B=1u+1Lr?oOK6&Yc=upQ1rX7Y!ItDn`lf;0&x$Y2QJAZh3lZO` zp!Ik>=BfdqHG2we>Os_<6|`1?tV*4QsH|i}|7TOD0rrrQi2sCo47>-v@QE1z&Abr``%%v-~ zv;__y!T2WiBi%3_OjB>D9(s^^MD}O86e;ZI7m|F~fX$1UwCvF|bt17JOw)52nbPh+ z{r_fu-LFt}`hcHWYSN$DS8i&bxjg~Zp1+>no@m7aYE(HIH9x zz;Yz!7h7g&615S(GE!)qY!(zh=-e{$iToY^F547PZIai8*tk78es!_Go~HhqTnS~= zb)$U2;Vv-1D(M5I`y&VMBAe2Yd9(s4TmOePL|fmLqmp~MG&FpI%ljRe-) z)cdTjU^DqA`Xw0L{mCwk;M2?M8+O@8)p$8VZ!TtX&{PazSMR{m>~~Q;q#)% zK}7r``QNuPht-4pa%xcaVG;o6#W#3A@!eU9evf8luizuh_*U?MwI{N&L!-(g zLO)Vn@_ZdOe*bjfN^P$U&L%?H<(MvV9fn-;{b*ifWclOaMY9`+aVLRgP2Z}0?G2gm z29cSK+s+U^Uj1BFjskQrjGH-g2-J^o_uM1Lx6)C{YzY5m@ z`=uOm<=P8IVFz-{a8}lum5RN$tr#DrTP!(B2F^D}sqbX;lfI!`<_d|*KvDD!w1`H8 zZdlP3WQ5RBPzOE^cho(TU!ogC^ZQ0>Qwn0S$wP2uU-S@K{fV5+LzWjjq!7cM-Q;X) zgmM!Z$)OCM$HG@iq_1qJzG%e5K=PFv%)SE8!mKZ!1Yos=eC5@FI`}pD$zJ%$nbZBm zr(ZyZpS%D+DZ5s?$uqY+&u;RX#Z9(T4}FfC>}5B(qUa{{M!jl+4fQG9|iN~7d1IK$=MS9{hg%HIg>uQRv<69rZ%k0 z-lZbJrxA~G4fcpnB2~`}AE$_LM_c;1haLb3-%L=I%KR7pl!06F9n>iss;d<=WI#Cv0f>nZ#7#8y{0EVO^(3TX@XsXrg{@~EUrQ#6(U&I7>F*EH1WWG^k`Ji&2M1A|tQ~8a>ixlM z9n}gJ)v}NG0EChy%p>2d7M2C4=_TiXIlq4&_x(J-r{6EfWfDS{j%N9$pG)s7*Y7VP zA33CazJ_y5?#yD&qM~W8I6st?HM!aYKozJ*ooC zYFxU1mc5G_6CL>*Inp1a2#*enRK2>o>X~-D_gIGqdhZS_E6fjaD@>VRy|99Z)bCNai1R z`L@1Fr#DkC1=GjfzOA&(G<-82m55;Iu@iUT0oaeQhK1{uA$ru%bH+NDxawz_mzPZ7 zf$~V%_9ZXx{m>mADWNxhOz$6nwPYS{R4=vzi5^RSBK$D-#uxYes4DRGCZ_J-q2^n@5^msq?WkO^*r~bf->_>>OT<8zT{~gj3BC0zjMh9x4Z)A7PhJcjSc}|&E+D~WJBDyx_$$$wB#jQLh7LaG ze5NXwx=|{S>6tJ4oAj@>*1T=A*skxC4Z16%K0WV&Hz@7Z*@m#ULF9UJ3k7_`K4q$)TNL zYG>3tH0<*HliN{+Fd9noc0k_vI>YEJwDT15Mj>yfv%Ch#BfZ~(yw@>C%aG=S`j*Ch z4tRjTkk_Af{|S9cNFG#f0mT61`w0nq{Z}D(F_M=7KLq?`!ezNt-hlhAIbMGVPq^lO z9f^8xDYZtmrw#mr*BizU3-$?H?GrZnL5nBs+?t}iA3$CnvE|7xCa>OE9$81}R{}ZL z#|(pB0e18&sb9VF(-zO%Q^_OytcSe8xM9Sp0{HMYH`=?^6ZQtuCGK_Ja+nNmO_{3x zJHbB={!a`2eGSVUbwz@I(q&)~S8|C0Zl#%n(6X2uzmKFHc5Ff@F_zM4KPF#ZDmtm?7FN9iZJo?fbF`Xt#n*Ygn7GkwB~%nhHSe)7{2 z#G+bU3%ysU|J3p4K4(8I#Gmz$_xi#Aop?d|?Si~RFBrzx&S(3aH2$pd=G>l(&vZ1= zRWy#m`1=jyjlXReSXq+xzSoU$IpS&Z2DX)~^j2=A>yq@WChydc-#se(EoAC9Dx~IB z`f2={cMOAu4uLT$Bhn@CL-#IkAjGo}$tl6LYh~UlpX4k69srJ; zMF%-S_imeCc7^%bfAjp?>`FpAS2wl%^D?$0Kr(yV~XRY!EJ)0neB7xa&)b$J5H3d22c%hRZh@Qm1T=UcPMtC!Dvh#Z2$H0G%)y`;Nv7bCY zw%b`wn?ewztB9ETARtq6Z2~D?BRfy$AJh2@ z^f~8$@;jr4ped~guUWrNYeYDBO)W=jzc@53&ea)MQjtfwrkV``0}`R74?1>g`MMc` z*9!3~Gx8YJi(HJ4&r>+-IiXJJakMplda4*K|PBt(xAa=>wWRqUp1mzNYEhnjY13miE7MG`&dE%Qao8 z>6q@nRrU2(1S&Ud?C(zX2QI6wtzLS`lDd9*x}-`0LR2TWbfw}OK~sH-Zst^XPbyKp zsk^^=V}D0y+a(=sLY{4oCpU}gwk_Q#sc5QC z(cOXnsl*`ux8nqPJ#Fz+TvR7E$J+biU5VJ{Hk9QvRU#Je>x*wuB{==3tzd)ncvnX& zs_ub6{HvC=D2W@BNm1R})76#ePC546{|uyYO1{qH;a81M+C>^Er=yrZuv((x2*P{WUE2QE=M`<9Ne#LNjvxT%OzC zjeK)?j$ceU-cfmqnfCI7z(_BSuN>c*a@+=sJna3S1Zpl{qsKSXfX(1K{0XMF+sZfV zanJMt`pB*6;BpMziG;a+o{yMvoMwKz{`cte{A|PjFN%}t5Es;x>u36xz^Q)j|506@ zDedVnANKmkkZCFZlHwlKbO%qoS_t=_J{5nD1kKg#A3Xm~eV{n({PuHtCgn4g=lS{A z7c9RIWl4XoU+{eLAwV4V`t0Wi!9%{s<#|3T)#Y>Aerz``&-TxuthxTzKMDZB^UjYX z5tWJ*{&RVzuOi1>p05|glqxb-D5(-$j_EG}o6GZjHKxlmAB(Y{zl99Kxc$5Je7E}~ z<+V9joR~z4u$ls*5?sE*hI4tQ^N`PVn^|Af^&c^VNOL)c>70F^F`^U4)YZa}ik~4k&RKD<;P_?5 zeS+hX755je`>psq!STe3BieGDFlBheS%SyE35I{n$9N8yA({3FOcr{)m@_@%9Kqwz zihoJ)__E^cjYX8auSEPBJB6(Wg=3ePu0P%XxN#+8w|}+9hxEM0(n1=y--lfX+$D;7 zs!@O)))Jp?&k-#LO|~3=CHbfK%Q$eSc0C20^bcw|Ebax3w`f4_9R>Ej#(Vz&2^?|{ zDCikb*h&7`z)8M%K(Y(DcLYglpA$dr?Zi8JB0vGwbX+0v>GmfUCpjx6|8#$#?d&cG zf4fQZ+x=v-#Hah)?ZD4OyCx1OC83!-Ml~*8ROeZZ(_RVY(U2tnsQLG3Iewivq48eY zE02S()991KRIh)7!sQ-0BtO=8Zok6iUJ)c|k3>L0mj89YNltE|f-ly&S7}`AQviqI z8#M0MxF%u{xF1evx7!_>|FE`$+=Bp-_i23Mc_m-&y+HDBHQsW$!sCjFf0p?4I5w{N zbKg;na?cc!ztH%YHoV+Z2mDiw4=qysZ09+cgvbs<&njH*NkMX<#%p#eT<{ySJNf5VBtBP+YX9VRHEXpa8j76v=xu zF7_+@5zYUA#{HU~u2t!HQsOFY{{NEZAJhKE>rn4%yv1h!x#$S#|I3sVxknetuK@QW z4)3weFN-z*#6rc-{eC6mx?T?V360k@DEWmRT<#S^l76?0^l#Dr8Bp1BZz|!3wVrZs8}dHZ{8L&%xi=m783>HTUsIz5$UX2# zE@52T0mbDJ0v^z5Gr3Xo2lp!Uah-Xy#(Q;~No)MiH9n>Nf#vVexX_L!-+@4x`+;kh z)e;nWQt~@oXSVjGlBs^YN!Kc3v8MX9v1sGE^|6>}OY|i+btF@XzF4X&*4o+Aok$7? zC>Cq$iEZla*%a@y9Mif^*y~?r9AP`0Hyz zs~hXVv3_+ubFYeCy&@EiUA=PUx`y?!^`RBfhM3d{>Lya_QhkYdSEOF)h;%A}llHzu zA{bm1ZCp_wTUx!e`VVC`p%(sR$E}H;b_K0Vp{QhQOB5Q=9#5vwobFUdcfZQytVsRR zSZ7C92YTx2{#0*&3g%30mO@Z}ta1J7SkV#C8ghg6@r`IDnVzMr=;`lnvmo3O-5t}a z5wV0^<|HY}&W^T3V>c>a0Y6Oi>9WcAKqB1HnzEe=={EKjCgbf1sd{r?qP=7A^2=^^ z;tm*ICnCP>a#XgiQRTl=i)}5MUt4)cM&9q6j`W^ZUPX|77(;?I#k_bYn2LjvW&=4bivI@4Yf1zF literal 0 HcmV?d00001 diff --git a/lz4.c b/lib/lz4.c similarity index 100% rename from lz4.c rename to lib/lz4.c diff --git a/lz4.h b/lib/lz4.h similarity index 100% rename from lz4.h rename to lib/lz4.h diff --git a/lib/lz4.o b/lib/lz4.o new file mode 100644 index 0000000000000000000000000000000000000000..2ed244d8cd57eea34d08a71d940381e7b873eb0d GIT binary patch literal 47472 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 literal 0 HcmV?d00001 diff --git a/lz4frame.c b/lib/lz4frame.c similarity index 100% rename from lz4frame.c rename to lib/lz4frame.c diff --git a/lz4frame.h b/lib/lz4frame.h similarity index 100% rename from lz4frame.h rename to lib/lz4frame.h diff --git a/lz4hc.c b/lib/lz4hc.c similarity index 100% rename from lz4hc.c rename to lib/lz4hc.c diff --git a/lz4hc.h b/lib/lz4hc.h similarity index 100% rename from lz4hc.h rename to lib/lz4hc.h diff --git a/lib/lz4hc.o b/lib/lz4hc.o new file mode 100644 index 0000000000000000000000000000000000000000..bbc0911780eb8186c95f21bc44f6da3091a4919e GIT binary patch literal 15888 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 N?$rhR%IIEQ@ZatjNMZm0 literal 0 HcmV?d00001 diff --git a/xxhash.c b/lib/xxhash.c similarity index 100% rename from xxhash.c rename to lib/xxhash.c diff --git a/xxhash.h b/lib/xxhash.h similarity index 100% rename from xxhash.h rename to lib/xxhash.h diff --git a/programs/Makefile b/programs/Makefile index 9001e2c..96de0e3 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -37,11 +37,11 @@ PREFIX ?= /usr CC := $(CC) CFLAGS ?= -O3 CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -DLZ4_VERSION=\"$(RELEASE)\" -FLAGS = -I.. $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) +FLAGS = -I../lib $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) BINDIR=$(PREFIX)/bin MANDIR=$(PREFIX)/share/man/man1 -LZ4DIR=.. +LZ4DIR=../lib TEST_FILES = COPYING TEST_TARGETS=test-native diff --git a/programs/lz4cli.c b/programs/lz4cli.c index 8a8fc27..e69a84a 100644 --- a/programs/lz4cli.c +++ b/programs/lz4cli.c @@ -288,7 +288,7 @@ int main(int argc, char** argv) legacy_format=0, forceStdout=0, forceCompress=0, - pause=0; + main_pause=0; char* input_filename=0; char* output_filename=0; char* dynNameSpace=0; @@ -424,7 +424,7 @@ int main(int argc, char** argv) break; // Pause at the end (hidden option) - case 'p': pause=1; BMK_SetPause(); break; + case 'p': main_pause=1; BMK_SetPause(); break; EXTENDED_ARGUMENTS; @@ -517,7 +517,7 @@ int main(int argc, char** argv) } } - if (pause) waitEnter(); + if (main_pause) waitEnter(); free(dynNameSpace); return 0; } From bf79270cedeb1faa50f2f0ef62039c200ec5cd39 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 30 Nov 2014 23:34:29 +0100 Subject: [PATCH 14/22] --- lib/liblz4.pc | 14 -------------- lib/liblz4.so | 1 - lib/liblz4.so.1 | 1 - lib/liblz4.so.1.4.1 | Bin 68571 -> 0 bytes lib/lz4.o | Bin 47472 -> 0 bytes lib/lz4hc.o | Bin 15888 -> 0 bytes 6 files changed, 16 deletions(-) delete mode 100644 lib/liblz4.pc delete mode 120000 lib/liblz4.so delete mode 120000 lib/liblz4.so.1 delete mode 100755 lib/liblz4.so.1.4.1 delete mode 100644 lib/lz4.o delete mode 100644 lib/lz4hc.o diff --git a/lib/liblz4.pc b/lib/liblz4.pc deleted file mode 100644 index 39983ba..0000000 --- a/lib/liblz4.pc +++ /dev/null @@ -1,14 +0,0 @@ -# LZ4 - Fast LZ compression algorithm -# Copyright (C) 2011-2014, Yann Collet. -# BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - -prefix=/usr -libdir=/usr/lib -includedir=/usr/include - -Name: lz4 -Description: fast lossless compression algorithm library -URL: http://code.google.com/p/lz4/ -Version: -Libs: -L/usr/lib -llz4 -Cflags: -I/usr/include diff --git a/lib/liblz4.so b/lib/liblz4.so deleted file mode 120000 index 3c57595..0000000 --- a/lib/liblz4.so +++ /dev/null @@ -1 +0,0 @@ -liblz4.so.1.4.1 \ No newline at end of file diff --git a/lib/liblz4.so.1 b/lib/liblz4.so.1 deleted file mode 120000 index 3c57595..0000000 --- a/lib/liblz4.so.1 +++ /dev/null @@ -1 +0,0 @@ -liblz4.so.1.4.1 \ No newline at end of file diff --git a/lib/liblz4.so.1.4.1 b/lib/liblz4.so.1.4.1 deleted file mode 100755 index 6ff6fcf46169369c6f1c4cc577e222d06cc7d7a1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 68571 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 PN&o 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 diff --git a/lib/lz4.o b/lib/lz4.o deleted file mode 100644 index 2ed244d8cd57eea34d08a71d940381e7b873eb0d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 47472 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 diff --git a/lib/lz4hc.o b/lib/lz4hc.o deleted file mode 100644 index bbc0911780eb8186c95f21bc44f6da3091a4919e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 15888 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 N?$rhR%IIEQ@ZatjNMZm0 From 989346b75eb82f1d3504bec82e4ede77c11d5711 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Sun, 30 Nov 2014 23:37:55 +0100 Subject: [PATCH 15/22] fix : sudo for make install --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 60f8ce1..d8c2621 100644 --- a/Makefile +++ b/Makefile @@ -93,8 +93,8 @@ clean: ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU)) install: - @cd $(LZ4DIR); $(MAKE) -e install - @cd $(PRGDIR); $(MAKE) -e install + @cd $(LZ4DIR); sudo $(MAKE) -e install + @cd $(PRGDIR); sudo $(MAKE) -e install uninstall: @cd $(LZ4DIR); $(MAKE) uninstall From 9523101aff2f7d38572b22b522430b9af39df873 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 1 Dec 2014 00:53:20 +0100 Subject: [PATCH 16/22] Clarified some file names --- LZ4_Framing_Format.html => LZ4_Frame_Format.html | 0 liblz4.pc.in | 14 -------------- lz4_format_description.txt => lz4_block_format.txt | 0 3 files changed, 14 deletions(-) rename LZ4_Framing_Format.html => LZ4_Frame_Format.html (100%) delete mode 100644 liblz4.pc.in rename lz4_format_description.txt => lz4_block_format.txt (100%) diff --git a/LZ4_Framing_Format.html b/LZ4_Frame_Format.html similarity index 100% rename from LZ4_Framing_Format.html rename to LZ4_Frame_Format.html diff --git a/liblz4.pc.in b/liblz4.pc.in deleted file mode 100644 index 0d05152..0000000 --- a/liblz4.pc.in +++ /dev/null @@ -1,14 +0,0 @@ -# LZ4 - Fast LZ compression algorithm -# Copyright (C) 2011-2014, Yann Collet. -# BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) - -prefix=@PREFIX@ -libdir=@LIBDIR@ -includedir=@INCLUDEDIR@ - -Name: lz4 -Description: fast lossless compression algorithm library -URL: http://code.google.com/p/lz4/ -Version: @VERSION@ -Libs: -L@LIBDIR@ -llz4 -Cflags: -I@INCLUDEDIR@ diff --git a/lz4_format_description.txt b/lz4_block_format.txt similarity index 100% rename from lz4_format_description.txt rename to lz4_block_format.txt From a109c91818341188d8d64096d1701c1747ed480d Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 1 Dec 2014 01:20:42 +0100 Subject: [PATCH 17/22] Fixed : make dist --- Makefile | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index d8c2621..66c8c4b 100644 --- a/Makefile +++ b/Makefile @@ -49,15 +49,14 @@ DISTRIBNAME=lz4-$(RELEASE).tar.gz TEXT = $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4.h $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4hc.h \ $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4frame.h $(LZ4DIR)/xxhash.c $(LZ4DIR)/xxhash.h \ $(LZ4DIR)/liblz4.pc.in $(LZ4DIR)/Makefile $(LZ4DIR)/LICENSE \ - Makefile lz4_format_description.txt NEWS README.md \ + Makefile lz4_block_format.txt LZ4_Frame_Format.html NEWS README.md \ cmake_unofficial/CMakeLists.txt \ $(PRGDIR)/fullbench.c $(PRGDIR)/lz4cli.c \ $(PRGDIR)/datagen.c $(PRGDIR)/fuzzer.c \ $(PRGDIR)/lz4io.c $(PRGDIR)/lz4io.h \ $(PRGDIR)/bench.c $(PRGDIR)/bench.h \ $(PRGDIR)/lz4.1 $(PRGDIR)/lz4c.1 $(PRGDIR)/lz4cat.1 \ - $(PRGDIR)/Makefile $(PRGDIR)/COPYING \ - LZ4_Framing_Format.html + $(PRGDIR)/Makefile $(PRGDIR)/COPYING NONTEXT = images/image00.png images/image01.png images/image02.png \ images/image03.png images/image04.png images/image05.png \ images/image06.png From 9f6826fdc9621935324f35a596d43c145f7b172c Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 1 Dec 2014 01:25:18 +0100 Subject: [PATCH 18/22] lz4cli : legacy arguments are now disabled by default --- programs/Makefile | 8 ++++---- programs/lz4cli.c | 18 +++++++++--------- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/programs/Makefile b/programs/Makefile index 96de0e3..eca920b 100644 --- a/programs/Makefile +++ b/programs/Makefile @@ -66,13 +66,13 @@ default: lz4 lz4c all: lz4 lz4c lz4c32 fullbench fullbench32 fuzzer fuzzer32 frametest frametest32 datagen lz4: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c - $(CC) $(FLAGS) -DDISABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) - -lz4c : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c $(CC) $(FLAGS) $^ -o $@$(EXT) +lz4c : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c + $(CC) $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) + lz4c32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c - $(CC) -m32 $(FLAGS) $^ -o $@$(EXT) + $(CC) -m32 $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT) fullbench : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c fullbench.c $(CC) $(FLAGS) $^ -o $@$(EXT) diff --git a/programs/lz4cli.c b/programs/lz4cli.c index e69a84a..351de80 100644 --- a/programs/lz4cli.c +++ b/programs/lz4cli.c @@ -32,10 +32,10 @@ //************************************** // Tuning parameters //************************************** -// DISABLE_LZ4C_LEGACY_OPTIONS : +// ENABLE_LZ4C_LEGACY_OPTIONS : // Control the availability of -c0, -c1 and -hc legacy arguments -// Default : Legacy options are enabled -// #define DISABLE_LZ4C_LEGACY_OPTIONS +// Default : Legacy options are disabled +// #define ENABLE_LZ4C_LEGACY_OPTIONS //************************************** @@ -201,14 +201,14 @@ int usage_advanced(void) DISPLAY( "Benchmark arguments :\n"); DISPLAY( " -b : benchmark file(s)\n"); DISPLAY( " -i# : iteration loops [1-9](default : 3), benchmark mode only\n"); -#if !defined(DISABLE_LZ4C_LEGACY_OPTIONS) +#if defined(ENABLE_LZ4C_LEGACY_OPTIONS) DISPLAY( "Legacy arguments :\n"); DISPLAY( " -c0 : fast compression\n"); DISPLAY( " -c1 : high compression\n"); DISPLAY( " -hc : high compression\n"); DISPLAY( " -y : overwrite output without prompting \n"); DISPLAY( " -s : suppress warnings \n"); -#endif // DISABLE_LZ4C_LEGACY_OPTIONS +#endif // ENABLE_LZ4C_LEGACY_OPTIONS EXTENDED_HELP; return 0; } @@ -250,7 +250,7 @@ int usage_longhelp(void) DISPLAY( "%s can be used in 'pure pipe mode', for example :\n", programName); DISPLAY( "3 : compress data stream from 'generator', send result to 'consumer'\n"); DISPLAY( " generator | %s | consumer \n", programName); -#if !defined(DISABLE_LZ4C_LEGACY_OPTIONS) +#if defined(ENABLE_LZ4C_LEGACY_OPTIONS) DISPLAY( "\n"); DISPLAY( "Warning :\n"); DISPLAY( "Legacy arguments take precedence. Therefore : \n"); @@ -259,7 +259,7 @@ int usage_longhelp(void) DISPLAY( "It is not equivalent to :\n"); DISPLAY( " %s -h -c filename\n", programName); DISPLAY( "which would display help text and exit\n"); -#endif // DISABLE_LZ4C_LEGACY_OPTIONS +#endif // ENABLE_LZ4C_LEGACY_OPTIONS return 0; } @@ -325,14 +325,14 @@ int main(int argc, char** argv) { argument ++; -#if !defined(DISABLE_LZ4C_LEGACY_OPTIONS) +#if defined(ENABLE_LZ4C_LEGACY_OPTIONS) // Legacy options (-c0, -c1, -hc, -y, -s) if ((argument[0]=='c') && (argument[1]=='0')) { cLevel=0; argument++; continue; } // -c0 (fast compression) if ((argument[0]=='c') && (argument[1]=='1')) { cLevel=9; argument++; continue; } // -c1 (high compression) if ((argument[0]=='h') && (argument[1]=='c')) { cLevel=9; argument++; continue; } // -hc (high compression) if (*argument=='y') { LZ4IO_setOverwrite(1); continue; } // -y (answer 'yes' to overwrite permission) if (*argument=='s') { displayLevel=1; continue; } // -s (silent mode) -#endif // DISABLE_LZ4C_LEGACY_OPTIONS +#endif // ENABLE_LZ4C_LEGACY_OPTIONS if ((*argument>='0') && (*argument<='9')) { From 67c25a5c1b03eaf61a89c634469fad3b0de76ae8 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Mon, 1 Dec 2014 22:00:07 +0100 Subject: [PATCH 19/22] lz4frame.h : clarified a few comments --- lib/lz4frame.h | 46 +++++++++++++++++++++++++++------------------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/lib/lz4frame.h b/lib/lz4frame.h index a4f5e36..7184cc3 100644 --- a/lib/lz4frame.h +++ b/lib/lz4frame.h @@ -1,7 +1,7 @@ /* LZ4 auto-framing library Header File - Copyright (C) 2011-2014, Yann Collet. + Copyright (C) 2011-2015, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) Redistribution and use in source and binary forms, with or without @@ -29,6 +29,7 @@ You can contact the author at : - LZ4 source repository : http://code.google.com/p/lz4/ + - LZ4 source mirror : https://github.com/Cyan4973/lz4 - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c */ @@ -46,7 +47,7 @@ extern "C" { /**************************************** Note : experimental API. - Not yet integrated within lz4 library. + Not yet integrated within liblz4 ****************************************/ /************************************** @@ -56,8 +57,8 @@ extern "C" { /************************************** - Error management -**************************************/ + * Error management + * ************************************/ typedef size_t LZ4F_errorCode_t; #define LZ4F_LIST_ERRORS(ITEM) \ ITEM(OK_NoError) ITEM(ERROR_GENERIC) \ @@ -72,15 +73,15 @@ typedef size_t LZ4F_errorCode_t; #define LZ4F_GENERATE_ENUM(ENUM) ENUM, typedef enum { LZ4F_LIST_ERRORS(LZ4F_GENERATE_ENUM) } LZ4F_errorCodes; /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ -int LZ4F_isError(LZ4F_errorCode_t code); /* Basically : code > -ERROR_maxCode */ -const char* LZ4F_getErrorName(LZ4F_errorCode_t code); /* return enum as string */ +int LZ4F_isError(LZ4F_errorCode_t code); /* Basically : code > -ERROR_maxCode */ +const char* LZ4F_getErrorName(LZ4F_errorCode_t code); /* return error code string; useful for debugging */ /************************************** - Framing compression functions -**************************************/ + * Frame compression types + * ************************************/ -typedef enum { LZ4F_default=0, max64KB=4, max256KB=5, max1MB=6, max4MB=7} blockSizeID_t; +typedef enum { LZ4F_default=0, max64KB=4, max256KB=5, max1MB=6, max4MB=7 } blockSizeID_t; typedef enum { blockLinked=0, blockIndependent} blockMode_t; typedef enum { noContentChecksum=0, contentChecksumEnabled } contentChecksum_t; @@ -93,8 +94,8 @@ typedef struct { typedef struct { LZ4F_frameInfo_t frameInfo; - unsigned compressionLevel; /* Not yet supported : only fast compression for the time being */ - unsigned autoFlush; /* 1 == always flush; reduce need for tmp buffer */ + unsigned compressionLevel; /* 0 == default (fast mode); values above 16 count as 16 */ + unsigned autoFlush; /* 1 == always flush : reduce need for tmp buffer */ unsigned reserved[4]; } LZ4F_preferences_t; @@ -120,7 +121,7 @@ size_t LZ4F_compressFrame(void* dstBuffer, size_t dstMaxSize, const void* srcBuf /********************************** * Advanced compression functions - * *********************************/ + * ********************************/ typedef void* LZ4F_compressionContext_t; @@ -159,6 +160,7 @@ size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* preferencesP /* LZ4F_compressBound() : * Provides the minimum size of Dst buffer given srcSize to handle worst case situations. * preferencesPtr is optional : you can provide NULL as argument, all preferences will then be set to default. + * Note that different preferences will produce in different results. */ size_t LZ4F_compressUpdate(LZ4F_compressionContext_t compressionContext, void* dstBuffer, size_t dstMaxSize, const void* srcBuffer, size_t srcSize, const LZ4F_compressOptions_t* compressOptionsPtr); @@ -207,19 +209,22 @@ typedef struct { /* Resource management */ -LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_compressionContext_t* LZ4F_decompressionContextPtr, unsigned version); -LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_compressionContext_t LZ4F_decompressionContext); +LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_decompressionContext_t* ctxPtr, unsigned version); +LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_decompressionContext_t ctx); /* LZ4F_createDecompressionContext() : * The first thing to do is to create a decompressionContext object, which will be used in all decompression operations. * This is achieved using LZ4F_createDecompressionContext(). - * The function will provide a pointer to a fully allocated and initialized LZ4F_decompressionContext object. + * The version provided MUST be LZ4F_VERSION. It is intended to track potential version differences between different binaries. + * The function will provide a pointer to a fully allocated and initialized LZ4F_decompressionContext_t object. * If the result LZ4F_errorCode_t is not OK_NoError, there was an error during context creation. * Object can release its memory using LZ4F_freeDecompressionContext(); */ /* Decompression */ -size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t decompressionContext, LZ4F_frameInfo_t* frameInfoPtr, const void* srcBuffer, size_t* srcSizePtr); +size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t ctx, + LZ4F_frameInfo_t* frameInfoPtr, + const void* srcBuffer, size_t* srcSizePtr); /* LZ4F_getFrameInfo() * This function decodes frame header information, such as blockSize. * It is optional : you could start by calling directly LZ4F_decompress() instead. @@ -231,7 +236,10 @@ size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t decompressionContext, LZ4F_ * or an error code which can be tested using LZ4F_isError(). */ -size_t LZ4F_decompress(LZ4F_decompressionContext_t decompressionContext, void* dstBuffer, size_t* dstSizePtr, const void* srcBuffer, size_t* srcSizePtr, const LZ4F_decompressOptions_t* decompressOptionsPtr); +size_t LZ4F_decompress(LZ4F_decompressionContext_t ctx, + void* dstBuffer, size_t* dstSizePtr, + const void* srcBuffer, size_t* srcSizePtr, + const LZ4F_decompressOptions_t* optionsPtr); /* LZ4F_decompress() * Call this function repetitively to regenerate data compressed within srcBuffer. * The function will attempt to decode *srcSizePtr bytes from srcBuffer, into dstBuffer of maximum size *dstSizePtr. @@ -248,8 +256,8 @@ size_t LZ4F_decompress(LZ4F_decompressionContext_t decompressionContext, void* d * * The function result is an hint of the better srcSize to use for next call to LZ4F_decompress. * Basically, it's the size of the current (or remaining) compressed block + header of next block. - * Respecting the hint provides some boost to performance, since it allows less buffer shuffling. - * Note that this is just a hint, you can always provide any srcSize you want. + * Respecting the hint provides some boost to performance, since it does not need intermediate buffers. + * This is just a hint, you can always provide any srcSize you want. * When a frame is fully decoded, the function result will be 0. * If decompression failed, function result is an error code which can be tested using LZ4F_isError(). */ From 118296aeb0f02b8978544793ae4cc897d7638765 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Tue, 2 Dec 2014 23:57:15 +0100 Subject: [PATCH 20/22] variable ref renamed --- lib/lz4.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/lib/lz4.c b/lib/lz4.c index fb84955..4d3e67f 100644 --- a/lib/lz4.c +++ b/lib/lz4.c @@ -465,7 +465,7 @@ static void LZ4_putPositionOnHash(const BYTE* p, U32 h, void* tableBase, tableTy { switch (tableType) { - case byPtr: { const BYTE** hashTable = (const BYTE**) tableBase; hashTable[h] = p; return; } + case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; } case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; } case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; } } @@ -550,7 +550,7 @@ static int LZ4_compress_generic( /* Main Loop */ for ( ; ; ) { - const BYTE* ref; + const BYTE* match; BYTE* token; { const BYTE* forwardIp = ip; @@ -566,10 +566,10 @@ static int LZ4_compress_generic( if (unlikely(forwardIp > mflimit)) goto _last_literals; - ref = LZ4_getPositionOnHash(h, ctx, tableType, base); + match = LZ4_getPositionOnHash(h, ctx, tableType, base); if (dict==usingExtDict) { - if (ref<(const BYTE*)source) + if (match<(const BYTE*)source) { refDelta = dictDelta; lowLimit = dictionary; @@ -583,13 +583,13 @@ static int LZ4_compress_generic( forwardH = LZ4_hashPosition(forwardIp, tableType); LZ4_putPositionOnHash(ip, h, ctx, tableType, base); - } while ( ((dictIssue==dictSmall) ? (ref < lowRefLimit) : 0) - || ((tableType==byU16) ? 0 : (ref + MAX_DISTANCE < ip)) - || (LZ4_read32(ref+refDelta) != LZ4_read32(ip)) ); + } while ( ((dictIssue==dictSmall) ? (match < lowRefLimit) : 0) + || ((tableType==byU16) ? 0 : (match + MAX_DISTANCE < ip)) + || (LZ4_read32(match+refDelta) != LZ4_read32(ip)) ); } /* Catch up */ - while ((ip>anchor) && (ref+refDelta > lowLimit) && (unlikely(ip[-1]==ref[refDelta-1]))) { ip--; ref--; } + while ((ip>anchor) && (match+refDelta > lowLimit) && (unlikely(ip[-1]==match[refDelta-1]))) { ip--; match--; } { /* Encode Literal length */ @@ -613,7 +613,7 @@ static int LZ4_compress_generic( _next_match: /* Encode Offset */ - LZ4_writeLE16(op, (U16)(ip-ref)); op+=2; + LZ4_writeLE16(op, (U16)(ip-match)); op+=2; /* Encode MatchLength */ { @@ -622,10 +622,10 @@ _next_match: if ((dict==usingExtDict) && (lowLimit==dictionary)) { const BYTE* limit; - ref += refDelta; - limit = ip + (dictEnd-ref); + match += refDelta; + limit = ip + (dictEnd-match); if (limit > matchlimit) limit = matchlimit; - matchLength = LZ4_count(ip+MINMATCH, ref+MINMATCH, limit); + matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, limit); ip += MINMATCH + matchLength; if (ip==limit) { @@ -636,7 +636,7 @@ _next_match: } else { - matchLength = LZ4_count(ip+MINMATCH, ref+MINMATCH, matchlimit); + matchLength = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit); ip += MINMATCH + matchLength; } @@ -662,10 +662,10 @@ _next_match: LZ4_putPosition(ip-2, ctx, tableType, base); /* Test next position */ - ref = LZ4_getPosition(ip, ctx, tableType, base); + match = LZ4_getPosition(ip, ctx, tableType, base); if (dict==usingExtDict) { - if (ref<(const BYTE*)source) + if (match<(const BYTE*)source) { refDelta = dictDelta; lowLimit = dictionary; @@ -677,9 +677,9 @@ _next_match: } } LZ4_putPosition(ip, ctx, tableType, base); - if ( ((dictIssue==dictSmall) ? (ref>=lowRefLimit) : 1) - && (ref+MAX_DISTANCE>=ip) - && (LZ4_read32(ref+refDelta)==LZ4_read32(ip)) ) + if ( ((dictIssue==dictSmall) ? (match>=lowRefLimit) : 1) + && (match+MAX_DISTANCE>=ip) + && (LZ4_read32(match+refDelta)==LZ4_read32(ip)) ) { token=op++; *token=0; goto _next_match; } /* Prepare next loop */ From 65ee6b09c4392814167e7a039d9312aabdb5119b Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Wed, 3 Dec 2014 19:17:10 +0100 Subject: [PATCH 21/22] Fixed : deprecated function LZ4_slideInputBufferHC() --- lib/Makefile | 1 - lib/lz4.c | 4 +-- lib/lz4hc.c | 98 ++++++++++++++++++++++------------------------------ 3 files changed, 43 insertions(+), 60 deletions(-) diff --git a/lib/Makefile b/lib/Makefile index f2d585f..3ae12fa 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -63,7 +63,6 @@ else endif default: liblz4 - @cd $(PRGDIR); $(MAKE) -e all: liblz4 diff --git a/lib/lz4.c b/lib/lz4.c index 4d3e67f..f8186b4 100644 --- a/lib/lz4.c +++ b/lib/lz4.c @@ -394,17 +394,17 @@ static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLi pIn += LZ4_NbCommonBytes(diff); return (unsigned)(pIn - pStart); } + if (LZ4_64bits()) if ((pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; } if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; } if ((pInhashTable, 0, sizeof(hc4->hashTable)); MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable)); hc4->nextToUpdate = 64 KB; - hc4->base = base - 64 KB; - hc4->inputBuffer = base; - hc4->end = base; - hc4->dictBase = base - 64 KB; + hc4->base = start - 64 KB; + hc4->inputBuffer = start; + hc4->end = start; + hc4->dictBase = start - 64 KB; hc4->dictLimit = 64 KB; hc4->lowLimit = 64 KB; } @@ -155,21 +155,6 @@ FORCE_INLINE void LZ4HC_Insert (LZ4HC_Data_Structure* hc4, const BYTE* ip) } -static void LZ4HC_setExternalDict(LZ4HC_Data_Structure* ctxPtr, const BYTE* newBlock) -{ - if (ctxPtr->end >= ctxPtr->base + 4) - LZ4HC_Insert (ctxPtr, ctxPtr->end-3); // finish referencing dictionary content - // Note : need to handle risk of index overflow - // Use only one memory segment for dict, so any previous External Dict is lost at this stage - ctxPtr->lowLimit = ctxPtr->dictLimit; - ctxPtr->dictLimit = (U32)(ctxPtr->end - ctxPtr->base); - ctxPtr->dictBase = ctxPtr->base; - ctxPtr->base = newBlock - ctxPtr->dictLimit; - ctxPtr->end = newBlock; - ctxPtr->nextToUpdate = ctxPtr->dictLimit; // reference table must skip to from beginning of block -} - - FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4, // Index table will be updated const BYTE* ip, const BYTE* const iLimit, const BYTE** matchpos, @@ -571,7 +556,7 @@ int LZ4_compressHC_limitedOutput(const char* source, char* dest, int inputSize, /***************************** - Using external allocation + Using external allocation *****************************/ int LZ4_sizeofStateHC(void) { return sizeof(LZ4HC_Data_Structure); } @@ -598,9 +583,10 @@ int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* source, c { return LZ4_compressHC2_limitedOutput_withStateHC (state, source, dest, inputSize, maxOutputSize, 0); } + /************************************** - Experimental Streaming Functions -**************************************/ + * Streaming Functions + * ************************************/ /* allocation */ LZ4_streamHC_t* LZ4_createStreamHC(void) { return (LZ4_streamHC_t*)malloc(sizeof(LZ4_streamHC_t)); } int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr) { free(LZ4_streamHCPtr); return 0; }; @@ -616,55 +602,68 @@ void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel) int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, const char* dictionary, int dictSize) { - LZ4HC_Data_Structure* streamPtr = (LZ4HC_Data_Structure*) LZ4_streamHCPtr; + LZ4HC_Data_Structure* ctxPtr = (LZ4HC_Data_Structure*) LZ4_streamHCPtr; if (dictSize > 64 KB) { dictionary += dictSize - 64 KB; dictSize = 64 KB; } - LZ4HC_init (streamPtr, (const BYTE*)dictionary); - if (dictSize >= 4) LZ4HC_Insert (streamPtr, (const BYTE*)dictionary +(dictSize-3)); - streamPtr->end = (const BYTE*)dictionary + dictSize; + LZ4HC_init (ctxPtr, (const BYTE*)dictionary); + if (dictSize >= 4) LZ4HC_Insert (ctxPtr, (const BYTE*)dictionary +(dictSize-3)); + ctxPtr->end = (const BYTE*)dictionary + dictSize; return dictSize; } /* compression */ -static int LZ4_compressHC_continue_generic (LZ4HC_Data_Structure* dsPtr, +static void LZ4HC_setExternalDict(LZ4HC_Data_Structure* ctxPtr, const BYTE* newBlock) +{ + if (ctxPtr->end >= ctxPtr->base + 4) + LZ4HC_Insert (ctxPtr, ctxPtr->end-3); /* Referencing remaining dictionary content */ + /* Only one memory segment for extDict, so any previous extDict is lost at this stage */ + ctxPtr->lowLimit = ctxPtr->dictLimit; + ctxPtr->dictLimit = (U32)(ctxPtr->end - ctxPtr->base); + ctxPtr->dictBase = ctxPtr->base; + ctxPtr->base = newBlock - ctxPtr->dictLimit; + ctxPtr->end = newBlock; + ctxPtr->nextToUpdate = ctxPtr->dictLimit; /* match referencing will resume from there */ +} + +static int LZ4_compressHC_continue_generic (LZ4HC_Data_Structure* ctxPtr, const char* source, char* dest, int inputSize, int maxOutputSize, limitedOutput_directive limit) { /* auto-init if forgotten */ - if (dsPtr->base == NULL) - LZ4HC_init (dsPtr, (const BYTE*) source); + if (ctxPtr->base == NULL) + LZ4HC_init (ctxPtr, (const BYTE*) source); /* Check overflow */ - if ((size_t)(dsPtr->end - dsPtr->base) > 2 GB) + if ((size_t)(ctxPtr->end - ctxPtr->base) > 2 GB) { - size_t dictSize = (size_t)(dsPtr->end - dsPtr->base) - dsPtr->dictLimit; + size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->base) - ctxPtr->dictLimit; if (dictSize > 64 KB) dictSize = 64 KB; - LZ4_loadDictHC((LZ4_streamHC_t*)dsPtr, (const char*)(dsPtr->end) - dictSize, (int)dictSize); + LZ4_loadDictHC((LZ4_streamHC_t*)ctxPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize); } /* Check if blocks follow each other */ - if ((const BYTE*)source != dsPtr->end) LZ4HC_setExternalDict(dsPtr, (const BYTE*)source); + if ((const BYTE*)source != ctxPtr->end) LZ4HC_setExternalDict(ctxPtr, (const BYTE*)source); /* Check overlapping input/dictionary space */ { const BYTE* sourceEnd = (const BYTE*) source + inputSize; - const BYTE* dictBegin = dsPtr->dictBase + dsPtr->lowLimit; - const BYTE* dictEnd = dsPtr->dictBase + dsPtr->dictLimit; + const BYTE* dictBegin = ctxPtr->dictBase + ctxPtr->lowLimit; + const BYTE* dictEnd = ctxPtr->dictBase + ctxPtr->dictLimit; if ((sourceEnd > dictBegin) && ((BYTE*)source < dictEnd)) { if (sourceEnd > dictEnd) sourceEnd = dictEnd; - dsPtr->lowLimit = (U32)(sourceEnd - dsPtr->dictBase); - if (dsPtr->dictLimit - dsPtr->lowLimit < 4) dsPtr->lowLimit = dsPtr->dictLimit; + ctxPtr->lowLimit = (U32)(sourceEnd - ctxPtr->dictBase); + if (ctxPtr->dictLimit - ctxPtr->lowLimit < 4) ctxPtr->lowLimit = ctxPtr->dictLimit; } } - return LZ4HC_compress_generic (dsPtr, source, dest, inputSize, maxOutputSize, dsPtr->compressionLevel, limit); + return LZ4HC_compress_generic (ctxPtr, source, dest, inputSize, maxOutputSize, ctxPtr->compressionLevel, limit); } int LZ4_compressHC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize) @@ -688,7 +687,6 @@ int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictS if (dictSize < 4) dictSize = 0; if (dictSize > prefixSize) dictSize = prefixSize; memcpy(safeBuffer, streamPtr->end - dictSize, dictSize); - //LZ4_loadDictHC(LZ4_streamHCPtr, safeBuffer, dictSize); { U32 endIndex = (U32)(streamPtr->end - streamPtr->base); streamPtr->end = (const BYTE*)safeBuffer + dictSize; @@ -749,20 +747,6 @@ int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source char* LZ4_slideInputBufferHC(void* LZ4HC_Data) { LZ4HC_Data_Structure* hc4 = (LZ4HC_Data_Structure*)LZ4HC_Data; - size_t distance = (hc4->end - 64 KB) - hc4->inputBuffer; - - if (hc4->end <= hc4->inputBuffer + 64 KB) return (char*)(hc4->end); /* no update : less than 64KB within buffer */ - - distance = (distance >> 16) << 16; /* Must be a multiple of 64 KB */ - LZ4HC_Insert(hc4, hc4->end - MINMATCH); - memcpy((void*)(hc4->end - 64 KB - distance), (const void*)(hc4->end - 64 KB), 64 KB); - hc4->base -= distance; - if ((U32)(hc4->inputBuffer - hc4->base) > 1 GB + 64 KB) /* Avoid overflow */ - { - int i; - hc4->base += 1 GB; - for (i=0; ihashTable[i] -= 1 GB; - } - hc4->end -= distance; - return (char*)(hc4->end); + int dictSize = LZ4_saveDictHC((LZ4_streamHC_t*)LZ4HC_Data, (char*)(hc4->inputBuffer), 64 KB); + return (char*)(hc4->inputBuffer + dictSize); } From b827ecf72894156c1727482b145dc9e7a116dbc9 Mon Sep 17 00:00:00 2001 From: Yann Collet Date: Wed, 3 Dec 2014 23:19:11 +0100 Subject: [PATCH 22/22] Clarified a few comments --- Makefile | 7 +++--- NEWS | 1 + lib/lz4.c | 8 +++--- lib/lz4.h | 9 +++++-- lib/lz4hc.c | 4 +-- lib/lz4hc.h | 71 +++++++++-------------------------------------------- 6 files changed, 28 insertions(+), 72 deletions(-) diff --git a/Makefile b/Makefile index 66c8c4b..f5bf4b5 100644 --- a/Makefile +++ b/Makefile @@ -72,12 +72,13 @@ endif default: lz4programs - @cd $(PRGDIR); $(MAKE) -e -all: lz4programs +all: + @cd $(LZ4DIR); $(MAKE) -e all + @cd $(PRGDIR); $(MAKE) -e all lz4programs: - @cd $(PRGDIR); $(MAKE) -e all + @cd $(PRGDIR); $(MAKE) -e clean: @rm -f $(DISTRIBNAME) *.sha1 diff --git a/NEWS b/NEWS index f49535d..45e1871 100644 --- a/NEWS +++ b/NEWS @@ -3,6 +3,7 @@ Changed : endian and alignment code Changed : directory structure : new "lib" directory Updated : lz4io, now uses lz4frame Fixed : some alignment warnings under clang +Fixed : deprecated function LZ4_slideInputBufferHC() r124: New : LZ4 HC streaming mode diff --git a/lib/lz4.c b/lib/lz4.c index f8186b4..f70ac46 100644 --- a/lib/lz4.c +++ b/lib/lz4.c @@ -1316,11 +1316,9 @@ void* LZ4_create (const char* inputBuffer) char* LZ4_slideInputBuffer (void* LZ4_Data) { - LZ4_stream_t_internal* lz4ds = (LZ4_stream_t_internal*)LZ4_Data; - - LZ4_saveDict((LZ4_stream_t*)LZ4_Data, (char*)lz4ds->bufferStart, 64 KB); - - return (char*)(lz4ds->bufferStart + 64 KB); + LZ4_stream_t_internal* ctx = (LZ4_stream_t_internal*)LZ4_Data; + int dictSize = LZ4_saveDict((LZ4_stream_t*)ctx, (char*)ctx->bufferStart, 64 KB); + return (char*)(ctx->bufferStart + dictSize); } /* Obsolete compresson functions using User-allocated state */ diff --git a/lib/lz4.h b/lib/lz4.h index 22bbcb5..7392320 100644 --- a/lib/lz4.h +++ b/lib/lz4.h @@ -178,6 +178,8 @@ int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedS * LZ4_stream_t * information structure to track an LZ4 stream. * important : init this structure content before first use ! + * note : only allocated directly the structure if you are statically linking LZ4 + * If you are using liblz4 as a DLL, please use below construction methods instead. */ typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t; @@ -188,9 +190,10 @@ typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t; void LZ4_resetStream (LZ4_stream_t* LZ4_streamPtr); /* - * If you prefer dynamic allocation methods, * LZ4_createStream will allocate and initialize an LZ4_stream_t structure * LZ4_freeStream releases its memory. + * In the context of a DLL (liblz4), please use these methods rather than the static struct. + * They are more future proof, in case of a change of LZ4_stream_t size. */ LZ4_stream_t* LZ4_createStream(void); int LZ4_freeStream (LZ4_stream_t* LZ4_streamPtr); @@ -241,7 +244,9 @@ typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_strea * LZ4_streamDecode_t * information structure to track an LZ4 stream. * init this structure content using LZ4_setStreamDecode or memset() before first use ! - * If you prefer dynamic allocation methods : + * + * In the context of a DLL (liblz4) please prefer usage of construction methods below. + * They are more future proof, in case of a change of LZ4_streamDecode_t size in the future. * LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure * LZ4_freeStreamDecode releases its memory. */ diff --git a/lib/lz4hc.c b/lib/lz4hc.c index c3e0b6d..6690e81 100644 --- a/lib/lz4hc.c +++ b/lib/lz4hc.c @@ -556,8 +556,8 @@ int LZ4_compressHC_limitedOutput(const char* source, char* dest, int inputSize, /***************************** - Using external allocation -*****************************/ + * Using external allocation + * ***************************/ int LZ4_sizeofStateHC(void) { return sizeof(LZ4HC_Data_Structure); } diff --git a/lib/lz4hc.h b/lib/lz4hc.h index 26ba6d3..ce813ab 100644 --- a/lib/lz4hc.h +++ b/lib/lz4hc.h @@ -108,21 +108,24 @@ They just use the externally allocated memory for state instead of allocating th #define LZ4_STREAMHCSIZE_U64 32774 #define LZ4_STREAMHCSIZE (LZ4_STREAMHCSIZE_U64 * sizeof(unsigned long long)) typedef struct { unsigned long long table[LZ4_STREAMHCSIZE_U64]; } LZ4_streamHC_t; - /* +LZ4_streamHC_t This structure allows static allocation of LZ4 HC streaming state. State must then be initialized using LZ4_resetStreamHC() before first use. -If you prefer dynamic allocation, please refer to functions below. +Static allocation should only be used with statically linked library. +If you want to use LZ4 as a DLL, please use construction functions below, which are more future-proof. */ + LZ4_streamHC_t* LZ4_createStreamHC(void); int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr); - /* These functions create and release memory for LZ4 HC streaming state. Newly created states are already initialized. Existing state space can be re-used anytime using LZ4_resetStreamHC(). +If you use LZ4 as a DLL, please use these functions instead of direct struct allocation, +to avoid size mismatch between different versions. */ void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel); @@ -152,70 +155,18 @@ using LZ4_saveDictHC(). /************************************** - Deprecated Streaming Functions -**************************************/ -/* Note : these streaming functions still follows the older model */ + * Deprecated Streaming Functions + * ************************************/ +/* Note : these streaming functions follows the older model, and should no longer be used */ void* LZ4_createHC (const char* inputBuffer); -//int LZ4_compressHC_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize); -//int LZ4_compressHC_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize); char* LZ4_slideInputBufferHC (void* LZ4HC_Data); int LZ4_freeHC (void* LZ4HC_Data); int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel); int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel); -/* -These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks. -In order to achieve this, it is necessary to start creating the LZ4HC Data Structure, thanks to the function : - -void* LZ4_createHC (const char* inputBuffer); -The result of the function is the (void*) pointer on the LZ4HC Data Structure. -This pointer will be needed in all other functions. -If the pointer returned is NULL, then the allocation has failed, and compression must be aborted. -The only parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. -The input buffer must be already allocated, and size at least 192KB. -'inputBuffer' will also be the 'const char* source' of the first block. - -All blocks are expected to lay next to each other within the input buffer, starting from 'inputBuffer'. -To compress each block, use either LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(). -Their behavior are identical to LZ4_compressHC() or LZ4_compressHC_limitedOutput(), -but require the LZ4HC Data Structure as their first argument, and check that each block starts right after the previous one. -If next block does not begin immediately after the previous one, the compression will fail (return 0). - -When it's no longer possible to lay the next block after the previous one (not enough space left into input buffer), a call to : -char* LZ4_slideInputBufferHC(void* LZ4HC_Data); -must be performed. It will typically copy the latest 64KB of input at the beginning of input buffer. -Note that, for this function to work properly, minimum size of an input buffer must be 192KB. -==> The memory position where the next input data block must start is provided as the result of the function. - -Compression can then resume, using LZ4_compressHC_continue() or LZ4_compressHC_limitedOutput_continue(), as usual. - -When compression is completed, a call to LZ4_freeHC() will release the memory used by the LZ4HC Data Structure. -*/ - -int LZ4_sizeofStreamStateHC(void); -int LZ4_resetStreamStateHC(void* state, const char* inputBuffer); - -/* -These functions achieve the same result as : -void* LZ4_createHC (const char* inputBuffer); - -They are provided here to allow the user program to allocate memory using its own routines. - -To know how much space must be allocated, use LZ4_sizeofStreamStateHC(); -Note also that space must be aligned for pointers (32 or 64 bits). - -Once space is allocated, you must initialize it using : LZ4_resetStreamStateHC(void* state, const char* inputBuffer); -void* state is a pointer to the space allocated. -It must be aligned for pointers (32 or 64 bits), and be large enough. -The parameter 'const char* inputBuffer' must, obviously, point at the beginning of input buffer. -The input buffer must be already allocated, and size at least 192KB. -'inputBuffer' will also be the 'const char* source' of the first block. - -The same space can be re-used multiple times, just by initializing it each time with LZ4_resetStreamState(). -return value of LZ4_resetStreamStateHC() must be 0 is OK. -Any other value means there was an error (typically, state is not aligned for pointers (32 or 64 bits)). -*/ +int LZ4_sizeofStreamStateHC(void); +int LZ4_resetStreamStateHC(void* state, const char* inputBuffer); #if defined (__cplusplus)