MEM_readMINMATCH replaced with inline function

diff --git a/lib/mem.h b/lib/mem.h
index 0e357e53099a277b3ce6c2fcf58c052be914dd2d..a369033b1f5c9fe283d95fa4e7a1ade5bb109b04 100644 (file)
--- a/lib/mem.h
+++ b/lib/mem.h
@@ -188,6 +188,16 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value)
 #endif /* MEM_FORCE_MEMORY_ACCESS */
 
 
+MEM_STATIC U32 MEM_readMINMATCH(const void* memPtr, U32 length)
+{
+    switch (length)
+    {
+    default :
+    case 4 : return MEM_read32(memPtr);
+    case 3 : return MEM_read32(memPtr)<<8;
+    }
+}
+
 MEM_STATIC U16 MEM_readLE16(const void* memPtr)
 {
     if (MEM_isLittleEndian())

diff --git a/lib/zstd_compress.c b/lib/zstd_compress.c
index 50fa2fdc26537879d9beb36bcb3c43173d1060bb..637ffb982613bc2a9741bf5e6dfa734fe8b68a82 100644 (file)
--- a/lib/zstd_compress.c
+++ b/lib/zstd_compress.c
@@ -207,15 +207,16 @@ static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,
     zc->seqStore.litLengthStart =  zc->seqStore.litStart + blockSize;
     zc->seqStore.matchLengthStart = zc->seqStore.litLengthStart + (blockSize>>2);
     zc->seqStore.dumpsStart = zc->seqStore.matchLengthStart + (blockSize>>2);
+    if (params.strategy == ZSTD_btopt) {
+        zc->seqStore.litFreq = (U32*)((void*)(zc->seqStore.dumpsStart + (blockSize>>2)));
+        zc->seqStore.litLengthFreq = zc->seqStore.litFreq + (1<<Litbits);
+        zc->seqStore.matchLengthFreq = zc->seqStore.litLengthFreq + (1<<LLbits);
+        zc->seqStore.offCodeFreq = zc->seqStore.matchLengthFreq + (1<<MLbits);
+        zc->seqStore.matchTable = (ZSTD_match_t*)((void*)(zc->seqStore.offCodeFreq + (1<<Offbits)));
+        zc->seqStore.priceTable = (ZSTD_optimal_t*)((void*)(zc->seqStore.matchTable + ZSTD_OPT_NUM+1));
+        zc->seqStore.litLengthSum = 0;
+    }
 
-    zc->seqStore.litFreq = (U32*)((void*)(zc->seqStore.dumpsStart + (blockSize>>2)));
-    zc->seqStore.litLengthFreq = zc->seqStore.litFreq + (1<<Litbits);
-    zc->seqStore.matchLengthFreq = zc->seqStore.litLengthFreq + (1<<LLbits);
-    zc->seqStore.offCodeFreq = zc->seqStore.matchLengthFreq + (1<<MLbits);
-    zc->seqStore.matchTable = (ZSTD_match_t*)(zc->seqStore.offCodeFreq + (1<<Offbits));
-    zc->seqStore.priceTable = (ZSTD_optimal_t*)(zc->seqStore.matchTable + ZSTD_OPT_NUM+1);
-
-    zc->seqStore.litLengthSum = 0;
     zc->hbSize = 0;
     zc->stage = 0;
     zc->loadedDictEnd = 0;
@@ -1661,10 +1662,7 @@ _storeSequence:
 
 static void ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    if (ctx->params.searchLength == 3)
-        ZSTD_compressBlock_opt_generic3(ctx, src, srcSize, 2);
-    else
-        ZSTD_compressBlock_opt_generic4(ctx, src, srcSize, 2);
+    ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 2);
 }
 
 static void ZSTD_compressBlock_btlazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
@@ -1883,10 +1881,7 @@ static void ZSTD_compressBlock_btlazy2_extDict(ZSTD_CCtx* ctx, const void* src,
 
 static void ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    if (ctx->params.searchLength == 3)
-        ZSTD_compressBlock_opt_extDict_generic3(ctx, src, srcSize, 2);
-    else
-        ZSTD_compressBlock_opt_extDict_generic4(ctx, src, srcSize, 2);
+    ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize, 2);
 }
 
 
@@ -2404,10 +2399,10 @@ static const ZSTD_parameters ZSTD_defaultParameters[4][ZSTD_MAX_CLEVEL+1] = {
     {  0, 14, 15, 15,  0, 15,  4,256, ZSTD_btopt   },  /* level 19 */
     {  0, 14, 15, 15,  0, 16,  4,256, ZSTD_btopt   },  /* level 20 */
     {  0, 14, 15, 15,  0, 17,  4,256, ZSTD_btopt   },  /* level 21 */
-    {  0, 14, 15, 15,  0, 17,  4,256, ZSTD_btopt   },  /* level 21-2 */
-    {  0, 14, 15, 15,  0, 17,  4,256, ZSTD_btopt   },  /* level 21-3 */
-    {  0, 14, 15, 15,  0, 17,  4,256, ZSTD_btopt   },  /* level 21-4 */
-    {  0, 14, 15, 15,  0, 17,  4,256, ZSTD_btopt   },  /* level 21-5 */
+    {  0, 14, 15, 15,  0, 14,  3,256, ZSTD_btopt   },  /* level 21-2 */
+    {  0, 14, 15, 15,  0, 15,  3,256, ZSTD_btopt   },  /* level 21-3 */
+    {  0, 14, 15, 15,  0, 16,  3,256, ZSTD_btopt   },  /* level 21-4 */
+    {  0, 14, 15, 15,  0, 17,  3,256, ZSTD_btopt   },  /* level 21-5 */
 },
 };
 

diff --git a/lib/zstd_opt.h b/lib/zstd_opt.h
index f61485987d1c055e603d71743b2c5fe9e2adfb86..66700514fdacfd9c803584b6f6a31d09bf234f15 100644 (file)
--- a/lib/zstd_opt.h
+++ b/lib/zstd_opt.h
@@ -41,7 +41,6 @@ FORCE_INLINE U32 ZSTD_GETPRICE(seqStore_t* seqStorePtr, U32 litLength, const BYT
     U32 price = (offCode-1) + (!offCode) + ZSTD_highbit(seqStorePtr->offCodeSum+1) - ZSTD_highbit(seqStorePtr->offCodeFreq[offCode]+1);
 
     /* match Length */
-    matchLength -= MINMATCHOPT;
     price += ((matchLength >= MaxML)<<3) + ((matchLength >= 255+MaxML)<<4) + ((matchLength>=(1<<15))<<3);
     if (matchLength >= MaxML) matchLength = MaxML;
     price += ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + ZSTD_highbit(seqStorePtr->matchLengthSum+1) - ZSTD_highbit(seqStorePtr->matchLengthFreq[matchLength]+1);
@@ -95,36 +94,36 @@ static U32 ZSTD_INSERTBTANDGETALLMATCHES (
     U32 dummy32;   /* to be nullified at the end */
     U32 mnum = 0;
 
-    size_t bestLength = MINMATCHOPT-1;
+    const U32 minMatch = (mls == 3) ? 3 : 4;
+    size_t bestLength = minMatch-1;
     hashTable[h] = current;   /* Update Hash Table */
 
-#if MINMATCHOPT == 3
-    /* HC3 match finder */
-    U32 matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
+    if (minMatch == 3) { /* HC3 match finder */
+        U32 matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
 
-    if (matchIndex3>windowLow) {
-        const BYTE* match;
-        size_t currentMl=0;
-        if ((!extDict) || matchIndex3 >= dictLimit) {
-            match = base + matchIndex3;
-            if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit);
-        } else {
-            match = dictBase + matchIndex3;
-            if (MEM_readMINMATCH(match) == MEM_readMINMATCH(ip))    /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
-                currentMl = ZSTD_count_2segments(ip+MINMATCHOPT, match+MINMATCHOPT, iLimit, dictEnd, prefixStart) + MINMATCHOPT;
-        }
+        if (matchIndex3>windowLow) {
+            const BYTE* match;
+            size_t currentMl=0;
+            if ((!extDict) || matchIndex3 >= dictLimit) {
+                match = base + matchIndex3;
+                if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit);
+            } else {
+                match = dictBase + matchIndex3;
+                if (MEM_readMINMATCH(match, minMatch) == MEM_readMINMATCH(ip, minMatch))    /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
+                    currentMl = ZSTD_count_2segments(ip+minMatch, match+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
+            }
 
-        /* save best solution */
-        if (currentMl > bestLength) {
-            bestLength = currentMl;
-            matches[mnum].off = current - matchIndex3;
-            matches[mnum].len = (U32)currentMl;
-            mnum++;
-            if (currentMl > ZSTD_OPT_NUM) return mnum;
-            if (ip+currentMl == iLimit) return mnum; /* best possible, and avoid read overflow*/
+            /* save best solution */
+            if (currentMl > bestLength) {
+                bestLength = currentMl;
+                matches[mnum].off = current - matchIndex3;
+                matches[mnum].len = (U32)currentMl;
+                mnum++;
+                if (currentMl > ZSTD_OPT_NUM) return mnum;
+                if (ip+currentMl == iLimit) return mnum; /* best possible, and avoid read overflow*/
+            }
         }
     }
-#endif
 
     while (nbCompares-- && (matchIndex > windowLow)) {
         U32* nextPtr = bt + 2*(matchIndex & btMask);
@@ -266,8 +265,9 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
     
     U32 rep_2=REPCODE_STARTVALUE, rep_1=REPCODE_STARTVALUE;
     const U32 maxSearches = 1U << ctx->params.searchLog;
-    const U32 mls = ctx->params.searchLength;
     const U32 sufficient_len = ctx->params.targetLength;
+    const U32 mls = ctx->params.searchLength;
+    const U32 minMatch = (ctx->params.searchLength == 3) ? 3 : 4;
 
     ZSTD_optimal_t* opt = seqStorePtr->priceTable;
     ZSTD_match_t* matches = seqStorePtr->matchTable;
@@ -295,9 +295,9 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
         opt[0].litlen = (U32)(ip - litstart);
 
         /* check repCode */
-        if (MEM_readMINMATCH(ip+1) == MEM_readMINMATCH(ip+1 - rep_1)) {
+        if (MEM_readMINMATCH(ip+1, minMatch) == MEM_readMINMATCH(ip+1 - rep_1, minMatch)) {
             /* repcode : we take it */
-            mlen = (U32)ZSTD_count(ip+1+MINMATCHOPT, ip+1+MINMATCHOPT-rep_1, iend) + MINMATCHOPT;
+            mlen = (U32)ZSTD_count(ip+1+minMatch, ip+1+minMatch-rep_1, iend) + minMatch;
 
             ZSTD_LOG_PARSER("%d: start try REP rep=%d mlen=%d\n", (int)(ip-base), (int)rep_1, (int)mlen);
             if (depth==0 || mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
@@ -307,11 +307,11 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
 
             litlen = opt[0].litlen + 1;
             do {
-                price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
+                price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen - minMatch);
                 if (mlen + 1 > last_pos || price < opt[mlen + 1].price)
                     SET_PRICE(mlen + 1, mlen, 0, litlen, price);   /* note : macro modifies last_pos */
                 mlen--;
-            } while (mlen >= MINMATCHOPT);
+            } while (mlen >= minMatch);
         }
 
         match_num = ZSTD_BTGETALLMATCHES_SELECTMLS(ctx, ip, ip, iend, maxSearches, mls, matches); /* first search (depth 0) */
@@ -331,7 +331,7 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
             goto _storeSequence;
         }
 
-       best_mlen = (last_pos) ? last_pos : MINMATCHOPT;
+       best_mlen = (last_pos) ? last_pos : minMatch;
 
        // set prices using matches at position = 0
        for (u = 0; u < match_num; u++) {
@@ -340,13 +340,13 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
            ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos);
            litlen = opt[0].litlen;
            while (mlen <= best_mlen) {
-                price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+                price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen - minMatch);
                 if (mlen > last_pos || price < opt[mlen].price)
                     SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
                 mlen++;
         }  }
 
-        if (last_pos < MINMATCHOPT) { ip++; continue; }
+        if (last_pos < minMatch) { ip++; continue; }
 
          /* check further positions */
         for (cur = 1; cur <= last_pos; cur++) {
@@ -401,8 +401,8 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
                ZSTD_LOG_PARSER("%d: tryNoExt REP1 rep=%u mlen=%u\n", (int)(inr-base), (U32)cur_rep, mlen);
            }
 
-           if (MEM_readMINMATCH(inr) == MEM_readMINMATCH(inr - cur_rep)) {  // check rep
-               mlen = (U32)ZSTD_count(inr+MINMATCHOPT, inr+MINMATCHOPT - cur_rep, iend) + MINMATCHOPT;
+           if (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(inr - cur_rep, minMatch)) {  // check rep
+               mlen = (U32)ZSTD_count(inr+minMatch, inr+minMatch - cur_rep, iend) + minMatch;
                ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), mlen, 0, opt[cur].rep, cur, opt[cur].off);
 
                if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
@@ -416,12 +416,12 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
                if (opt[cur].mlen == 1) {
                     litlen = opt[cur].litlen;
                     if (cur > litlen) {
-                        price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, inr-litlen, 0, mlen);
+                        price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, inr-litlen, 0, mlen - minMatch);
                     } else
-                        price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
+                        price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen - minMatch);
                 } else {
                     litlen = 0;
-                    price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen);
+                    price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen - minMatch);
                 }
 
                 best_mlen = mlen;
@@ -431,7 +431,7 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
                     if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
                         SET_PRICE(cur + mlen, mlen, 0, litlen, price);
                     mlen--;
-                } while (mlen >= MINMATCHOPT);
+                } while (mlen >= minMatch);
             }
 
             match_num = ZSTD_BTGETALLMATCHES_SELECTMLS(ctx, inr, ip, iend, maxSearches, mls, matches);
@@ -444,7 +444,7 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
                 goto _storeSequence;
             }
 
-            best_mlen = (best_mlen > MINMATCHOPT) ? best_mlen : MINMATCHOPT;
+            best_mlen = (best_mlen > minMatch) ? best_mlen : minMatch;
 
             /* set prices using matches at position = cur */
             for (u = 0; u < match_num; u++) {
@@ -457,12 +457,12 @@ void ZSTD_COMPRESSBLOCK_OPT_GENERIC(ZSTD_CCtx* ctx,
                     if (opt[cur].mlen == 1) {
                         litlen = opt[cur].litlen;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen);
+                            price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen - minMatch);
                         else
-                            price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+                            price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen - minMatch);
                     } else {
                         litlen = 0;
-                        price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, matches[u].off, mlen);
+                        price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, matches[u].off, mlen - minMatch);
                     }
 
                   //  ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen);
@@ -530,7 +530,7 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
                 ml2 = (U32)ZSTD_count(ip, ip-offset, iend);
             else
                 ml2 = (U32)ZSTD_count(ip, ip-rep_1, iend);
-            if ((offset >= 8) && (ml2 < mlen || ml2 < MINMATCHOPT)) {
+            if ((offset >= 8) && (ml2 < mlen || ml2 < minMatch)) {
                 printf("%d: ERROR_NoExt iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); }
             if (ip < anchor) {
                 printf("%d: ERROR_NoExt ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
@@ -538,23 +538,23 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
                 printf("%d: ERROR_NoExt ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
 #endif
 
-            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
+            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-minMatch);
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-minMatch);
             anchor = ip = ip + mlen;
         }   /* for (cur=0; cur < last_pos; ) */
 
         /* check immediate repcode */
         while ((anchor >= prefixStart + rep_2) && (anchor <= ilimit)
-             && (MEM_readMINMATCH(anchor) == MEM_readMINMATCH(anchor - rep_2)) ) {
+             && (MEM_readMINMATCH(anchor, minMatch) == MEM_readMINMATCH(anchor - rep_2, minMatch)) ) {
             /* store sequence */
-            best_mlen = (U32)ZSTD_count(anchor+MINMATCHOPT, anchor+MINMATCHOPT-rep_2, iend);
+            best_mlen = (U32)ZSTD_count(anchor+minMatch, anchor+minMatch-rep_2, iend);
             best_off = rep_2;
             rep_2 = rep_1;
             rep_1 = best_off;
             ZSTD_LOG_ENCODE("%d/%d: ENCODE REP literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(anchor-base), (int)(iend-base), (int)(0), (int)best_mlen, (int)(0), (int)rep_1, (int)rep_2);
             ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, best_mlen);
             ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, best_mlen);
-            anchor += best_mlen+MINMATCHOPT;
+            anchor += best_mlen+minMatch;
             continue;   /* faster when present ... (?) */
         }
         if (anchor > ip) ip = anchor;
@@ -590,8 +590,9 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
    
     U32 rep_2=REPCODE_STARTVALUE, rep_1=REPCODE_STARTVALUE;
     const U32 maxSearches = 1U << ctx->params.searchLog;
-    const U32 mls = ctx->params.searchLength;
     const U32 sufficient_len = ctx->params.targetLength;
+    const U32 mls = ctx->params.searchLength;
+    const U32 minMatch = (ctx->params.searchLength == 3) ? 3 : 4;
 
     ZSTD_optimal_t* opt = seqStorePtr->priceTable;
     ZSTD_match_t* matches = seqStorePtr->matchTable;
@@ -623,10 +624,10 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
             const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
             const BYTE* const repMatch = repBase + repIndex;
             if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-               && (MEM_readMINMATCH(ip+1) == MEM_readMINMATCH(repMatch)) ) {
+               && (MEM_readMINMATCH(ip+1, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
                 /* repcode detected we should take it */
                 const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                mlen = (U32)ZSTD_count_2segments(ip+1+MINMATCHOPT, repMatch+MINMATCHOPT, iend, repEnd, prefixStart) + MINMATCHOPT;
+                mlen = (U32)ZSTD_count_2segments(ip+1+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
 
                 ZSTD_LOG_PARSER("%d: start try REP rep=%d mlen=%d\n", (int)(ip-base), (int)rep_1, (int)mlen);
                 if (depth==0 || mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
@@ -636,14 +637,14 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
 
                 litlen = opt[0].litlen + 1;
                 do {
-                    price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
+                    price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen - minMatch);
                     if (mlen + 1 > last_pos || price < opt[mlen + 1].price)
                         SET_PRICE(mlen + 1, mlen, 0, litlen, price);
                     mlen--;
-                } while (mlen >= MINMATCHOPT);
+                } while (mlen >= minMatch);
         }   }
 
-       best_mlen = (last_pos) ? last_pos : MINMATCHOPT;
+       best_mlen = (last_pos) ? last_pos : minMatch;
 
        match_num = ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT(ctx, ip, ip, iend, maxSearches, mls, matches);  /* first search (depth 0) */
 
@@ -669,13 +670,13 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
             ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos);
             litlen = opt[0].litlen;
             while (mlen <= best_mlen) {
-                price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+                price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen - minMatch);
                 if (mlen > last_pos || price < opt[mlen].price)
                     SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
                 mlen++;
         }   }
 
-        if (last_pos < MINMATCHOPT) {
+        if (last_pos < minMatch) {
             // ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */
             ip++; continue;
         }
@@ -737,10 +738,10 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
            const BYTE* const repMatch = repBase + repIndex;
            if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-              &&(MEM_readMINMATCH(inr) == MEM_readMINMATCH(repMatch)) ) {
+              && (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
                 /* repcode detected */
                 const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                mlen = (U32)ZSTD_count_2segments(inr+MINMATCHOPT, repMatch+MINMATCHOPT, iend, repEnd, prefixStart) + MINMATCHOPT;
+                mlen = (U32)ZSTD_count_2segments(inr+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
                 ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), mlen, 0, opt[cur].rep, cur, opt[cur].off);
 
                 if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
@@ -754,12 +755,12 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
                 if (opt[cur].mlen == 1) {
                     litlen = opt[cur].litlen;
                     if (cur > litlen) {
-                        price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, inr-litlen, 0, mlen);
+                        price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, inr-litlen, 0, mlen - minMatch);
                     } else
-                        price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen);
+                        price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, 0, mlen - minMatch);
                 } else {
                     litlen = 0;
-                    price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen);
+                    price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, 0, mlen - minMatch);
                 }
 
                 best_mlen = mlen;
@@ -770,10 +771,10 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
                     if (cur + mlen > last_pos || price <= opt[cur + mlen].price) // || ((price == opt[cur + mlen].price) && (opt[cur].mlen == 1) && (cur != litlen))) // at equal price prefer REP instead of MATCH
                         SET_PRICE(cur + mlen, mlen, 0, litlen, price);
                     mlen--;
-                } while (mlen >= MINMATCHOPT);
+                } while (mlen >= minMatch);
             }
 
-            best_mlen = (best_mlen > MINMATCHOPT) ? best_mlen : MINMATCHOPT;
+            best_mlen = (best_mlen > minMatch) ? best_mlen : minMatch;
 
             match_num = ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT(ctx, inr, ip, iend, maxSearches, mls, matches);
             ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
@@ -796,12 +797,12 @@ void ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC(ZSTD_CCtx* ctx,
                     if (opt[cur].mlen == 1) {
                         litlen = opt[cur].litlen;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen);
+                            price = opt[cur - litlen].price + ZSTD_GETPRICE(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen - minMatch);
                         else
-                            price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen);
+                            price = ZSTD_GETPRICE(seqStorePtr, litlen, litstart, matches[u].off, mlen - minMatch);
                     } else {
                         litlen = 0;
-                        price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, matches[u].off, mlen);
+                        price = opt[cur].price + ZSTD_GETPRICE(seqStorePtr, 0, NULL, matches[u].off, mlen - minMatch);
                     }
 
                 //    ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen);
@@ -874,7 +875,7 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
                 else ml2 = (U32)ZSTD_count(ip, ip-offset, iend);
             }
             else ml2 = (U32)ZSTD_count(ip, ip-rep_1, iend);
-            if ((offset >= 8) && (ml2 < mlen || ml2 < MINMATCHOPT)) {
+            if ((offset >= 8) && (ml2 < mlen || ml2 < minMatch)) {
                 printf("%d: ERROR_Ext iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); }
             if (ip < anchor) {
                 printf("%d: ERROR_Ext ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
@@ -882,8 +883,8 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
                 printf("%d: ERROR_Ext ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
 #endif
 
-            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCHOPT);
+            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-minMatch);
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-minMatch);
             anchor = ip = ip + mlen;
         }
 
@@ -891,22 +892,22 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
         /* check immediate repcode */
         while ((anchor >= base + lowLimit + rep_2) && (anchor <= ilimit)) {
             if ((anchor - rep_2) >= prefixStart) {
-                if (MEM_readMINMATCH(anchor) == MEM_readMINMATCH(anchor - rep_2))
-                    mlen = (U32)ZSTD_count(anchor+MINMATCHOPT, anchor - rep_2 + MINMATCHOPT, iend) + MINMATCHOPT;
+                if (MEM_readMINMATCH(anchor, minMatch) == MEM_readMINMATCH(anchor - rep_2, minMatch))
+                    mlen = (U32)ZSTD_count(anchor+minMatch, anchor - rep_2 + minMatch, iend) + minMatch;
                 else
                     break;
             } else {
                 const BYTE* repMatch = dictBase + ((anchor-base) - rep_2);
-                if ((repMatch + MINMATCHOPT <= dictEnd) && (MEM_readMINMATCH(anchor) == MEM_readMINMATCH(repMatch))) 
-                    mlen = (U32)ZSTD_count_2segments(anchor+MINMATCHOPT, repMatch+MINMATCHOPT, iend, dictEnd, prefixStart) + MINMATCHOPT;
+                if ((repMatch + minMatch <= dictEnd) && (MEM_readMINMATCH(anchor, minMatch) == MEM_readMINMATCH(repMatch, minMatch))) 
+                    mlen = (U32)ZSTD_count_2segments(anchor+minMatch, repMatch+minMatch, iend, dictEnd, prefixStart) + minMatch;
                 else
                     break;
             }
                    
             offset = rep_2; rep_2 = rep_1; rep_1 = offset;   /* swap offset history */
             ZSTD_LOG_ENCODE("%d/%d: ENCODE REP literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(anchor-base), (int)(iend-base), (int)(0), (int)best_mlen, (int)(0), (int)rep_1, (int)rep_2);
-            ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, mlen-MINMATCHOPT);
-            ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, mlen-MINMATCHOPT);
+            ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, mlen-minMatch);
+            ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, mlen-minMatch);
             anchor += mlen;
         }
 #else
@@ -917,14 +918,14 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
             const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
             const BYTE* const repMatch = repBase + repIndex;
             if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-               && (MEM_readMINMATCH(anchor) == MEM_readMINMATCH(repMatch)) ) {
+               && (MEM_readMINMATCH(anchor, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
                 /* repcode detected, let's take it */
                 const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                mlen = (U32)ZSTD_count_2segments(anchor+MINMATCHOPT, repMatch+MINMATCHOPT, iend, repEnd, prefixStart) + MINMATCHOPT;
+                mlen = (U32)ZSTD_count_2segments(anchor+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
                 offset = rep_2; rep_2 = rep_1; rep_1 = offset;   /* swap offset history */
                 ZSTD_LOG_ENCODE("%d/%d: ENCODE REP literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(anchor-base), (int)(iend-base), (int)(0), (int)best_mlen, (int)(0), (int)rep_1, (int)rep_2);
-                ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, mlen-MINMATCHOPT);
-                ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, mlen-MINMATCHOPT);
+                ZSTD_updatePrice(seqStorePtr, 0, anchor, 0, mlen-minMatch);
+                ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, mlen-minMatch);
                 anchor += mlen;
                 continue;   /* faster when present ... (?) */
             }

diff --git a/lib/zstd_opt_internal.h b/lib/zstd_opt_internal.h
index b980eab085249514ae77c73ae3bd45f84a02fb6e..6dd5f5165677ca0d460197a847d6d69017025d82 100644 (file)
--- a/lib/zstd_opt_internal.h
+++ b/lib/zstd_opt_internal.h
@@ -168,39 +168,14 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
     return hashTable3[ZSTD_hash3Ptr(ip, hashLog3)];
 }
 
-
-#define MINMATCHOPT 4
-#define MEM_readMINMATCH(ptr) (U32)(MEM_read32(ptr)) 
-#define ZSTD_GETPRICE ZSTD_getPrice4
-#define ZSTD_INSERTBTANDGETALLMATCHES ZSTD_insertBtAndGetAllMatches4
-#define ZSTD_BTGETALLMATCHES ZSTD_BtGetAllMatches4
-#define ZSTD_BTGETALLMATCHES_SELECTMLS ZSTD_BtGetAllMatches_selectMLS4
-#define ZSTD_BTGETALLMATCHES_EXTDICT ZSTD_BtGetAllMatches_extDict4
-#define ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT ZSTD_BtGetAllMatches_selectMLS_extDict4
-#define ZSTD_COMPRESSBLOCK_OPT_GENERIC ZSTD_compressBlock_opt_generic4
-#define ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC ZSTD_compressBlock_opt_extDict_generic4
-#include "zstd_opt.h"
-#undef MINMATCHOPT
-#undef MEM_readMINMATCH
-#undef ZSTD_GETPRICE
-#undef ZSTD_INSERTBTANDGETALLMATCHES
-#undef ZSTD_BTGETALLMATCHES
-#undef ZSTD_BTGETALLMATCHES_SELECTMLS
-#undef ZSTD_BTGETALLMATCHES_EXTDICT
-#undef ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT
-#undef ZSTD_COMPRESSBLOCK_OPT_GENERIC
-#undef ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC
-
-#define MINMATCHOPT 3
-#define MEM_readMINMATCH(ptr) ((U32)(MEM_read32(ptr)<<8)) 
-#define ZSTD_GETPRICE ZSTD_getPrice3
-#define ZSTD_INSERTBTANDGETALLMATCHES ZSTD_insertBtAndGetAllMatches3
-#define ZSTD_BTGETALLMATCHES ZSTD_BtGetAllMatches3
-#define ZSTD_BTGETALLMATCHES_SELECTMLS ZSTD_BtGetAllMatches_selectMLS3
-#define ZSTD_BTGETALLMATCHES_EXTDICT ZSTD_BtGetAllMatches_extDict3
-#define ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT ZSTD_BtGetAllMatches_selectMLS_extDict3
-#define ZSTD_COMPRESSBLOCK_OPT_GENERIC ZSTD_compressBlock_opt_generic3
-#define ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC ZSTD_compressBlock_opt_extDict_generic3
+#define ZSTD_GETPRICE ZSTD_getPrice
+#define ZSTD_INSERTBTANDGETALLMATCHES ZSTD_insertBtAndGetAllMatches
+#define ZSTD_BTGETALLMATCHES ZSTD_BtGetAllMatches
+#define ZSTD_BTGETALLMATCHES_SELECTMLS ZSTD_BtGetAllMatches_selectMLS
+#define ZSTD_BTGETALLMATCHES_EXTDICT ZSTD_BtGetAllMatches_extDict
+#define ZSTD_BTGETALLMATCHES_SELECTMLS_EXTDICT ZSTD_BtGetAllMatches_selectMLS_extDict
+#define ZSTD_COMPRESSBLOCK_OPT_GENERIC ZSTD_compressBlock_opt_generic
+#define ZSTD_COMPRESSBLOCK_OPT_EXTDICT_GENERIC ZSTD_compressBlock_opt_extDict_generic
 #include "zstd_opt.h"