Merge pull request #72 from Cyan4973/dev

Dev

Makefile

@@ -32,7 +32,7 @@
 # ################################################################
 
 # Version number
-export VERSION := 0.3.3
+export VERSION := 0.3.6
 
 PRGDIR  = programs
 ZSTDDIR = lib

NEWS

@@ -1,3 +1,12 @@
+v0.3.6
+small blocks params
+
+v0.3.5
+minor generic compression improvements
+
+v0.3.4
+Faster fast cLevels
+
 v0.3.3
 Small compression ratio improvement
 

README.md

@@ -7,7 +7,7 @@ It is provided as a BSD-license package, hosted on Github.
 |master      | [![Build Status](https://travis-ci.org/Cyan4973/zstd.svg?branch=master)](https://travis-ci.org/Cyan4973/zstd) |
 |dev         | [![Build Status](https://travis-ci.org/Cyan4973/zstd.svg?branch=dev)](https://travis-ci.org/Cyan4973/zstd) |
 
-For a taste of its performance, here are a few benchmark numbers from a number of compression codecs suitable for real-time. The test was completed on a Core i7-5600U @ 2.6 GHz, using [fsbench 0.14.3](http://encode.ru/threads/1371-Filesystem-benchmark?p=34029&viewfull=1#post34029), an open-source benchmark program by m^2.
+For a taste of its performance, here are a few benchmark numbers from a number of compression codecs suitable for real-time. The test was completed on a Core i7-5600U @ 2.6 GHz, using m^2's [fsbench 0.14.3](http://encode.ru/threads/1371-Filesystem-benchmark?p=34029&viewfull=1#post34029) compiled with gcc 4.8.4, on the [Silesia compression corpus](http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia).
 
 |Name             | Ratio | C.speed | D.speed |
 |-----------------|-------|--------:|--------:|
@@ -23,7 +23,7 @@ For a taste of its performance, here are a few benchmark numbers from a number o
 [zlib]:http://www.zlib.net/
 [LZ4]:http://www.lz4.org/
 
-Zstd can also offer stronger compression ratio at the cost of compression speed. Speed / Ratio trade-off is configurable by small increment, to fit different situations. Note however that decompression speed is preserved and remain roughly the same at all settings, a property shared by most LZ compression algorithms, such as [zlib]. The following test is run on a Core i7-3930K CPU @ 4.5GHz, using [lzbench], an open-source in-memory benchmark by inikep, on the [Silesia compression corpus](http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia)
+Zstd can also offer stronger compression ratio at the cost of compression speed. Speed / Ratio trade-off is configurable by small increment, to fit different situations. Note however that decompression speed is preserved and remain roughly the same at all settings, a property shared by most LZ compression algorithms, such as [zlib]. The following test is run on a Core i7-3930K CPU @ 4.5GHz, using [lzbench], an open-source in-memory benchmark by inikep compiled with gcc 5.2.1, on the [Silesia compression corpus](http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia).
 
 [lzbench]:https://github.com/inikep/lzbench
 
@@ -32,9 +32,9 @@ Compression Speed vs Ratio | Decompression Speed
 ![Compression Speed vs Ratio](images/CSpeed.png "Compression Speed vs Ratio") | ![Decompression Speed](images/DSpeed.png "Decompression Speed")
 
 
-Zstd entropy stage is provided by [Huff0 and FSE, from Finite State Entrop library](https://github.com/Cyan4973/FiniteStateEntropy).
+Zstd entropy stage is provided by [Huff0 and FSE, from Finite State Entropy library](https://github.com/Cyan4973/FiniteStateEntropy).
 
-Its memory requirement can also be configured to fit into low-memory hardware configurations, or servers handling multiple connections/contexts in parallel.
+Its memory requirement can be configured to fit into low-memory hardware configurations, or servers handling multiple connections/contexts in parallel.
 
 Zstd has not yet reached "stable format" status. It doesn't guarantee yet that its current compressed format will remain stable and supported in future versions. During this period, it can still change to adapt new optimizations still being investigated. "Stable Format" is projected sometimes early 2016. 
 

lib/zstd.c

@@ -125,7 +125,6 @@
 
 static const U32 g_maxDistance = 4 * BLOCKSIZE;
 static const U32 g_maxLimit = 1 GB;
-static const U32 g_searchStrength = 8;
 
 #define WORKPLACESIZE (BLOCKSIZE*3)
 #define MINMATCH 4
@@ -524,8 +523,6 @@ static U32   ZSTD_hashPtr(const void* p) { return ( (MEM_read64(p) * prime7bytes
 
 //static U32   ZSTD_hashPtr(const void* p) { return ( (*(U32*)p * KNUTH) >> (32-HASH_LOG)); }
 
-static void  ZSTD_addPtr(U32* table, const BYTE* p, const BYTE* start) { table[ZSTD_hashPtr(p)] = (U32)(p-start); }
-
 static const BYTE* ZSTD_updateMatch(U32* table, const BYTE* p, const BYTE* start)
 {
     U32 h = ZSTD_hashPtr(p);
@@ -540,6 +537,8 @@ static int ZSTD_checkMatch(const BYTE* match, const BYTE* ip)
     return MEM_read32(match) == MEM_read32(ip);
 }
 
+static void  ZSTD_addPtr(U32* table, const BYTE* p, const BYTE* start) { table[ZSTD_hashPtr(p)] = (U32)(p-start); }
+
 
 static size_t ZSTD_compressBlock(ZSTD_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
 {

lib/zstd.h

@@ -48,7 +48,7 @@ extern "C" {
 ***************************************/
 #define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
 #define ZSTD_VERSION_MINOR    3    /* for new (non-breaking) interface capabilities */
-#define ZSTD_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */
+#define ZSTD_VERSION_RELEASE  6    /* for tweaks, bug-fixes, or development */
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
 unsigned ZSTD_versionNumber (void);
 

lib/zstd_internal.h

@@ -206,6 +206,8 @@ typedef struct {
 
 void ZSTD_resetSeqStore(seqStore_t* ssPtr);
 
+static const U32 g_searchStrength = 8;
+
 #define REPCODE_STARTVALUE 4
 #define MLbits   7
 #define LLbits   6
@@ -217,7 +219,6 @@ void ZSTD_resetSeqStore(seqStore_t* ssPtr);
 #define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
 #define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
 
-
 /** ZSTD_storeSeq
     Store a sequence (literal length, literals, offset code and match length) into seqStore_t
     @offsetCode : distance to match, or 0 == repCode
@@ -225,6 +226,14 @@ void ZSTD_resetSeqStore(seqStore_t* ssPtr);
 */
 MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const BYTE* literals, size_t offsetCode, size_t matchCode)
 {
+#if 0
+    static const BYTE* g_start = NULL;
+    if (g_start==NULL) g_start = literals;
+    if (literals - g_start == 8695)
+    printf("pos %6u : %3u literals & match %3u bytes at distance %6u \n",
+           (U32)(literals - g_start), (U32)litLength, (U32)matchCode+4, (U32)offsetCode);
+#endif
+
     /* copy Literals */
     ZSTD_wildcopy(seqStorePtr->lit, literals, litLength);
     seqStorePtr->lit += litLength;

lib/zstdhc.c

@@ -91,7 +91,7 @@ struct ZSTD_HC_CCtx_s
 
     seqStore_t seqStore;    /* sequences storage ptrs */
     U32* hashTable;
-    U32* chainTable;
+    U32* contentTable;
 };
 
 
@@ -111,23 +111,23 @@ size_t ZSTD_HC_freeCCtx(ZSTD_HC_CCtx* cctx)
 /** ZSTD_HC_validateParams
     correct params value to remain within authorized range
     optimize for srcSize if srcSize > 0 */
-void ZSTD_HC_validateParams(ZSTD_HC_parameters* params, size_t srcSize)
+void ZSTD_HC_validateParams(ZSTD_HC_parameters* params, U64 srcSizeHint)
 {
-    const U32 chainplus = (params->strategy == ZSTD_HC_btlazy2);
+    const U32 btPlus = (params->strategy == ZSTD_HC_btlazy2);
 
     /* validate params */
     if (params->windowLog   > ZSTD_HC_WINDOWLOG_MAX) params->windowLog = ZSTD_HC_WINDOWLOG_MAX;
     if (params->windowLog   < ZSTD_HC_WINDOWLOG_MIN) params->windowLog = ZSTD_HC_WINDOWLOG_MIN;
 
     /* correct params, to use less memory */
-    if (srcSize > 0)
+    if ((srcSizeHint > 0) && (srcSizeHint < (1<<ZSTD_HC_WINDOWLOG_MAX)))
     {
-        U32 srcLog = ZSTD_highbit((U32)srcSize-1) + 1;
+        U32 srcLog = ZSTD_highbit((U32)srcSizeHint-1) + 1;
         if (params->windowLog > srcLog) params->windowLog = srcLog;
     }
 
-    if (params->chainLog    > params->windowLog + chainplus) params->chainLog = params->windowLog+chainplus;   /* <= ZSTD_HC_CHAINLOG_MAX */
-    if (params->chainLog    < ZSTD_HC_CHAINLOG_MIN) params->chainLog = ZSTD_HC_CHAINLOG_MIN;
+    if (params->contentLog  > params->windowLog+btPlus) params->contentLog = params->windowLog+btPlus;   /* <= ZSTD_HC_CONTENTLOG_MAX */
+    if (params->contentLog  < ZSTD_HC_CONTENTLOG_MIN) params->contentLog = ZSTD_HC_CONTENTLOG_MIN;
     if (params->hashLog     > ZSTD_HC_HASHLOG_MAX) params->hashLog = ZSTD_HC_HASHLOG_MAX;
     if (params->hashLog     < ZSTD_HC_HASHLOG_MIN) params->hashLog = ZSTD_HC_HASHLOG_MIN;
     if (params->searchLog   > ZSTD_HC_SEARCHLOG_MAX) params->searchLog = ZSTD_HC_SEARCHLOG_MAX;
@@ -135,18 +135,19 @@ void ZSTD_HC_validateParams(ZSTD_HC_parameters* params, size_t srcSize)
     if (params->searchLength> ZSTD_HC_SEARCHLENGTH_MAX) params->searchLength = ZSTD_HC_SEARCHLENGTH_MAX;
     if (params->searchLength< ZSTD_HC_SEARCHLENGTH_MIN) params->searchLength = ZSTD_HC_SEARCHLENGTH_MIN;
     if ((U32)params->strategy>(U32)ZSTD_HC_btlazy2) params->strategy = ZSTD_HC_btlazy2;
-    if ((int)params->strategy<(int)ZSTD_HC_greedy) params->strategy = ZSTD_HC_greedy;
 }
 
 
 static size_t ZSTD_HC_resetCCtx_advanced (ZSTD_HC_CCtx* zc,
-                                          ZSTD_HC_parameters params)
+                                          ZSTD_HC_parameters params,
+                                          U64 srcSizeHint)
 {
-    ZSTD_HC_validateParams(&params, 0);
+    ZSTD_HC_validateParams(&params, srcSizeHint);
 
     /* reserve table memory */
     {
-        const size_t tableSpace = ((1 << params.chainLog) + (1 << params.hashLog)) * sizeof(U32);
+        const U32 contentLog = params.strategy == ZSTD_HC_fast ? 1 : params.contentLog;
+        const size_t tableSpace = ((1 << contentLog) + (1 << params.hashLog)) * sizeof(U32);
         const size_t neededSpace = tableSpace + WORKPLACESIZE;
         if (zc->workSpaceSize < neededSpace)
         {
@@ -155,13 +156,13 @@ static size_t ZSTD_HC_resetCCtx_advanced (ZSTD_HC_CCtx* zc,
             zc->workSpace = malloc(neededSpace);
             if (zc->workSpace == NULL) return ERROR(memory_allocation);
         }
-        zc->hashTable = (U32*)zc->workSpace;
-        zc->chainTable = zc->hashTable + ((size_t)1 << params.hashLog);
-        zc->seqStore.buffer = (void*) (zc->chainTable + ((size_t)1 << params.chainLog));
-        memset(zc->hashTable, 0, tableSpace );
+        memset(zc->workSpace, 0, tableSpace );
+        zc->hashTable = (U32*)(zc->workSpace);
+        zc->contentTable = zc->hashTable + ((size_t)1 << params.hashLog);
+        zc->seqStore.buffer = (void*) (zc->contentTable + ((size_t)1 << contentLog));
     }
 
-    zc->nextToUpdate = 0;
+    zc->nextToUpdate = 1;
     zc->end = NULL;
     zc->base = NULL;
     zc->dictBase = NULL;
@@ -195,6 +196,10 @@ static const U64 prime6bytes = 227718039650203ULL;
 static size_t ZSTD_HC_hash6(U64 u, U32 h) { return (size_t)((u * prime6bytes) << (64-48) >> (64-h)) ; }
 static size_t ZSTD_HC_hash6Ptr(const void* p, U32 h) { return ZSTD_HC_hash6(MEM_read64(p), h); }
 
+static const U64 prime7bytes =    58295818150454627ULL;
+static size_t ZSTD_HC_hash7(U64 u, U32 h) { return (size_t)((u * prime7bytes) << (64-56) >> (64-h)) ; }
+static size_t ZSTD_HC_hash7Ptr(const void* p, U32 h) { return ZSTD_HC_hash7(MEM_read64(p), h); }
+
 static size_t ZSTD_HC_hashPtr(const void* p, U32 hBits, U32 mls)
 {
     switch(mls)
@@ -203,10 +208,108 @@ static size_t ZSTD_HC_hashPtr(const void* p, U32 hBits, U32 mls)
     case 4: return ZSTD_HC_hash4Ptr(p, hBits);
     case 5: return ZSTD_HC_hash5Ptr(p, hBits);
     case 6: return ZSTD_HC_hash6Ptr(p, hBits);
+    case 7: return ZSTD_HC_hash7Ptr(p, hBits);
     }
 }
 
-#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & mask]
+/* *************************************
+*  Fast Scan
+***************************************/
+
+FORCE_INLINE
+size_t ZSTD_HC_compressBlock_fast_generic(ZSTD_HC_CCtx* ctx,
+                                          void* dst, size_t maxDstSize,
+                                    const void* src, size_t srcSize,
+                                    const U32 mls)
+{
+    U32* hashTable = ctx->hashTable;
+    const U32 hBits = ctx->params.hashLog;
+    seqStore_t* seqStorePtr = &(ctx->seqStore);
+    const BYTE* const base = ctx->base;
+    const size_t maxDist = ((size_t)1 << ctx->params.windowLog);
+
+    const BYTE* const istart = (const BYTE*)src;
+    const BYTE* ip = istart;
+    const BYTE* anchor = istart;
+    const BYTE* const lowest = (size_t)(istart-base) > maxDist ? istart-maxDist : base;
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* const ilimit = iend - 8;
+
+    size_t offset_2=4, offset_1=4;
+
+
+    /* init */
+    if (ip == base)
+    {
+        hashTable[ZSTD_HC_hashPtr(base+1, hBits, mls)] = 1;
+        hashTable[ZSTD_HC_hashPtr(base+2, hBits, mls)] = 2;
+        hashTable[ZSTD_HC_hashPtr(base+3, hBits, mls)] = 3;
+        ip = base+4;
+    }
+    ZSTD_resetSeqStore(seqStorePtr);
+
+    /* Main Search Loop */
+    while (ip < ilimit)  /* < instead of <=, because unconditionnal ZSTD_addPtr(ip+1) */
+    {
+        const size_t h = ZSTD_HC_hashPtr(ip, hBits, mls);
+        const BYTE* match = base + hashTable[h];
+        hashTable[h] = (U32)(ip-base);
+
+        if (MEM_read32(ip-offset_2) == MEM_read32(ip)) match = ip-offset_2;
+        if ( (match < lowest) ||
+             (MEM_read32(match) != MEM_read32(ip)) )
+        { ip += ((ip-anchor) >> g_searchStrength) + 1; offset_2 = offset_1; continue; }
+        while ((ip>anchor) && (match>base) && (ip[-1] == match[-1])) { ip--; match--; }  /* catch up */
+
+        {
+            size_t litLength = ip-anchor;
+            size_t matchLength = ZSTD_count(ip+MINMATCH, match+MINMATCH, iend);
+            size_t offsetCode = ip-match;
+            if (offsetCode == offset_2) offsetCode = 0;
+            offset_2 = offset_1;
+            offset_1 = ip-match;
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offsetCode, matchLength);
+
+            /* Fill Table */
+            hashTable[ZSTD_HC_hashPtr(ip+1, hBits, mls)] = (U32)(ip+1-base);
+            ip += matchLength + MINMATCH;
+            anchor = ip;
+            if (ip < ilimit) /* same test as loop, for speed */
+                hashTable[ZSTD_HC_hashPtr(ip-2, hBits, mls)] = (U32)(ip-2-base);
+        }
+    }
+
+    /* Last Literals */
+    {
+        size_t lastLLSize = iend - anchor;
+        memcpy(seqStorePtr->lit, anchor, lastLLSize);
+        seqStorePtr->lit += lastLLSize;
+    }
+
+    /* Finale compression stage */
+    return ZSTD_compressSequences((BYTE*)dst, maxDstSize,
+                                  seqStorePtr, srcSize);
+}
+
+
+size_t ZSTD_HC_compressBlock_fast(ZSTD_HC_CCtx* ctx,
+                               void* dst, size_t maxDstSize,
+                         const void* src, size_t srcSize)
+{
+    const U32 mls = ctx->params.searchLength;
+    switch(mls)
+    {
+    default:
+    case 4 :
+        return ZSTD_HC_compressBlock_fast_generic(ctx, dst, maxDstSize, src, srcSize, 4);
+    case 5 :
+        return ZSTD_HC_compressBlock_fast_generic(ctx, dst, maxDstSize, src, srcSize, 5);
+    case 6 :
+        return ZSTD_HC_compressBlock_fast_generic(ctx, dst, maxDstSize, src, srcSize, 6);
+    case 7 :
+        return ZSTD_HC_compressBlock_fast_generic(ctx, dst, maxDstSize, src, srcSize, 7);
+    }
+}
 
 
 /* *************************************
@@ -214,18 +317,19 @@ static size_t ZSTD_HC_hashPtr(const void* p, U32 hBits, U32 mls)
 ***************************************/
 /** ZSTD_HC_insertBt1 : add one ptr to tree
     @ip : assumed <= iend-8 */
-static void ZSTD_HC_insertBt1(ZSTD_HC_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares)
+static U32 ZSTD_HC_insertBt1(ZSTD_HC_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares)
 {
     U32* const hashTable = zc->hashTable;
     const U32 hashLog = zc->params.hashLog;
     const size_t h  = ZSTD_HC_hashPtr(ip, hashLog, mls);
-    U32* const bt   = zc->chainTable;
-    const U32 btLog = zc->params.chainLog - 1;
+    U32* const bt   = zc->contentTable;
+    const U32 btLog = zc->params.contentLog - 1;
     const U32 btMask= (1 << btLog) - 1;
     U32 matchIndex  = hashTable[h];
     size_t commonLengthSmaller=0, commonLengthLarger=0;
     const BYTE* const base = zc->base;
-    const U32 current = (U32)(ip-base);
+    const BYTE* match = base + matchIndex;
+    U32 current = (U32)(ip-base);
     const U32 btLow = btMask >= current ? 0 : current - btMask;
     U32* smallerPtr = bt + 2*(current&btMask);
     U32* largerPtr  = bt + 2*(current&btMask) + 1;
@@ -233,14 +337,21 @@ static void ZSTD_HC_insertBt1(ZSTD_HC_CCtx* zc, const BYTE* const ip, const U32
     const U32 windowSize = 1 << zc->params.windowLog;
     const U32 windowLow = windowSize >= current ? 0 : current - windowSize;
 
-    hashTable[h] = (U32)(ip-base);   /* Update Hash Table */
+    if ((current-matchIndex == 1)   /* RLE */
+        && MEM_read64(match) == MEM_read64(ip))
+    {
+        size_t rleLength = ZSTD_count(ip+sizeof(size_t), match+sizeof(size_t), iend) + sizeof(size_t);
+        return (U32)(rleLength - mls);
+    }
+
+    hashTable[h] = (U32)(ip - base);   /* Update Hash Table */
 
     while (nbCompares-- && (matchIndex > windowLow))
     {
         U32* nextPtr = bt + 2*(matchIndex & btMask);
-        const BYTE* match = base + matchIndex;
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
 
+        match = base + matchIndex;
         matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
 
         if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */
@@ -267,6 +378,7 @@ static void ZSTD_HC_insertBt1(ZSTD_HC_CCtx* zc, const BYTE* const ip, const U32
     }
 
     *smallerPtr = *largerPtr = 0;
+    return 1;
 }
 
 
@@ -280,8 +392,8 @@ size_t ZSTD_HC_insertBtAndFindBestMatch (
     U32* const hashTable = zc->hashTable;
     const U32 hashLog = zc->params.hashLog;
     const size_t h  = ZSTD_HC_hashPtr(ip, hashLog, mls);
-    U32* const bt   = zc->chainTable;
-    const U32 btLog = zc->params.chainLog - 1;
+    U32* const bt   = zc->contentTable;
+    const U32 btLog = zc->params.contentLog - 1;
     const U32 btMask= (1 << btLog) - 1;
     U32 matchIndex  = hashTable[h];
     size_t commonLengthSmaller=0, commonLengthLarger=0;
@@ -310,7 +422,7 @@ size_t ZSTD_HC_insertBtAndFindBestMatch (
             if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit(current-matchIndex+1) - ZSTD_highbit((U32)offsetPtr[0]+1)) )
                 bestLength = matchLength, *offsetPtr = current - matchIndex;
             if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */
-                break;   /* drop, next to null, to guarantee consistency (is there a way to do better ?) */
+                break;   /* just drop, to guarantee consistency (miss a little bit of compression) */
         }
 
         if (match[matchLength] < ip[matchLength])
@@ -318,41 +430,41 @@ size_t ZSTD_HC_insertBtAndFindBestMatch (
             /* match is smaller than current */
             *smallerPtr = matchIndex;             /* update smaller idx */
             commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
             smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+            if (matchIndex <= btLow) smallerPtr=&dummy32;  /* beyond tree size, stop the search */
+            matchIndex = (matchIndex <= btLow) ? windowLow : nextPtr[1];
         }
         else
         {
             /* match is larger than current */
             *largerPtr = matchIndex;
             commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
             largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
+            if (matchIndex <= btLow) largerPtr=&dummy32; /* beyond tree size, stop the search */
+            matchIndex = (matchIndex <= btLow) ? windowLow : nextPtr[0];
         }
     }
 
     *smallerPtr = *largerPtr = 0;
 
     zc->nextToUpdate = current+1;   /* current has been inserted */
-    if (bestLength < MINMATCH) return 0;
     return bestLength;
 }
 
 
-static void ZSTD_HC_updateTree(ZSTD_HC_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls)
+static const BYTE* ZSTD_HC_updateTree(ZSTD_HC_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls)
 {
     const BYTE* const base = zc->base;
     const U32 target = (U32)(ip - base);
     U32 idx = zc->nextToUpdate;
     //size_t dummy;
 
-    for( ; idx < target ; idx++)
-        ZSTD_HC_insertBt1(zc, base+idx, mls, iend, nbCompares);
+    for( ; idx < target ; )
+        idx += ZSTD_HC_insertBt1(zc, base+idx, mls, iend, nbCompares);
         //ZSTD_HC_insertBtAndFindBestMatch(zc, base+idx, iend, &dummy, nbCompares, mls);
 
-    zc->nextToUpdate = target;
+    zc->nextToUpdate = idx;
+    return base + idx;
 }
 
 
@@ -364,7 +476,13 @@ size_t ZSTD_HC_BtFindBestMatch (
                         size_t* offsetPtr,
                         const U32 maxNbAttempts, const U32 mls)
 {
-    ZSTD_HC_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
+    const BYTE* nextToUpdate = ZSTD_HC_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
+    if (nextToUpdate > ip)
+    {
+        /* RLE data */
+        *offsetPtr = 1;
+        return ZSTD_count(ip, ip-1, iLimit);
+    }
     return ZSTD_HC_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls);
 }
 
@@ -385,138 +503,19 @@ FORCE_INLINE size_t ZSTD_HC_BtFindBestMatch_selectMLS (
 }
 
 
-size_t ZSTD_HC_compressBlock_btLazy2(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-
-    size_t offset_2=REPCODE_STARTVALUE, offset_1=REPCODE_STARTVALUE;
-    const U32 maxSearches = 1 << ctx->params.searchLog;
-    const U32 mls = ctx->params.searchLength;
-
-    /* init */
-    ZSTD_resetSeqStore(seqStorePtr);
-    if (((ip-ctx->base) - ctx->dictLimit) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;
-
-    /* Match Loop */
-    while (ip <= ilimit)
-    {
-        size_t matchLength;
-        size_t offset=999999;
-        const BYTE* start;
-
-        /* try to find a first match */
-        if (MEM_read32(ip) == MEM_read32(ip - offset_2))
-        {
-            /* repcode : we take it*/
-            size_t offtmp = offset_2;
-            size_t litLength = ip - anchor;
-            matchLength = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_2, iend);
-            offset_2 = offset_1;
-            offset_1 = offtmp;
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, 0, matchLength);
-            ip += matchLength+MINMATCH;
-            anchor = ip;
-            continue;
-        }
-
-        offset_2 = offset_1;
-        matchLength = ZSTD_HC_BtFindBestMatch_selectMLS(ctx, ip, iend, &offset, maxSearches, mls);
-        if (!matchLength) { ip++; continue; }
-
-        /* let's try to find a better solution */
-        start = ip;
-
-        while (ip<ilimit)
-        {
-            ip ++;
-            if (MEM_read32(ip) == MEM_read32(ip - offset_1))
-            {
-                size_t ml2 = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_1, iend) + MINMATCH;
-                int gain2 = (int)(ml2 * 3);
-                int gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1);
-                if (gain2 > gain1)
-                    matchLength = ml2, offset = 0, start = ip;
-            }
-            {
-                size_t offset2=999999;
-                size_t ml2 = ZSTD_HC_BtFindBestMatch_selectMLS(ctx, ip, iend, &offset2, maxSearches, mls);
-                int gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 4);
-                if (gain2 > gain1)
-                {
-                    matchLength = ml2, offset = offset2, start = ip;
-                    continue;   /* search a better one */
-                }
-            }
-
-            /* let's find an even better one */
-            if (ip<ilimit)
-            {
-                ip ++;
-                if (MEM_read32(ip) == MEM_read32(ip - offset_1))
-                {
-                    size_t ml2 = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_1, iend) + MINMATCH;
-                    int gain2 = (int)(ml2 * 4);
-                    int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 1);
-                    if (gain2 > gain1)
-                        matchLength = ml2, offset = 0, start = ip;
-                }
-                {
-                    size_t offset2=999999;
-                    size_t ml2 = ZSTD_HC_BtFindBestMatch_selectMLS(ctx, ip, iend, &offset2, maxSearches, mls);
-                    int gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                    int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 7);
-                    if (gain2 > gain1)
-                    {
-                        matchLength = ml2, offset = offset2, start = ip;
-                        continue;
-                    }
-                }
-            }
-            break;  /* nothing found : store previous solution */
-        }
-
-        /* store sequence */
-        {
-            size_t litLength = start - anchor;
-            if (offset) offset_1 = offset;
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH);
-            ip = start + matchLength;
-            anchor = ip;
-        }
-
-    }
-
-    /* Last Literals */
-    {
-        size_t lastLLSize = iend - anchor;
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-
-    /* Final compression stage */
-    return ZSTD_compressSequences((BYTE*)dst, maxDstSize,
-                                  seqStorePtr, srcSize);
-}
-
-
-
 /* ***********************
 *  Hash Chain
 *************************/
 
+#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & mask]
+
 /* Update chains up to ip (excluded) */
 static U32 ZSTD_HC_insertAndFindFirstIndex  (ZSTD_HC_CCtx* zc, const BYTE* ip, U32 mls)
 {
     U32* const hashTable  = zc->hashTable;
     const U32 hashLog = zc->params.hashLog;
-    U32* const chainTable = zc->chainTable;
-    const U32 chainMask = (1 << zc->params.chainLog) - 1;
+    U32* const chainTable = zc->contentTable;
+    const U32 chainMask = (1 << zc->params.contentLog) - 1;
     const BYTE* const base = zc->base;
     const U32 target = (U32)(ip - base);
     U32 idx = zc->nextToUpdate;
@@ -535,14 +534,14 @@ static U32 ZSTD_HC_insertAndFindFirstIndex  (ZSTD_HC_CCtx* zc, const BYTE* ip, U
 
 
 FORCE_INLINE /* inlining is important to hardwire a hot branch (template emulation) */
-size_t ZSTD_HC_insertAndFindBestMatch (
+size_t ZSTD_HC_HcFindBestMatch (
                         ZSTD_HC_CCtx* zc,   /* Index table will be updated */
                         const BYTE* const ip, const BYTE* const iLimit,
                         size_t* offsetPtr,
                         const U32 maxNbAttempts, const U32 matchLengthSearch)
 {
-    U32* const chainTable = zc->chainTable;
-    const U32 chainSize = (1 << zc->params.chainLog);
+    U32* const chainTable = zc->contentTable;
+    const U32 chainSize = (1 << zc->params.contentLog);
     const U32 chainMask = chainSize-1;
     const BYTE* const base = zc->base;
     const BYTE* const dictBase = zc->dictBase;
@@ -563,22 +562,21 @@ size_t ZSTD_HC_insertAndFindBestMatch (
         if (matchIndex >= dictLimit)
         {
             match = base + matchIndex;
-            if ( (match[ml] == ip[ml])
-              && (MEM_read32(match) == MEM_read32(ip)) )   /* ensures minimum match of 4 */
+            if (match[ml] == ip[ml])   /* potentially better */
             {
-                const size_t mlt = ZSTD_count(ip+MINMATCH, match+MINMATCH, iLimit) + MINMATCH;
+                const size_t mlt = ZSTD_count(ip, match, iLimit);
                 if (mlt > ml)
                 //if (((int)(4*mlt) - (int)ZSTD_highbit((U32)(ip-match)+1)) > ((int)(4*ml) - (int)ZSTD_highbit((U32)((*offsetPtr)+1))))
                 {
                     ml = mlt; *offsetPtr = ip-match;
-                    if (ip+ml >= iLimit) break;
+                    if (ip+mlt >= iLimit) break;
                 }
             }
         }
         else
         {
             match = dictBase + matchIndex;
-            if (MEM_read32(match) == MEM_read32(ip))
+            if (MEM_read32(match) == MEM_read32(ip))   /* beware of end of dict */
             {
                 size_t mlt;
                 const BYTE* vLimit = ip + (dictLimit - matchIndex);
@@ -598,7 +596,7 @@ size_t ZSTD_HC_insertAndFindBestMatch (
 }
 
 
-FORCE_INLINE size_t ZSTD_HC_insertAndFindBestMatch_selectMLS (
+FORCE_INLINE size_t ZSTD_HC_HcFindBestMatch_selectMLS (
                         ZSTD_HC_CCtx* zc,   /* Index table will be updated */
                         const BYTE* ip, const BYTE* const iLimit,
                         size_t* offsetPtr,
@@ -607,14 +605,18 @@ FORCE_INLINE size_t ZSTD_HC_insertAndFindBestMatch_selectMLS (
     switch(matchLengthSearch)
     {
     default :
-    case 4 : return ZSTD_HC_insertAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4);
-    case 5 : return ZSTD_HC_insertAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5);
-    case 6 : return ZSTD_HC_insertAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6);
+    case 4 : return ZSTD_HC_HcFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4);
+    case 5 : return ZSTD_HC_HcFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5);
+    case 6 : return ZSTD_HC_HcFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6);
     }
 }
 
 
-size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+/* common lazy function, to be inlined */
+FORCE_INLINE
+size_t ZSTD_HC_compressBlock_lazy_generic(ZSTD_HC_CCtx* ctx,
+                                     void* dst, size_t maxDstSize, const void* src, size_t srcSize,
+                                     const U32 searchMethod, const U32 deep)   /* 0 : hc; 1 : bt */
 {
     seqStore_t* seqStorePtr = &(ctx->seqStore);
     const BYTE* const istart = (const BYTE*)src;
@@ -627,6 +629,11 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
     const U32 maxSearches = 1 << ctx->params.searchLog;
     const U32 mls = ctx->params.searchLength;
 
+    typedef size_t (*searchMax_f)(ZSTD_HC_CCtx* zc, const BYTE* ip, const BYTE* iLimit,
+                        size_t* offsetPtr,
+                        U32 maxNbAttempts, U32 matchLengthSearch);
+    searchMax_f searchMax = searchMethod ? ZSTD_HC_BtFindBestMatch_selectMLS : ZSTD_HC_HcFindBestMatch_selectMLS;
+
     /* init */
     ZSTD_resetSeqStore(seqStorePtr);
     if (((ip-ctx->base) - ctx->dictLimit) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;
@@ -654,8 +661,12 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
         }
 
         offset_2 = offset_1;
-        matchLength = ZSTD_HC_insertAndFindBestMatch_selectMLS(ctx, ip, iend, &offset, maxSearches, mls);
-        if (!matchLength) { ip++; continue; }
+        matchLength = searchMax(ctx, ip, iend, &offset, maxSearches, mls);
+        if (matchLength < MINMATCH)
+        {
+            ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */
+            continue;
+        }
 
         /* let's try to find a better solution */
         start = ip;
@@ -668,15 +679,15 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
                 size_t ml2 = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_1, iend) + MINMATCH;
                 int gain2 = (int)(ml2 * 3);
                 int gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1);
-                if (gain2 > gain1)
+                if ((ml2 >= MINMATCH) && (gain2 > gain1))
                     matchLength = ml2, offset = 0, start = ip;
             }
             {
                 size_t offset2=999999;
-                size_t ml2 = ZSTD_HC_insertAndFindBestMatch_selectMLS(ctx, ip, iend, &offset2, maxSearches, mls);
-                int gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 4);
-                if (gain2 > gain1)
+                size_t ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
+                int gain2 = (int)(ml2*(3+deep) - ZSTD_highbit((U32)offset2+1));   /* raw approx */
+                int gain1 = (int)(matchLength*(3+deep) - ZSTD_highbit((U32)offset+1) + (3+deep));
+                if ((ml2 >= MINMATCH) && (gain2 > gain1))
                 {
                     matchLength = ml2, offset = offset2, start = ip;
                     continue;   /* search a better one */
@@ -684,7 +695,7 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
             }
 
             /* let's find an even better one */
-            if (ip<ilimit)
+            if (deep && (ip<ilimit))
             {
                 ip ++;
                 if (MEM_read32(ip) == MEM_read32(ip - offset_1))
@@ -692,15 +703,15 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
                     size_t ml2 = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_1, iend) + MINMATCH;
                     int gain2 = (int)(ml2 * 4);
                     int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 1);
-                    if (gain2 > gain1)
+                    if ((ml2 >= MINMATCH) && (gain2 > gain1))
                         matchLength = ml2, offset = 0, start = ip;
                 }
                 {
                     size_t offset2=999999;
-                    size_t ml2 = ZSTD_HC_insertAndFindBestMatch_selectMLS(ctx, ip, iend, &offset2, maxSearches, mls);
+                    size_t ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
                     int gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
                     int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 7);
-                    if (gain2 > gain1)
+                    if ((ml2 >= MINMATCH) && (gain2 > gain1))
                     {
                         matchLength = ml2, offset = offset2, start = ip;
                         continue;
@@ -710,13 +721,19 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
             break;  /* nothing found : store previous solution */
         }
 
+        /* catch up */
+        if (offset)
+        {
+            while ((start>anchor) && (start>ctx->base+offset) && (start[-1] == start[-1-offset]))
+                { start--; matchLength++; }
+        }
+
         /* store sequence */
         {
             size_t litLength = start - anchor;
             if (offset) offset_1 = offset;
             ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH);
-            ip = start + matchLength;
-            anchor = ip;
+            anchor = ip = start + matchLength;
         }
 
     }
@@ -733,103 +750,19 @@ size_t ZSTD_HC_compressBlock_lazydeep(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDs
                                   seqStorePtr, srcSize);
 }
 
+size_t ZSTD_HC_compressBlock_btlazy2(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_HC_compressBlock_lazy_generic(ctx, dst, maxDstSize, src, srcSize, 1, 1);
+}
+
+size_t ZSTD_HC_compressBlock_lazy2(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
+{
+    return ZSTD_HC_compressBlock_lazy_generic(ctx, dst, maxDstSize, src, srcSize, 0, 1);
+}
 
 size_t ZSTD_HC_compressBlock_lazy(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
 {
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-
-    size_t offset_2=REPCODE_STARTVALUE, offset_1=REPCODE_STARTVALUE;
-    const U32 maxSearches = 1 << ctx->params.searchLog;
-    const U32 mls = ctx->params.searchLength;
-
-    /* init */
-    ZSTD_resetSeqStore(seqStorePtr);
-    if (((ip-ctx->base) - ctx->dictLimit) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;
-
-    /* Match Loop */
-    while (ip <= ilimit)
-    {
-        size_t matchLength;
-        size_t offset=0;
-        const BYTE* start;
-
-        /* try to find a first match */
-        if (MEM_read32(ip) == MEM_read32(ip - offset_2))
-        {
-            /* repcode : we take it*/
-            size_t offtmp = offset_2;
-            size_t litLength = ip - anchor;
-            matchLength = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_2, iend);
-            offset_2 = offset_1;
-            offset_1 = offtmp;
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, 0, matchLength);
-            ip += matchLength+MINMATCH;
-            anchor = ip;
-            continue;
-        }
-
-        offset_2 = offset_1;
-        matchLength = ZSTD_HC_insertAndFindBestMatch_selectMLS(ctx, ip, iend, &offset, maxSearches, mls);
-        if (!matchLength) { ip++; continue; }
-
-        /* let's try to find a better solution */
-        start = ip;
-
-        while (ip<ilimit)
-        {
-            ip ++;
-            if (MEM_read32(ip) == MEM_read32(ip - offset_1))
-            {
-                size_t ml2 = ZSTD_count(ip+MINMATCH, ip+MINMATCH-offset_1, iend) + MINMATCH;
-                int gain2 = (int)(ml2 * 3);
-                int gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1);
-                if (gain2 > gain1)
-                {
-                    matchLength = ml2, offset = 0, start = ip;
-
-                }
-            }
-            {
-                size_t offset2=999999;
-                size_t ml2 = ZSTD_HC_insertAndFindBestMatch_selectMLS(ctx, ip, iend, &offset2, maxSearches, mls);
-                int gain2 = (int)(ml2*3 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                int gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 3);
-                if (gain2 > gain1)
-                {
-                    matchLength = ml2, offset = offset2, start = ip;
-                    continue;   /* search a better one */
-                }
-            }
-
-            break;  /* nothing found : store previous one */
-        }
-
-        /* store sequence */
-        {
-            size_t litLength = start - anchor;
-            if (offset) offset_1 = offset;
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH);
-            ip = start + matchLength;
-            anchor = ip;
-        }
-
-    }
-
-    /* Last Literals */
-    {
-        size_t lastLLSize = iend - anchor;
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-
-    /* Final compression stage */
-    return ZSTD_compressSequences((BYTE*)dst, maxDstSize,
-                                  seqStorePtr, srcSize);
+    return ZSTD_HC_compressBlock_lazy_generic(ctx, dst, maxDstSize, src, srcSize, 0, 0);
 }
 
 
@@ -884,8 +817,13 @@ size_t ZSTD_HC_compressBlock_greedy(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstS
         /* search */
         {
             size_t offset=999999;
-            size_t matchLength = ZSTD_HC_insertAndFindBestMatch_selectMLS(ctx, ip, iend, &offset, maxSearches, mls);
-            if (!matchLength) { ip++; continue; }
+            size_t matchLength = ZSTD_HC_HcFindBestMatch_selectMLS(ctx, ip, iend, &offset, maxSearches, mls);
+            if (matchLength < MINMATCH)
+            {
+                ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */
+                continue;
+            }
+            while ((ip>anchor) && (ip-offset>ctx->base) && (ip[-1] == ip[-1-offset])) { ip--; matchLength++; }  /* catch up */
             /* store sequence */
             {
                 size_t litLength = ip-anchor;
@@ -913,20 +851,21 @@ size_t ZSTD_HC_compressBlock_greedy(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstS
 
 typedef size_t (*ZSTD_HC_blockCompressor) (ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
 
-
 static ZSTD_HC_blockCompressor ZSTD_HC_selectBlockCompressor(ZSTD_HC_strategy strat)
 {
     switch(strat)
     {
     default :
+    case ZSTD_HC_fast:
+        return ZSTD_HC_compressBlock_fast;
     case ZSTD_HC_greedy:
         return ZSTD_HC_compressBlock_greedy;
     case ZSTD_HC_lazy:
         return ZSTD_HC_compressBlock_lazy;
-    case ZSTD_HC_lazydeep:
-        return ZSTD_HC_compressBlock_lazydeep;
+    case ZSTD_HC_lazy2:
+        return ZSTD_HC_compressBlock_lazy2;
     case ZSTD_HC_btlazy2:
-        return ZSTD_HC_compressBlock_btLazy2;
+        return ZSTD_HC_compressBlock_btlazy2;
     }
 }
 
@@ -992,7 +931,7 @@ size_t ZSTD_HC_compressContinue (ZSTD_HC_CCtx* ctxPtr,
     if (ip != ctxPtr->end)
     {
         if (ctxPtr->end != NULL)
-            ZSTD_HC_resetCCtx_advanced(ctxPtr, ctxPtr->params);   /* just reset, but no need to re-alloc */
+            ZSTD_HC_resetCCtx_advanced(ctxPtr, ctxPtr->params, srcSize);
         ctxPtr->base = ip;
     }
 
@@ -1003,22 +942,24 @@ size_t ZSTD_HC_compressContinue (ZSTD_HC_CCtx* ctxPtr,
 
 size_t ZSTD_HC_compressBegin_advanced(ZSTD_HC_CCtx* ctx,
                                       void* dst, size_t maxDstSize,
-                                      const ZSTD_HC_parameters params)
+                                      const ZSTD_HC_parameters params,
+                                      U64 srcSizeHint)
 {
     size_t errorCode;
     if (maxDstSize < 4) return ERROR(dstSize_tooSmall);
-    errorCode = ZSTD_HC_resetCCtx_advanced(ctx, params);
+    errorCode = ZSTD_HC_resetCCtx_advanced(ctx, params, srcSizeHint);
     if (ZSTD_isError(errorCode)) return errorCode;
     MEM_writeLE32(dst, ZSTD_magicNumber); /* Write Header */
     return 4;
 }
 
 
-size_t ZSTD_HC_compressBegin(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, int compressionLevel)
+size_t ZSTD_HC_compressBegin(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, int compressionLevel, U64 srcSizeHint)
 {
+    int tableID = ((srcSizeHint-1) > 128 KB);   /* intentional underflow for 0 */
     if (compressionLevel<=0) compressionLevel = 1;
     if (compressionLevel > ZSTD_HC_MAX_CLEVEL) compressionLevel = ZSTD_HC_MAX_CLEVEL;
-    return ZSTD_HC_compressBegin_advanced(ctx, dst, maxDstSize, ZSTD_HC_defaultParameters[compressionLevel]);
+    return ZSTD_HC_compressBegin_advanced(ctx, dst, maxDstSize, ZSTD_HC_defaultParameters[tableID][compressionLevel], srcSizeHint);
 }
 
 
@@ -1048,12 +989,15 @@ size_t ZSTD_HC_compress_advanced (ZSTD_HC_CCtx* ctx,
     size_t oSize;
 
     /* correct params, to use less memory */
-    U32 srcLog = ZSTD_highbit((U32)srcSize-1) + 1;
-    if (params.windowLog > srcLog) params.windowLog = srcLog;
-    if (params.chainLog > srcLog) params.chainLog = srcLog;
+    {
+        U32 srcLog = ZSTD_highbit((U32)srcSize-1) + 1;
+        U32 contentBtPlus = (ctx->params.strategy == ZSTD_HC_btlazy2);
+        if (params.windowLog > srcLog) params.windowLog = srcLog;
+        if (params.contentLog > srcLog+contentBtPlus) params.contentLog = srcLog+contentBtPlus;
+    }
 
     /* Header */
-    oSize = ZSTD_HC_compressBegin_advanced(ctx, dst, maxDstSize, params);
+    oSize = ZSTD_HC_compressBegin_advanced(ctx, dst, maxDstSize, params, srcSize);
     if(ZSTD_isError(oSize)) return oSize;
     op += oSize;
     maxDstSize -= oSize;
@@ -1075,9 +1019,10 @@ size_t ZSTD_HC_compress_advanced (ZSTD_HC_CCtx* ctx,
 
 size_t ZSTD_HC_compressCCtx (ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel)
 {
+    const int tableID = (srcSize > 128 KB);
     if (compressionLevel<=1) return ZSTD_compress(dst, maxDstSize, src, srcSize);   /* fast mode */
     if (compressionLevel > ZSTD_HC_MAX_CLEVEL) compressionLevel = ZSTD_HC_MAX_CLEVEL;
-    return ZSTD_HC_compress_advanced(ctx, dst, maxDstSize, src, srcSize, ZSTD_HC_defaultParameters[compressionLevel]);
+    return ZSTD_HC_compress_advanced(ctx, dst, maxDstSize, src, srcSize, ZSTD_HC_defaultParameters[tableID][compressionLevel]);
 }
 
 size_t ZSTD_HC_compress(void* dst, size_t maxDstSize, const void* src, size_t srcSize, int compressionLevel)

lib/zstdhc_static.h

@@ -45,27 +45,29 @@ extern "C" {
 /* *************************************
 *  Types
 ***************************************/
-typedef enum { ZSTD_HC_greedy, ZSTD_HC_lazy, ZSTD_HC_lazydeep, ZSTD_HC_btlazy2 } ZSTD_HC_strategy;
+/** from faster to stronger */
+typedef enum { ZSTD_HC_fast, ZSTD_HC_greedy, ZSTD_HC_lazy, ZSTD_HC_lazy2, ZSTD_HC_btlazy2 } ZSTD_HC_strategy;
+
 typedef struct
 {
     U32 windowLog;     /* largest match distance : impact decompression buffer size */
-    U32 chainLog;      /* full search distance : larger == more compression, slower, more memory*/
+    U32 contentLog;    /* full search segment : larger == more compression, slower, more memory (useless for fast) */
     U32 hashLog;       /* dispatch table : larger == more memory, faster*/
     U32 searchLog;     /* nb of searches : larger == more compression, slower*/
     U32 searchLength;  /* size of matches : larger == faster decompression */
-    ZSTD_HC_strategy strategy;   /* greedy, lazy, lazydeep */
+    ZSTD_HC_strategy strategy;
 } ZSTD_HC_parameters;
 
 /* parameters boundaries */
 #define ZSTD_HC_WINDOWLOG_MAX 26
 #define ZSTD_HC_WINDOWLOG_MIN 18
-#define ZSTD_HC_CHAINLOG_MAX (ZSTD_HC_WINDOWLOG_MAX+1)
-#define ZSTD_HC_CHAINLOG_MIN 4
+#define ZSTD_HC_CONTENTLOG_MAX (ZSTD_HC_WINDOWLOG_MAX+1)
+#define ZSTD_HC_CONTENTLOG_MIN 4
 #define ZSTD_HC_HASHLOG_MAX 28
 #define ZSTD_HC_HASHLOG_MIN 4
-#define ZSTD_HC_SEARCHLOG_MAX (ZSTD_HC_CHAINLOG_MAX-1)
+#define ZSTD_HC_SEARCHLOG_MAX (ZSTD_HC_CONTENTLOG_MAX-1)
 #define ZSTD_HC_SEARCHLOG_MIN 1
-#define ZSTD_HC_SEARCHLENGTH_MAX 6
+#define ZSTD_HC_SEARCHLENGTH_MAX 7
 #define ZSTD_HC_SEARCHLENGTH_MIN 4
 
 
@@ -81,14 +83,14 @@ size_t ZSTD_HC_compress_advanced (ZSTD_HC_CCtx* ctx,
 
 /** ZSTD_HC_validateParams
     correct params value to remain within authorized range
-    optimize for srcSize if srcSize > 0 */
-void ZSTD_HC_validateParams(ZSTD_HC_parameters* params, size_t srcSize);
+    srcSizeHint value is optional, select 0 if not known */
+void ZSTD_HC_validateParams(ZSTD_HC_parameters* params, U64 srcSizeHint);
 
 
 /* *************************************
 *  Streaming functions
 ***************************************/
-size_t ZSTD_HC_compressBegin(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, int compressionLevel);
+size_t ZSTD_HC_compressBegin(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, int compressionLevel, U64 srcSizeHint);
 size_t ZSTD_HC_compressContinue(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
 size_t ZSTD_HC_compressEnd(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize);
 
@@ -96,36 +98,59 @@ size_t ZSTD_HC_compressEnd(ZSTD_HC_CCtx* ctx, void* dst, size_t maxDstSize);
 /* *************************************
 *  Pre-defined compression levels
 ***************************************/
-#define ZSTD_HC_MAX_CLEVEL 22
-static const ZSTD_HC_parameters ZSTD_HC_defaultParameters[ZSTD_HC_MAX_CLEVEL+1] = {
+#define ZSTD_HC_MAX_CLEVEL 20
+static const ZSTD_HC_parameters ZSTD_HC_defaultParameters[2][ZSTD_HC_MAX_CLEVEL+1] = {
+{   /* for <= 128 KB */
     /* W,  C,  H,  S,  L, strat */
-    { 18, 12, 14,  1,  4, ZSTD_HC_greedy   },  /* level  0 - never used */
-    { 18, 12, 14,  1,  4, ZSTD_HC_greedy   },  /* level  1 - in fact redirected towards zstd fast */
-    { 18, 12, 15,  2,  4, ZSTD_HC_greedy   },  /* level  2 */
-    { 19, 14, 18,  2,  5, ZSTD_HC_greedy   },  /* level  3 */
-    { 20, 17, 19,  3,  5, ZSTD_HC_greedy   },  /* level  4 */
-    { 20, 18, 19,  2,  5, ZSTD_HC_lazy     },  /* level  5 */
-    { 21, 18, 20,  3,  5, ZSTD_HC_lazy     },  /* level  6 */
-    { 21, 20, 20,  3,  5, ZSTD_HC_lazy     },  /* level  7 */
-    { 21, 19, 20,  4,  5, ZSTD_HC_lazy     },  /* level  8 */
-    { 21, 19, 20,  5,  5, ZSTD_HC_lazy     },  /* level  9 */
-    { 21, 20, 20,  5,  5, ZSTD_HC_lazy     },  /* level 10 */
-    { 21, 20, 20,  5,  5, ZSTD_HC_lazydeep },  /* level 11 */
-    { 22, 20, 22,  5,  5, ZSTD_HC_lazydeep },  /* level 12 */
-    { 22, 20, 22,  6,  5, ZSTD_HC_lazydeep },  /* level 13 */
-    { 22, 21, 22,  6,  5, ZSTD_HC_lazydeep },  /* level 14 */
-    { 22, 21, 22,  6,  5, ZSTD_HC_lazydeep },  /* level 15 */
-    { 22, 21, 22,  5,  5, ZSTD_HC_btlazy2  },  /* level 16 */
-    { 22, 22, 23,  5,  5, ZSTD_HC_btlazy2  },  /* level 17 */
-    { 23, 23, 23,  5,  5, ZSTD_HC_btlazy2  },  /* level 18 */
-    { 25, 25, 22,  5,  5, ZSTD_HC_btlazy2  },  /* level 19 */
-    { 25, 25, 23,  8,  5, ZSTD_HC_btlazy2  },  /* level 20 */
-    { 25, 26, 23,  9,  5, ZSTD_HC_btlazy2  },  /* level 21 */
-    { 25, 26, 23,  9,  5, ZSTD_HC_btlazy2  },  /* level 22 */
+    { 17, 12, 12,  1,  4, ZSTD_HC_fast    },  /* level  0 - never used */
+    { 17, 12, 13,  1,  6, ZSTD_HC_fast    },  /* level  1 */
+    { 17, 15, 16,  1,  5, ZSTD_HC_fast    },  /* level  2 */
+    { 17, 16, 17,  1,  5, ZSTD_HC_fast    },  /* level  3 */
+    { 17, 13, 15,  2,  4, ZSTD_HC_greedy  },  /* level  4 */
+    { 17, 15, 17,  3,  4, ZSTD_HC_greedy  },  /* level  5 */
+    { 17, 14, 17,  3,  4, ZSTD_HC_lazy    },  /* level  6 */
+    { 17, 16, 17,  4,  4, ZSTD_HC_lazy    },  /* level  7 */
+    { 17, 16, 17,  4,  4, ZSTD_HC_lazy2   },  /* level  8 */
+    { 17, 17, 16,  5,  4, ZSTD_HC_lazy2   },  /* level  9 */
+    { 17, 17, 16,  6,  4, ZSTD_HC_lazy2   },  /* level 10 */
+    { 17, 17, 16,  7,  4, ZSTD_HC_lazy2   },  /* level 11 */
+    { 17, 17, 16,  8,  4, ZSTD_HC_lazy2   },  /* level 12 */
+    { 17, 18, 16,  4,  4, ZSTD_HC_btlazy2 },  /* level 13 */
+    { 17, 18, 16,  5,  4, ZSTD_HC_btlazy2 },  /* level 14 */
+    { 17, 18, 16,  6,  4, ZSTD_HC_btlazy2 },  /* level 15 */
+    { 17, 18, 16,  7,  4, ZSTD_HC_btlazy2 },  /* level 16 */
+    { 17, 18, 16,  8,  4, ZSTD_HC_btlazy2 },  /* level 17 */
+    { 17, 18, 16,  9,  4, ZSTD_HC_btlazy2 },  /* level 18 */
+    { 17, 18, 16, 10,  4, ZSTD_HC_btlazy2 },  /* level 19 */
+    { 17, 18, 18, 12,  4, ZSTD_HC_btlazy2 },  /* level 20 */
+},
+{   /* for > 128 KB */
+    /* W,  C,  H,  S,  L, strat */
+    { 18, 12, 12,  1,  4, ZSTD_HC_fast    },  /* level  0 - never used */
+    { 18, 14, 14,  1,  7, ZSTD_HC_fast    },  /* level  1 - in fact redirected towards zstd fast */
+    { 19, 15, 16,  1,  6, ZSTD_HC_fast    },  /* level  2 */
+    { 20, 18, 20,  1,  6, ZSTD_HC_fast    },  /* level  3 */
+    { 21, 19, 21,  1,  6, ZSTD_HC_fast    },  /* level  4 */
+    { 20, 13, 18,  5,  5, ZSTD_HC_greedy  },  /* level  5 */
+    { 20, 17, 19,  3,  5, ZSTD_HC_greedy  },  /* level  6 */
+    { 21, 17, 20,  3,  5, ZSTD_HC_lazy    },  /* level  7 */
+    { 21, 19, 20,  3,  5, ZSTD_HC_lazy    },  /* level  8 */
+    { 21, 20, 20,  3,  5, ZSTD_HC_lazy2   },  /* level  9 */
+    { 21, 19, 20,  4,  5, ZSTD_HC_lazy2   },  /* level 10 */
+    { 22, 20, 22,  4,  5, ZSTD_HC_lazy2   },  /* level 11 */
+    { 22, 20, 22,  5,  5, ZSTD_HC_lazy2   },  /* level 12 */
+    { 22, 21, 22,  5,  5, ZSTD_HC_lazy2   },  /* level 13 */
+    { 22, 22, 23,  5,  5, ZSTD_HC_lazy2   },  /* level 14 */
+    { 23, 23, 23,  5,  5, ZSTD_HC_lazy2   },  /* level 15 */
+    { 23, 21, 22,  5,  5, ZSTD_HC_btlazy2 },  /* level 16 */
+    { 23, 24, 23,  4,  5, ZSTD_HC_btlazy2 },  /* level 17 */
+    { 25, 24, 23,  5,  5, ZSTD_HC_btlazy2 },  /* level 18 */
+    { 25, 26, 23,  5,  5, ZSTD_HC_btlazy2 },  /* level 19 */
+    { 26, 27, 24,  6,  5, ZSTD_HC_btlazy2 },  /* level 20 */
+}
 };
 
 
-
 #if defined (__cplusplus)
 }
 #endif

programs/Makefile

@@ -30,7 +30,7 @@
 # fullbench32: Same as fullbench, but forced to compile in 32-bits mode
 # ##########################################################################
 
-VERSION?= 0.3.3
+VERSION?= 0.3.6
 
 DESTDIR?=
 PREFIX ?= /usr/local

programs/bench.c

@@ -380,7 +380,7 @@ static int BMK_benchMem(void* srcBuffer, size_t srcSize, const char* fileName, i
 }
 
 
-static U64 BMK_GetFileSize(char* infilename)
+static U64 BMK_GetFileSize(const char* infilename)
 {
     int r;
 #if defined(_MSC_VER)

programs/fileio.c

@@ -36,7 +36,7 @@
 /**LEGACY_SUPPORT :
 *  decompressor can decode older formats (starting from Zstd 0.1+) */
 #  define ZSTD_LEGACY_SUPPORT 1
-#endif // ZSTD_LEGACY_SUPPORT
+#endif
 
 
 /* *************************************
@@ -58,11 +58,13 @@
 /* *************************************
 *  Includes
 ***************************************/
-#include <stdio.h>     /* fprintf, fopen, fread, _fileno, stdin, stdout */
-#include <stdlib.h>    /* malloc, free */
-#include <string.h>    /* strcmp, strlen */
-#include <time.h>      /* clock */
-#include <errno.h>     /* errno */
+#include <stdio.h>      /* fprintf, fopen, fread, _fileno, stdin, stdout */
+#include <stdlib.h>     /* malloc, free */
+#include <string.h>     /* strcmp, strlen */
+#include <time.h>       /* clock */
+#include <errno.h>      /* errno */
+#include <sys/types.h>  /* stat64 */
+#include <sys/stat.h>   /* stat64 */
 #include "mem.h"
 #include "fileio.h"
 #include "zstd_static.h"
@@ -91,6 +93,10 @@
 #  define IS_CONSOLE(stdStream) isatty(fileno(stdStream))
 #endif
 
+#if !defined(S_ISREG)
+#  define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
+#endif
+
 
 /* *************************************
 *  Constants
@@ -215,19 +221,35 @@ static void FIO_getFileHandles(FILE** pfinput, FILE** pfoutput, const char* inpu
     if ( *pfoutput==0) EXM_THROW(13, "Pb opening dst : %s", output_filename);
 }
 
+
+static U64 FIO_getFileSize(const char* infilename)
+{
+    int r;
+#if defined(_MSC_VER)
+    struct _stat64 statbuf;
+    r = _stat64(infilename, &statbuf);
+#else
+    struct stat statbuf;
+    r = stat(infilename, &statbuf);
+#endif
+    if (r || !S_ISREG(statbuf.st_mode)) return 0;
+    return (U64)statbuf.st_size;
+}
+
+
 typedef void* (*FIO_createC) (void);
 static void* local_ZSTD_createCCtx(void) { return (void*) ZSTD_createCCtx(); }
 static void* local_ZSTD_HC_createCCtx(void) { return (void*) ZSTD_HC_createCCtx(); }
 
-typedef size_t (*FIO_initC) (void* ctx, void* dst, size_t maxDstSize, int cLevel);
-static size_t local_ZSTD_compressBegin (void* ctx, void* dst, size_t maxDstSize, int cLevel)
+typedef size_t (*FIO_initC) (void* ctx, void* dst, size_t maxDstSize, int cLevel, U64 srcSizeHint);
+static size_t local_ZSTD_compressBegin (void* ctx, void* dst, size_t maxDstSize, int cLevel, U64 srcSizeHint)
 {
-    (void)cLevel;
+    (void)cLevel; (void)srcSizeHint;
     return ZSTD_compressBegin((ZSTD_CCtx*)ctx, dst, maxDstSize);
 }
-static size_t local_ZSTD_HC_compressBegin (void* ctx, void* dst, size_t maxDstSize, int cLevel)
+static size_t local_ZSTD_HC_compressBegin (void* ctx, void* dst, size_t maxDstSize, int cLevel, U64 srcSizeHint)
 {
-    return ZSTD_HC_compressBegin((ZSTD_HC_CCtx*)ctx, dst, maxDstSize, cLevel);
+    return ZSTD_HC_compressBegin((ZSTD_HC_CCtx*)ctx, dst, maxDstSize, cLevel, srcSizeHint);
 }
 
 typedef size_t (*FIO_continueC) (void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
@@ -294,6 +316,7 @@ unsigned long long FIO_compressFilename(const char* output_filename, const char*
         freeC = local_ZSTD_HC_freeCCtx;
     }
     FIO_getFileHandles(&finput, &foutput, input_filename, output_filename);
+    filesize = FIO_getFileSize(input_filename);
 
     /* Allocate Memory */
     ctx = createC();
@@ -304,12 +327,13 @@ unsigned long long FIO_compressFilename(const char* output_filename, const char*
     inEnd = inBuff + inBuffSize;
 
     /* Write Frame Header */
-    cSize = initC(ctx, outBuff, outBuffSize, cLevel);
+    cSize = initC(ctx, outBuff, outBuffSize, cLevel, filesize);
     if (ZSTD_isError(cSize)) EXM_THROW(22, "Compression error : cannot create frame header");
 
     sizeCheck = fwrite(outBuff, 1, cSize, foutput);
     if (sizeCheck!=cSize) EXM_THROW(23, "Write error : cannot write header into %s", output_filename);
     compressedfilesize += cSize;
+    filesize = 0;
 
     /* Main compression loop */
     while (1)

programs/fuzzer.c

@@ -297,7 +297,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
     {
         size_t sampleSize, sampleStart;
         size_t cSize, dSize, dSupSize;
-        U32 sampleSizeLog, buffNb;
+        U32 sampleSizeLog, buffNb, cLevelMod;
         U64 crcOrig, crcDest;
         int cLevel;
 
@@ -328,13 +328,10 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         sampleStart = FUZ_rand(&lseed) % (srcBufferSize - sampleSize);
         crcOrig = XXH64(srcBuffer + sampleStart, sampleSize, 0);
 
-        /* compression test */
-        /* covered by HC cLevel 1
-        cSize = ZSTD_compressCCtx(ctx, cBuffer, cBufferSize, srcBuffer + sampleStart, sampleSize);
-        CHECK(ZSTD_isError(cSize), "ZSTD_compress failed"); */
-
         /* HC compression test */
-        cLevel = (FUZ_rand(&lseed) & 3) +1;
+#define MAX(a,b) ((a)>(b)?(a):(b))
+        cLevelMod = MAX(1, 38 - (int)(MAX(9, sampleSizeLog) * 2));   /* use high compression levels with small samples, for speed */
+        cLevel = (FUZ_rand(&lseed) % cLevelMod) +1;
         cSize = ZSTD_HC_compressCCtx(hcctx, cBuffer, cBufferSize, srcBuffer + sampleStart, sampleSize, cLevel);
         CHECK(ZSTD_isError(cSize), "ZSTD_HC_compressCCtx failed");
 
@@ -358,7 +355,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         dSize = ZSTD_decompress(dstBuffer, sampleSize + dSupSize, cBuffer, cSize);
         CHECK(dSize != sampleSize, "ZSTD_decompress failed (%s) (srcSize : %u ; cSize : %u)", ZSTD_getErrorName(dSize), (U32)sampleSize, (U32)cSize);
         crcDest = XXH64(dstBuffer, sampleSize, 0);
-        CHECK(crcOrig != crcDest, "dstBuffer corrupted (pos %u / %u)", (U32)findDiff(srcBuffer+sampleStart, dstBuffer, sampleSize), (U32)sampleSize);
+        CHECK(crcOrig != crcDest, "decompression result corrupted (pos %u / %u)", (U32)findDiff(srcBuffer+sampleStart, dstBuffer, sampleSize), (U32)sampleSize);
 
         /* truncated src decompression test */
         {

programs/paramgrill.c

@@ -122,7 +122,7 @@ static U32 g_rand = 1;
 static U32 g_singleRun = 0;
 static U32 g_target = 0;
 static U32 g_noSeed = 0;
-static const ZSTD_HC_parameters* g_seedParams = ZSTD_HC_defaultParameters;
+static const ZSTD_HC_parameters* g_seedParams = ZSTD_HC_defaultParameters[0];
 static ZSTD_HC_parameters g_params = { 0, 0, 0, 0, 0, ZSTD_HC_greedy };
 
 void BMK_SetNbIterations(int nbLoops)
@@ -280,7 +280,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
     void* const compressedBuffer = malloc(maxCompressedSize);
     void* const resultBuffer = malloc(srcSize);
     U32 Wlog = params.windowLog;
-    U32 Clog = params.chainLog;
+    U32 Clog = params.contentLog;
     U32 Hlog = params.hashLog;
     U32 Slog = params.searchLog;
     U32 Slength = params.searchLength;
@@ -289,7 +289,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
     U64 crcOrig;
 
     /* Memory allocation & restrictions */
-    snprintf(name, 30, "W%02uC%02uH%02uS%02uL%1ust%1u", Wlog, Clog, Hlog, Slog, Slength, strat);
+    snprintf(name, 30, "Sw%02uc%02uh%02us%02ul%1ut%1u", Wlog, Clog, Hlog, Slog, Slength, strat);
     if (!compressedBuffer || !resultBuffer || !blockTable)
     {
         DISPLAY("\nError: not enough memory!\n");
@@ -429,14 +429,18 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
 }
 
 
-const char* g_stratName[] = { "ZSTD_HC_greedy  ", "ZSTD_HC_lazy    ", "ZSTD_HC_lazydeep", "ZSTD_HC_btlazy2 " };
+const char* g_stratName[] = { "ZSTD_HC_fast   ",
+                              "ZSTD_HC_greedy ",
+                              "ZSTD_HC_lazy   ",
+                              "ZSTD_HC_lazy2  ",
+                              "ZSTD_HC_btlazy2" };
 
 static void BMK_printWinner(FILE* f, U32 cLevel, BMK_result_t result, ZSTD_HC_parameters params, size_t srcSize)
 {
     DISPLAY("\r%79s\r", "");
     fprintf(f,"    {%3u,%3u,%3u,%3u,%3u, %s },  ",
-            params.windowLog, params.chainLog, params.hashLog, params.searchLog, params.searchLength,
-            g_stratName[params.strategy]);
+            params.windowLog, params.contentLog, params.hashLog, params.searchLog, params.searchLength,
+            g_stratName[(U32)(params.strategy)]);
     fprintf(f,
             "/* level %2u */   /* R:%5.3f at %5.1f MB/s - %5.1f MB/s */\n",
             cLevel, (double)srcSize / result.cSize, (double)result.cSpeed / 1000., (double)result.dSpeed / 1000.);
@@ -483,7 +487,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_HC_parameters params,
 
     BMK_benchParam(&testResult, srcBuffer, srcSize, ctx, params);
 
-    for (cLevel = 2; cLevel <= ZSTD_HC_MAX_CLEVEL; cLevel++)
+    for (cLevel = 1; cLevel <= ZSTD_HC_MAX_CLEVEL; cLevel++)
     {
         if (testResult.cSpeed < g_cSpeedTarget[cLevel])
             continue;   /* not fast enough for this level */
@@ -509,8 +513,10 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_HC_parameters params,
             double W_DMemUsed_note = W_ratioNote * ( 40 + 9*cLevel) - log((double)W_DMemUsed);
             double O_DMemUsed_note = O_ratioNote * ( 40 + 9*cLevel) - log((double)O_DMemUsed);
 
-            size_t W_CMemUsed = (1 << params.windowLog) + 4 * (1 << params.hashLog) + 4 * (1 << params.chainLog);
-            size_t O_CMemUsed = (1 << winners[cLevel].params.windowLog) + 4 * (1 << winners[cLevel].params.hashLog) + 4 * (1 << winners[cLevel].params.chainLog);
+            size_t W_CMemUsed = (1 << params.windowLog) + 4 * (1 << params.hashLog) +
+                                ((params.strategy==ZSTD_HC_fast) ? 0 : 4 * (1 << params.contentLog));
+            size_t O_CMemUsed = (1 << winners[cLevel].params.windowLog) + 4 * (1 << winners[cLevel].params.hashLog) +
+                                ((winners[cLevel].params.strategy==ZSTD_HC_fast) ? 0 :  4 * (1 << winners[cLevel].params.contentLog));
             double W_CMemUsed_note = W_ratioNote * ( 50 + 13*cLevel) - log((double)W_CMemUsed);
             double O_CMemUsed_note = O_ratioNote * ( 50 + 13*cLevel) - log((double)O_CMemUsed);
 
@@ -573,24 +579,30 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_HC_parameters params,
     return better;
 }
 
-#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )
 
-static BYTE g_alreadyTested[ZSTD_HC_WINDOWLOG_MAX+1-ZSTD_HC_WINDOWLOG_MIN]
-                           [ZSTD_HC_CHAINLOG_MAX+1-ZSTD_HC_CHAINLOG_MIN]
-                           [ZSTD_HC_HASHLOG_MAX+1-ZSTD_HC_HASHLOG_MIN]
-                           [ZSTD_HC_SEARCHLOG_MAX+1-ZSTD_HC_SEARCHLOG_MIN]
-                           [ZSTD_HC_SEARCHLENGTH_MAX+1-ZSTD_HC_SEARCHLENGTH_MIN]
-                           [4 /* strategy */ ] = {};   /* init to zero */
+/* nullified useless params, to ensure count stats */
+static ZSTD_HC_parameters* sanitizeParams(ZSTD_HC_parameters params)
+{
+    g_params = params;
+    if (params.strategy == ZSTD_HC_fast)
+    {
+        g_params.contentLog = 0;
+        g_params.searchLog = 0;
+    }
+    return &g_params;
+}
+
+#define PARAMTABLELOG   25
+#define PARAMTABLESIZE (1<<PARAMTABLELOG)
+#define PARAMTABLEMASK (PARAMTABLESIZE-1)
+static BYTE g_alreadyTested[PARAMTABLESIZE] = {0};   /* init to zero */
 
 #define NB_TESTS_PLAYED(p) \
-    g_alreadyTested[p.windowLog-ZSTD_HC_WINDOWLOG_MIN] \
-                   [p.chainLog-ZSTD_HC_CHAINLOG_MIN]   \
-                   [p.hashLog-ZSTD_HC_HASHLOG_MIN]     \
-                   [p.searchLog-ZSTD_HC_SEARCHLOG_MIN] \
-                   [p.searchLength-ZSTD_HC_SEARCHLENGTH_MIN] \
-                   [(U32)p.strategy]
+    g_alreadyTested[(XXH64(sanitizeParams(p), sizeof(p), 0) >> 3) & PARAMTABLEMASK]
 
 
+#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )
+
 static void playAround(FILE* f, winnerInfo_t* winners,
                        ZSTD_HC_parameters params,
                        const void* srcBuffer, size_t srcSize,
@@ -611,9 +623,9 @@ static void playAround(FILE* f, winnerInfo_t* winners,
             switch(changeID)
             {
             case 0:
-                p.chainLog++; break;
+                p.contentLog++; break;
             case 1:
-                p.chainLog--; break;
+                p.contentLog--; break;
             case 2:
                 p.hashLog++; break;
             case 3:
@@ -665,17 +677,17 @@ static void BMK_selectRandomStart(
                        const void* srcBuffer, size_t srcSize,
                        ZSTD_HC_CCtx* ctx)
 {
-    U32 id = (FUZ_rand(&g_rand) % ZSTD_HC_MAX_CLEVEL) + 1;
-    if ((id<2) || (winners[id].params.windowLog==0))
+    U32 id = (FUZ_rand(&g_rand) % (ZSTD_HC_MAX_CLEVEL+1));
+    if ((id==0) || (winners[id].params.windowLog==0))
     {
         /* totally random entry */
         ZSTD_HC_parameters p;
-        p.chainLog   = FUZ_rand(&g_rand) % (ZSTD_HC_CHAINLOG_MAX+1 - ZSTD_HC_CHAINLOG_MIN) + ZSTD_HC_CHAINLOG_MIN;
+        p.contentLog = FUZ_rand(&g_rand) % (ZSTD_HC_CONTENTLOG_MAX+1 - ZSTD_HC_CONTENTLOG_MIN) + ZSTD_HC_CONTENTLOG_MIN;
         p.hashLog    = FUZ_rand(&g_rand) % (ZSTD_HC_HASHLOG_MAX+1 - ZSTD_HC_HASHLOG_MIN) + ZSTD_HC_HASHLOG_MIN;
         p.searchLog  = FUZ_rand(&g_rand) % (ZSTD_HC_SEARCHLOG_MAX+1 - ZSTD_HC_SEARCHLOG_MIN) + ZSTD_HC_SEARCHLOG_MIN;
         p.windowLog  = FUZ_rand(&g_rand) % (ZSTD_HC_WINDOWLOG_MAX+1 - ZSTD_HC_WINDOWLOG_MIN) + ZSTD_HC_WINDOWLOG_MIN;
         p.searchLength=FUZ_rand(&g_rand) % (ZSTD_HC_SEARCHLENGTH_MAX+1 - ZSTD_HC_SEARCHLENGTH_MIN) + ZSTD_HC_SEARCHLENGTH_MIN;
-        p.strategy   = (ZSTD_HC_strategy) (FUZ_rand(&g_rand) % 4);
+        p.strategy   = (ZSTD_HC_strategy) (FUZ_rand(&g_rand) % (ZSTD_HC_btlazy2+1));
         playAround(f, winners, p, srcBuffer, srcSize, ctx);
     }
     else
@@ -691,12 +703,13 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
     int i;
     const char* rfName = "grillResults.txt";
     FILE* f;
-    const U32 srcLog = BMK_highbit((U32)( (g_blockSize ? g_blockSize : srcSize) -1))+1;
+    const size_t blockSize = g_blockSize ? g_blockSize : srcSize;
+    const U32 srcLog = BMK_highbit((U32)(blockSize-1))+1;
 
     if (g_singleRun)
     {
         BMK_result_t testResult;
-        ZSTD_HC_validateParams(&g_params, g_blockSize ? g_blockSize : srcSize);
+        ZSTD_HC_validateParams(&g_params, blockSize);
         BMK_benchParam(&testResult, srcBuffer, srcSize, ctx, g_params);
         DISPLAY("\n");
         return;
@@ -708,32 +721,38 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
     if (f==NULL) { DISPLAY("error opening %s \n", rfName); exit(1); }
 
     if (g_target)
-        g_cSpeedTarget[2] = g_target * 1000;
+        g_cSpeedTarget[1] = g_target * 1000;
     else
     {
-        /* baseline config for level 2 */
+        /* baseline config for level 1 */
         BMK_result_t testResult;
-        params = g_seedParams[2];
-        params.windowLog = MIN(srcLog, params.windowLog);
-        params.chainLog = MIN(params.windowLog, params.chainLog);
-        params.searchLog = MIN(params.chainLog, params.searchLog);
+        params.windowLog = 18;
+        params.hashLog = 14;
+        params.contentLog = 1;
+        params.searchLog = 1;
+        params.searchLength = 7;
+        params.strategy = ZSTD_HC_fast;
+        ZSTD_HC_validateParams(&params, blockSize);
         BMK_benchParam(&testResult, srcBuffer, srcSize, ctx, params);
-        g_cSpeedTarget[2] = (testResult.cSpeed * 15) >> 4;
+        g_cSpeedTarget[1] = (testResult.cSpeed * 15) >> 4;
     }
 
-    /* establish speed objectives (relative to level 2) */
-    for (i=3; i<=ZSTD_HC_MAX_CLEVEL; i++)
-        g_cSpeedTarget[i] = (g_cSpeedTarget[i-1] * 13) >> 4;
+    /* establish speed objectives (relative to level 1) */
+    for (i=2; i<=ZSTD_HC_MAX_CLEVEL; i++)
+        g_cSpeedTarget[i] = (g_cSpeedTarget[i-1] * 25) >> 5;
 
     /* populate initial solution */
     {
-        const int maxSeeds = g_noSeed ? 2 : ZSTD_HC_MAX_CLEVEL;
-        for (i=2; i<=maxSeeds; i++)
+        const int tableID = (blockSize > 128 KB);
+        const int maxSeeds = g_noSeed ? 1 : ZSTD_HC_MAX_CLEVEL;
+        g_seedParams = ZSTD_HC_defaultParameters[tableID];
+        for (i=1; i<=maxSeeds; i++)
         {
+            const U32 btPlus = (params.strategy == ZSTD_HC_btlazy2);
             params = g_seedParams[i];
             params.windowLog = MIN(srcLog, params.windowLog);
-            params.chainLog = MIN(params.windowLog, params.chainLog);
-            params.searchLog = MIN(params.chainLog, params.searchLog);
+            params.contentLog = MIN(params.windowLog+btPlus, params.contentLog);
+            params.searchLog = MIN(params.contentLog, params.searchLog);
             BMK_seed(winners, params, srcBuffer, srcSize, ctx);
         }
     }
@@ -951,10 +970,10 @@ int main(int argc, char** argv)
                                 g_params.windowLog *= 10, g_params.windowLog += *argument++ - '0';
                             continue;
                         case 'c':
-                            g_params.chainLog = 0;
+                            g_params.contentLog = 0;
                             argument++;
                             while ((*argument>= '0') && (*argument<='9'))
-                                g_params.chainLog *= 10, g_params.chainLog += *argument++ - '0';
+                                g_params.contentLog *= 10, g_params.contentLog += *argument++ - '0';
                             continue;
                         case 'h':
                             g_params.hashLog = 0;
@@ -975,7 +994,7 @@ int main(int argc, char** argv)
                                 g_params.searchLength *= 10, g_params.searchLength += *argument++ - '0';
                             continue;
                         case 't':  /* strategy */
-                            g_params.strategy = ZSTD_HC_greedy;
+                            g_params.strategy = (ZSTD_HC_strategy)0;
                             argument++;
                             while ((*argument>= '0') && (*argument<='9'))
                             {
@@ -989,7 +1008,7 @@ int main(int argc, char** argv)
                                 argument++;
                                 while ((*argument>= '0') && (*argument<='9'))
                                     cLevel *= 10, cLevel += *argument++ - '0';
-                                if (cLevel < 2) cLevel = 2;
+                                if (cLevel < 1) cLevel = 1;
                                 if (cLevel > ZSTD_HC_MAX_CLEVEL) cLevel = ZSTD_HC_MAX_CLEVEL;
                                 g_params = g_seedParams[cLevel];
                                 continue;
@@ -1000,7 +1019,7 @@ int main(int argc, char** argv)
                     }
                     break;
 
-                    /* target level2 speed objective, in MB/s */
+                    /* target level1 speed objective, in MB/s */
                 case 'T':
                     argument++;
                     g_target = 0;
@@ -1022,6 +1041,7 @@ int main(int argc, char** argv)
                         if (*argument=='K') g_blockSize<<=10, argument++;  /* allows using KB notation */
                         if (*argument=='M') g_blockSize<<=20, argument++;
                         if (*argument=='B') argument++;
+                        DISPLAY("using %u KB block size \n", g_blockSize>>10);
                     }
                     break;
 

programs/zstdcli.c

@@ -70,7 +70,7 @@
 **************************************/
 #define COMPRESSOR_NAME "zstd command line interface"
 #ifndef ZSTD_VERSION
-#  define ZSTD_VERSION "v0.3.3"
+#  define ZSTD_VERSION "v0.3.6"
 #endif
 #define AUTHOR "Yann Collet"
 #define WELCOME_MESSAGE "*** %s %i-bits %s, by %s (%s) ***\n", COMPRESSOR_NAME, (int)(sizeof(void*)*8), ZSTD_VERSION, AUTHOR, __DATE__