minor optimization for small files

diff --git a/lib/fse.c b/lib/fse.c
index 606dcbcc3232f62c79754f3b7eb0fd7aa8266ec4..986a0da15e7e717e3225a970a5d4c4852fe8449a 100644 (file)
--- a/lib/fse.c
+++ b/lib/fse.c
@@ -848,9 +848,12 @@ size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
         tableU16[s] = (U16)(tableSize + s);
 
     /* Build Symbol Transformation Table */
-    for (s=0; s<=maxSymbolValue; s++) {
-        symbolTT[s].deltaNbBits = (nbBits << 16) - (1 << nbBits);
-        symbolTT[s].deltaFindState = s-1;
+    {
+        const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
+        for (s=0; s<=maxSymbolValue; s++) {
+            symbolTT[s].deltaNbBits = deltaNbBits;
+            symbolTT[s].deltaFindState = s-1;
+        }
     }
 
     return 0;

diff --git a/lib/zstd_compress.c b/lib/zstd_compress.c
index eb3031dcbb59c1380dacac67de4e49fc253c6df7..37550e6b7bce0f6abf5a5c01cae52aa63e3e5d7d 100644 (file)
--- a/lib/zstd_compress.c
+++ b/lib/zstd_compress.c
@@ -544,10 +544,11 @@ size_t ZSTD_compressSequences(ZSTD_CCtx* zc,
     }
 
     /* Sequences Header */
-    if ((oend-op) < MIN_SEQUENCES_SIZE)
-        return ERROR(dstSize_tooSmall);
-    MEM_writeLE16(op, (U16)nbSeq); op+=2;
-
+    if ((oend-op) < MIN_SEQUENCES_SIZE) return ERROR(dstSize_tooSmall);
+    if (nbSeq < 128) *op++ = (BYTE)nbSeq;
+    else {
+        op[0] = (nbSeq>>8) + 128; op[1] = (BYTE)nbSeq; op+=2;
+    }
     if (nbSeq==0) goto _check_compressibility;
 
     /* dumps : contains rests of large lengths */
@@ -946,12 +947,7 @@ void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* zc,
 
     /* init */
     ZSTD_resetSeqStore(seqStorePtr);
-    if (ip < lowest+4) {
-        hashTable[ZSTD_hashPtr(lowest+1, hBits, mls)] = lowIndex+1;
-        hashTable[ZSTD_hashPtr(lowest+2, hBits, mls)] = lowIndex+2;
-        hashTable[ZSTD_hashPtr(lowest+3, hBits, mls)] = lowIndex+3;
-        ip = lowest+4;
-    }
+    if (ip < lowest+REPCODE_STARTVALUE) ip = lowest+REPCODE_STARTVALUE;
 
     /* Main Search Loop */
     while (ip < ilimit) {  /* < instead of <=, because repcode check at (ip+1) */
@@ -1056,12 +1052,9 @@ void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx,
 
     /* init */
     ZSTD_resetSeqStore(seqStorePtr);
-    /* skip first 4 positions to avoid read overflow during repcode match check */
+    /* skip first position to avoid read overflow during repcode match check */
     hashTable[ZSTD_hashPtr(ip+0, hBits, mls)] = (U32)(ip-base+0);
-    hashTable[ZSTD_hashPtr(ip+1, hBits, mls)] = (U32)(ip-base+1);
-    hashTable[ZSTD_hashPtr(ip+2, hBits, mls)] = (U32)(ip-base+2);
-    hashTable[ZSTD_hashPtr(ip+3, hBits, mls)] = (U32)(ip-base+3);
-    ip += 4;
+    ip += REPCODE_STARTVALUE;
 
     /* Main Search Loop */
     while (ip < ilimit) {  /* < instead of <=, because (ip+1) */

diff --git a/lib/zstd_decompress.c b/lib/zstd_decompress.c
index cdc7d3074ace01f00310390300fb0093d7e49d0c..96ba8936552312a0024b1676f6bd03f2879ac823 100644 (file)
--- a/lib/zstd_decompress.c
+++ b/lib/zstd_decompress.c
@@ -273,7 +273,8 @@ void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
 static size_t ZSTD_decodeFrameHeader_Part1(ZSTD_DCtx* zc, const void* src, size_t srcSize)
 {
     U32 magicNumber;
-    if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);
+    if (srcSize != ZSTD_frameHeaderSize_min)
+        return ERROR(srcSize_wrong);
     magicNumber = MEM_readLE32(src);
     if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);
     zc->headerSize = ZSTD_frameHeaderSize_min;
@@ -300,7 +301,8 @@ size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcS
 static size_t ZSTD_decodeFrameHeader_Part2(ZSTD_DCtx* zc, const void* src, size_t srcSize)
 {
     size_t result;
-    if (srcSize != zc->headerSize) return ERROR(srcSize_wrong);
+    if (srcSize != zc->headerSize)
+        return ERROR(srcSize_wrong);
     result = ZSTD_getFrameParams(&(zc->params), src, srcSize);
     if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bitsImplementation);
     return result;
@@ -313,7 +315,8 @@ size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bp
     BYTE headerFlags;
     U32 cSize;
 
-    if (srcSize < 3) return ERROR(srcSize_wrong);
+    if (srcSize < 3)
+        return ERROR(srcSize_wrong);
 
     headerFlags = *in;
     cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
@@ -335,7 +338,7 @@ static size_t ZSTD_copyRawBlock(void* dst, size_t maxDstSize, const void* src, s
 }
 
 
-/** ZSTD_decodeLiteralsBlock
+/*! ZSTD_decodeLiteralsBlock
     @return : nb of bytes read from src (< srcSize ) */
 size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                           const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
@@ -426,8 +429,7 @@ size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                 break;
             }
 
-            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize)   /* risk reading beyond src buffer with wildcopy */
-            {
+            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
                 if (litSize > srcSize-lhSize) return ERROR(corruption_detected);
                 memcpy(dctx->litBuffer, istart+lhSize, litSize);
                 dctx->litPtr = dctx->litBuffer;
@@ -483,11 +485,14 @@ size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLen
     size_t dumpsLength;
 
     /* check */
-    if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
+    if (srcSize < MIN_SEQUENCES_SIZE)
+        return ERROR(srcSize_wrong);
 
     /* SeqHead */
-    *nbSeq = MEM_readLE16(ip); ip+=2;
-    if (*nbSeq==0) return 2;
+    *nbSeq = *ip++;
+    if (*nbSeq==0) return 1;
+    if (*nbSeq >= 128)
+        *nbSeq = ((nbSeq[0]-128)<<8) + *ip++;
 
     LLtype  = *ip >> 6;
     Offtype = (*ip >> 4) & 3;
@@ -787,10 +792,10 @@ static size_t ZSTD_decompressSequences(
         seqState_t seqState;
 
         memset(&sequence, 0, sizeof(sequence));
-        sequence.offset = 4;
+        sequence.offset = REPCODE_STARTVALUE;
         seqState.dumps = dumps;
         seqState.dumpsEnd = dumps + dumpsLength;
-        seqState.prevOffset = 4;
+        seqState.prevOffset = REPCODE_STARTVALUE;
         errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
         if (ERR_isError(errorCode)) return ERROR(corruption_detected);
         FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);

diff --git a/lib/zstd_internal.h b/lib/zstd_internal.h
index 0b993b1e8d50189c7134836542c79bf94b6d7d45..f34fb282f540ca6934dc398a818aa4db723e93b0 100644 (file)
--- a/lib/zstd_internal.h
+++ b/lib/zstd_internal.h
@@ -81,7 +81,7 @@ static const size_t ZSTD_frameHeaderSize_min = 5;
 #define IS_RLE 3
 
 #define MINMATCH 4
-#define REPCODE_STARTVALUE 4
+#define REPCODE_STARTVALUE 1
 
 #define MLbits   7
 #define LLbits   6
@@ -102,7 +102,7 @@ static const size_t ZSTD_frameHeaderSize_min = 5;
 
 #define HufLog 12
 
-#define MIN_SEQUENCES_SIZE 2 /*seqNb*/
+#define MIN_SEQUENCES_SIZE 1 /* seqNb */
 #define MIN_CBLOCK_SIZE (1 /*litCSize*/ + MIN_SEQUENCES_SIZE)
 
 #define WILDCOPY_OVERLENGTH 8