AuroraMiddleware/zstd
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactoring for portability

Browse Source
This commit is contained in:
Yann Collet 2016-02-10 13:37:52 +01:00
parent 302177a0c8
commit 70e8c389f1
4 changed files with 345 additions and 496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
lib/zstd_compress.c
View File

@ -88,6 +88,7 @@ typedef struct {
BYTE* matchLength; BYTE* matchLength;
BYTE* dumpsStart; BYTE* dumpsStart;
BYTE* dumps; BYTE* dumps;
/* opt */
U32* matchLengthFreq; U32* matchLengthFreq;
U32* litLengthFreq; U32* litLengthFreq;
U32* litFreq; U32* litFreq;
@ -100,19 +101,20 @@ typedef struct {
static void ZSTD_resetFreqs(seqStore_t* ssPtr) static void ZSTD_resetFreqs(seqStore_t* ssPtr)
{ {
ssPtr->matchLengthSum = (1<<MLbits); unsigned u;
ssPtr->litLengthSum = (1<<LLbits); ssPtr->matchLengthSum = 512; // (1<<MLbits);
ssPtr->litLengthSum = 256; // (1<<LLbits);
ssPtr->litSum = (1<<Litbits); ssPtr->litSum = (1<<Litbits);
ssPtr->offCodeSum = (1<<Offbits); ssPtr->offCodeSum = (1<<Offbits);
for (int i=0; i<=MaxLit; i++) for (u=0; u<=MaxLit; u++)
ssPtr->litFreq[i] = 1; ssPtr->litFreq[u] = 1;
for (int i=0; i<=MaxLL; i++) for (u=0; u<=MaxLL; u++)
ssPtr->litLengthFreq[i] = 1; ssPtr->litLengthFreq[u] = 1;
for (int i=0; i<=MaxML; i++) for (u=0; u<=MaxML; u++)
ssPtr->matchLengthFreq[i] = 1; ssPtr->matchLengthFreq[u] = 1;
for (int i=0; i<=MaxOff; i++) for (u=0; u<=MaxOff; u++)
ssPtr->offCodeFreq[i] = 1; ssPtr->offCodeFreq[u] = 1;
} }
static void ZSTD_resetSeqStore(seqStore_t* ssPtr) static void ZSTD_resetSeqStore(seqStore_t* ssPtr)
@ -173,7 +175,9 @@ size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
static unsigned ZSTD_highbit(U32 val); static unsigned ZSTD_highbit(U32 val);
/** ZSTD_validateParams #define CLAMP(val,min,max) { if (val<min) val=min; else if (val>max) val=max; }
/** ZSTD_validateParams()
correct params value to remain within authorized range correct params value to remain within authorized range
optimize for srcSize if srcSize > 0 */ optimize for srcSize if srcSize > 0 */
void ZSTD_validateParams(ZSTD_parameters* params) void ZSTD_validateParams(ZSTD_parameters* params)
@ -182,25 +186,21 @@ void ZSTD_validateParams(ZSTD_parameters* params)
/* validate params */ /* validate params */
if (MEM_32bits()) if (params->windowLog > 25) params->windowLog = 25; /* 32 bits mode cannot flush > 24 bits */ if (MEM_32bits()) if (params->windowLog > 25) params->windowLog = 25; /* 32 bits mode cannot flush > 24 bits */
if (params->windowLog > ZSTD_WINDOWLOG_MAX) params->windowLog = ZSTD_WINDOWLOG_MAX; CLAMP(params->windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
if (params->windowLog < ZSTD_WINDOWLOG_MIN) params->windowLog = ZSTD_WINDOWLOG_MIN; CLAMP(params->contentLog, ZSTD_CONTENTLOG_MIN, ZSTD_CONTENTLOG_MAX);
CLAMP(params->hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
CLAMP(params->searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);
CLAMP(params->searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX);
CLAMP(params->sufficientLength, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);
if ((U32)params->strategy>(U32)ZSTD_opt_bt) params->strategy = ZSTD_opt_bt;
/* correct params, to use less memory */ /* correct params, to use less memory */
if ((params->srcSize > 0) && (params->srcSize < (1<<ZSTD_WINDOWLOG_MAX))) { if ((params->srcSize > 0) && (params->srcSize < (1<<ZSTD_WINDOWLOG_MAX))) {
U32 srcLog = ZSTD_highbit((U32)(params->srcSize)-1) + 1; U32 srcLog = ZSTD_highbit((U32)(params->srcSize)-1) + 1;
if (params->windowLog > srcLog) params->windowLog = srcLog; if (params->windowLog > srcLog) params->windowLog = srcLog;
} }
if (params->windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) params->windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN; /* required for frame header */ if (params->windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) params->windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN; /* required for frame header */
if (params->contentLog > params->windowLog+btPlus) params->contentLog = params->windowLog+btPlus; /* <= ZSTD_CONTENTLOG_MAX */ if (params->contentLog > params->windowLog+btPlus) params->contentLog = params->windowLog+btPlus; /* <= ZSTD_CONTENTLOG_MAX */
if (params->contentLog < ZSTD_CONTENTLOG_MIN) params->contentLog = ZSTD_CONTENTLOG_MIN;
if (params->hashLog > ZSTD_HASHLOG_MAX) params->hashLog = ZSTD_HASHLOG_MAX;
if (params->hashLog < ZSTD_HASHLOG_MIN) params->hashLog = ZSTD_HASHLOG_MIN;
if (params->searchLog > ZSTD_SEARCHLOG_MAX) params->searchLog = ZSTD_SEARCHLOG_MAX;
if (params->searchLog < ZSTD_SEARCHLOG_MIN) params->searchLog = ZSTD_SEARCHLOG_MIN;
if (params->searchLength> ZSTD_SEARCHLENGTH_MAX) params->searchLength = ZSTD_SEARCHLENGTH_MAX;
if (params->searchLength< ZSTD_SEARCHLENGTH_MIN) params->searchLength = ZSTD_SEARCHLENGTH_MIN;
if ((U32)params->strategy>(U32)ZSTD_opt_bt) params->strategy = ZSTD_opt_bt;
} }
@ -234,18 +234,19 @@ static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,
zc->lowLimit = 0; zc->lowLimit = 0;
zc->params = params; zc->params = params;
zc->blockSize = blockSize; zc->blockSize = blockSize;
zc->seqStore.offsetStart = (U32*) (zc->seqStore.buffer);
zc->seqStore.litFreq = (U32*) (zc->seqStore.buffer);
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.offsetStart = zc->seqStore.offCodeFreq + (1<<Offbits);
zc->seqStore.offCodeStart = (BYTE*) (zc->seqStore.offsetStart + (blockSize>>2)); zc->seqStore.offCodeStart = (BYTE*) (zc->seqStore.offsetStart + (blockSize>>2));
zc->seqStore.litStart = zc->seqStore.offCodeStart + (blockSize>>2); zc->seqStore.litStart = zc->seqStore.offCodeStart + (blockSize>>2);
zc->seqStore.litLengthStart = zc->seqStore.litStart + blockSize; zc->seqStore.litLengthStart = zc->seqStore.litStart + blockSize;
zc->seqStore.matchLengthStart = zc->seqStore.litLengthStart + (blockSize>>2); zc->seqStore.matchLengthStart = zc->seqStore.litLengthStart + (blockSize>>2);
zc->seqStore.dumpsStart = zc->seqStore.matchLengthStart + (blockSize>>2); zc->seqStore.dumpsStart = zc->seqStore.matchLengthStart + (blockSize>>2);
BYTE* dumpsEnd= zc->seqStore.dumpsStart + (blockSize>>2); // zc->seqStore.XXX = zc->seqStore.dumpsStart + (blockSize>>4);
zc->seqStore.litFreq = (U32*)(dumpsEnd);
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.XXX = zc->seqStore.offCodeFreq + (1<<Offbits)*sizeof(U32);
zc->hbSize = 0; zc->hbSize = 0;
zc->stage = 0; zc->stage = 0;
@ -562,7 +563,6 @@ size_t ZSTD_compressSequences(ZSTD_CCtx* zc,
const size_t maxCSize = srcSize - minGain; const size_t maxCSize = srcSize - minGain;
BYTE* seqHead; BYTE* seqHead;
/* Compress literals */ /* Compress literals */
{ {
size_t cSize; size_t cSize;
@ -1194,8 +1194,8 @@ void ZSTD_compressBlock_fast_extDict(ZSTD_CCtx* ctx,
/* ************************************* /* *************************************
* Binary Tree search * Binary Tree search
***************************************/ ***************************************/
/** ZSTD_insertBt1 : add one or multiple positions to tree /** ZSTD_insertBt1() : add one or multiple positions to tree
* @ip : assumed <= iend-8 * ip : assumed <= iend-8
* @return : nb of positions added */ * @return : nb of positions added */
static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares, static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares,
U32 extDict) U32 extDict)
@ -1230,9 +1230,9 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
while (nbCompares-- && (matchIndex > windowLow)) { while (nbCompares-- && (matchIndex > windowLow)) {
U32* nextPtr = bt + 2*(matchIndex & btMask); U32* nextPtr = bt + 2*(matchIndex & btMask);
const U32* predictPtr = bt + 2*((matchIndex-1) & btMask); /* written this way, as bt is a roll buffer */
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */ size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
const U32* predictPtr = bt + 2*((matchIndex-1) & btMask); /* written this way, as bt is a roll buffer */
if (matchIndex == predictedSmall) { if (matchIndex == predictedSmall) {
/* no need to check length, result known */ /* no need to check length, result known */
*smallerPtr = matchIndex; *smallerPtr = matchIndex;
@ -1242,7 +1242,6 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
predictedSmall = predictPtr[1] + (predictPtr[1]>0); predictedSmall = predictPtr[1] + (predictPtr[1]>0);
continue; continue;
} }
if (matchIndex == predictedLarge) { if (matchIndex == predictedLarge) {
*largerPtr = matchIndex; *largerPtr = matchIndex;
if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */ if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */
@ -2314,8 +2313,9 @@ size_t ZSTD_compress(void* dst, size_t maxDstSize, const void* src, size_t srcSi
} }
/*- Pre-defined compression levels -*/ /*-===== Pre-defined compression levels =====-*/
#define ZSTD_MAX_CLEVEL 25
unsigned ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; } unsigned ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
static const ZSTD_parameters ZSTD_defaultParameters[4][ZSTD_MAX_CLEVEL+1] = { static const ZSTD_parameters ZSTD_defaultParameters[4][ZSTD_MAX_CLEVEL+1] = {
@ -2345,7 +2345,8 @@ static const ZSTD_parameters ZSTD_defaultParameters[4][ZSTD_MAX_CLEVEL+1] = {
{ 0, 0, 22, 20, 22, 4, 4, ZSTD_lazy2 }, /* level 21 = 11 + L=4 */ // 41902762 lazy1=42087013 norep1=42911693 { 0, 0, 22, 20, 22, 4, 4, ZSTD_lazy2 }, /* level 21 = 11 + L=4 */ // 41902762 lazy1=42087013 norep1=42911693
{ 0, 0, 23, 21, 22, 5, 4, ZSTD_btlazy2 }, /* level 22 = 16 + L=4 */ // 41233150 btlazy1=41560211 norep1=42322286 { 0, 0, 23, 21, 22, 5, 4, ZSTD_btlazy2 }, /* level 22 = 16 + L=4 */ // 41233150 btlazy1=41560211 norep1=42322286
{ 0, 32, 23, 21, 22, 5, 4, ZSTD_opt }, /* level 23 */ { 0, 32, 23, 21, 22, 5, 4, ZSTD_opt }, /* level 23 */
{ 0, 32, 23, 21, 22, 5, 4, ZSTD_opt_bt }, /* level 24 */ { 0, 32, 23, 21, 22, 5, 4, ZSTD_opt_bt }, /* level 24 = 16 + btopt */
{ 0, 64, 26, 27, 25, 10, 4, ZSTD_opt_bt }, /* level 25 = 20 + btopt */
}, },
{ /* for srcSize <= 256 KB */ { /* for srcSize <= 256 KB */
/* SL, W, C, H, S, L, strat */ /* SL, W, C, H, S, L, strat */

383
lib/zstd_opt.c
View File

@ -37,46 +37,23 @@ typedef struct
#define ZSTD_FREQ_THRESHOLD (256) #define ZSTD_FREQ_THRESHOLD (256)
// log2_32 is from http://stackoverflow.com/questions/11376288/fast-computing-of-log2-for-64-bit-integers
const U32 tab32[32] = {
0, 9, 1, 10, 13, 21, 2, 29,
11, 14, 16, 18, 22, 25, 3, 30,
8, 12, 20, 28, 15, 17, 24, 7,
19, 27, 23, 6, 26, 5, 4, 31};
U32 log2_32 (U32 value)
{
value |= value >> 1;
value |= value >> 2;
value |= value >> 4;
value |= value >> 8;
value |= value >> 16;
return tab32[(U32)(value*0x07C4ACDD) >> 27];
}
FORCE_INLINE U32 ZSTD_getLiteralPriceReal(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals) FORCE_INLINE U32 ZSTD_getLiteralPriceReal(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals)
{ {
U32 price = 0; U32 price = 0;
if (litLength > 0) { if (litLength > 0) {
U32 freq, u;
/* literals */ /* literals */
for (U32 i=0; i < litLength; i++) for (u=0; u < litLength; u++)
price += log2_32(seqStorePtr->litSum) - log2_32(seqStorePtr->litFreq[literals[i]]); price += ZSTD_highbit(seqStorePtr->litSum) - ZSTD_highbit(seqStorePtr->litFreq[literals[u]]);
/* literal Length */ /* literal Length */
U32 freq; price += ((litLength >= MaxLL)*8) + ((litLength >= 255+MaxLL)*16) + ((litLength>=(1<<15))*8);
if (litLength >= MaxLL) { if (litLength >= MaxLL) litLength = MaxLL;
freq = seqStorePtr->litLengthFreq[MaxLL];
if (litLength<255 + MaxLL) {
price += 8;
} else {
price += 8;
if (litLength < (1<<15)) price += 16; else price += 24;
} }
else
freq = seqStorePtr->litLengthFreq[litLength]; freq = seqStorePtr->litLengthFreq[litLength];
price += log2_32(seqStorePtr->litLengthSum) - log2_32(freq); price += ZSTD_highbit(seqStorePtr->litLengthSum) - ZSTD_highbit(freq);
/* note : seems that using matchLengthSum (<litLengthSum) improves compression ? */
} }
return price + (price == 0); return price + (price == 0);
@ -88,7 +65,7 @@ FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* seqStorePtr, U32 litLength, co
{ {
if (seqStorePtr->litSum > ZSTD_FREQ_THRESHOLD) if (seqStorePtr->litSum > ZSTD_FREQ_THRESHOLD)
return ZSTD_getLiteralPriceReal(seqStorePtr, litLength, literals); return ZSTD_getLiteralPriceReal(seqStorePtr, litLength, literals);
/* backup eval */
return 1 + (litLength<<3); return 1 + (litLength<<3);
} }
@ -96,25 +73,18 @@ FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* seqStorePtr, U32 litLength, co
FORCE_INLINE U32 ZSTD_getMatchPriceReal(seqStore_t* seqStorePtr, U32 offset, U32 matchLength) FORCE_INLINE U32 ZSTD_getMatchPriceReal(seqStore_t* seqStorePtr, U32 offset, U32 matchLength)
{ {
/* match offset */ U32 freq;
BYTE offCode = (BYTE)ZSTD_highbit(offset) + 1;
if (offset==0) /* offset */
offCode = 0; BYTE offCode = offset ? (BYTE)ZSTD_highbit(offset) + 1 : 0;
U32 price = log2_32(seqStorePtr->offCodeSum) - log2_32(seqStorePtr->offCodeFreq[offCode]); U32 price = ZSTD_highbit(seqStorePtr->offCodeSum) - ZSTD_highbit(seqStorePtr->offCodeFreq[offCode]);
price += offCode; price += offCode;
/* match Length */ /* match Length */
U32 freq; price += ((matchLength >= MaxML)*8) + ((matchLength >= 255+MaxML)*16) + ((matchLength>=(1<<15))*8);
if (matchLength >= MaxML) { if (matchLength >= MaxML) matchLength = MaxML;
freq = seqStorePtr->matchLengthFreq[MaxML]; freq = seqStorePtr->matchLengthFreq[matchLength];
if (matchLength < 255+MaxML) { price += ZSTD_highbit(seqStorePtr->matchLengthSum) - ZSTD_highbit(freq);
price += 8;
} else {
price += 8;
if (matchLength < (1<<15)) price += 16; else price += 24;
} }
else freq = seqStorePtr->matchLengthFreq[matchLength];
price += log2_32(seqStorePtr->matchLengthSum) - log2_32(freq);
return price; return price;
} }
@ -132,6 +102,7 @@ FORCE_INLINE U32 ZSTD_getPrice(seqStore_t* seqStorePtr, U32 litLength, const BYT
MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength) MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
{ {
U32 u;
#if 0 #if 0
static const BYTE* g_start = NULL; static const BYTE* g_start = NULL;
if (g_start==NULL) g_start = literals; if (g_start==NULL) g_start = literals;
@ -141,8 +112,8 @@ MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const B
#endif #endif
/* literals */ /* literals */
seqStorePtr->litSum += litLength; seqStorePtr->litSum += litLength;
for (U32 i=0; i < litLength; i++) for (u=0; u < litLength; u++)
seqStorePtr->litFreq[literals[i]]++; seqStorePtr->litFreq[literals[u]]++;
/* literal Length */ /* literal Length */
seqStorePtr->litLengthSum++; seqStorePtr->litLengthSum++;
@ -212,7 +183,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
U32 dummy32; /* to be nullified at the end */ U32 dummy32; /* to be nullified at the end */
U32 mnum = 0; U32 mnum = 0;
bestLength = 0; bestLength = MINMATCH-1;
hashTable[h] = current; /* Update Hash Table */ hashTable[h] = current; /* Update Hash Table */
while (nbCompares-- && (matchIndex > windowLow)) { while (nbCompares-- && (matchIndex > windowLow)) {
@ -232,18 +203,13 @@ U32 ZSTD_insertBtAndGetAllMatches (
} }
if (matchLength > bestLength) { if (matchLength > bestLength) {
if (matchLength > matchEndIdx - matchIndex) if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength;
matchEndIdx = matchIndex + (U32)matchLength;
{
if (matchLength >= MINMATCH) {
bestLength = matchLength; bestLength = matchLength;
matches[mnum].off = current - matchIndex; matches[mnum].off = current - matchIndex;
matches[mnum].len = (U32)matchLength; matches[mnum].len = (U32)matchLength;
matches[mnum].back = 0; matches[mnum].back = 0;
mnum++; mnum++;
}
if (matchLength > ZSTD_OPT_NUM) break; if (matchLength > ZSTD_OPT_NUM) break;
}
if (ip+matchLength == iend) /* equal : no way to know if inf or sup */ if (ip+matchLength == iend) /* equal : no way to know if inf or sup */
break; /* drop, to guarantee consistency (miss a little bit of compression) */ break; /* drop, to guarantee consistency (miss a little bit of compression) */
} }
@ -262,8 +228,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */ if (matchIndex <= btLow) { largerPtr=&dummy32; break; } /* beyond tree size, stop the search */
largerPtr = nextPtr; largerPtr = nextPtr;
matchIndex = nextPtr[0]; matchIndex = nextPtr[0];
} } }
}
*smallerPtr = *largerPtr = 0; *smallerPtr = *largerPtr = 0;
@ -290,8 +255,7 @@ FORCE_INLINE U32 ZSTD_BtGetAllMatches_selectMLS (
const BYTE* ip, const BYTE* const iLowLimit, const BYTE* const iHighLimit, const BYTE* ip, const BYTE* const iLowLimit, const BYTE* const iHighLimit,
const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, U32 minml) const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, U32 minml)
{ {
if (iLowLimit) {}; // skip warnings (void)iLowLimit; /* unused */
switch(matchLengthSearch) switch(matchLengthSearch)
{ {
default : default :
@ -303,7 +267,7 @@ FORCE_INLINE U32 ZSTD_BtGetAllMatches_selectMLS (
/** Tree updater, providing best match */ /** Tree updater, providing best match */
FORCE_INLINE /* inlining is important to hardwire a hot branch (template emulation) */ FORCE_INLINE /* inlining is important to hardwire a hot branch (template emulation) */
size_t ZSTD_BtGetAllMatches_extDict ( U32 ZSTD_BtGetAllMatches_extDict (
ZSTD_CCtx* zc, ZSTD_CCtx* zc,
const BYTE* const ip, const BYTE* const iLimit, const BYTE* const ip, const BYTE* const iLimit,
const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, U32 minml) const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, U32 minml)
@ -458,7 +422,7 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
ZSTD_optimal_t opt[ZSTD_OPT_NUM+4]; ZSTD_optimal_t opt[ZSTD_OPT_NUM+4];
ZSTD_match_t matches[ZSTD_OPT_NUM+1]; ZSTD_match_t matches[ZSTD_OPT_NUM+1];
const uint8_t *inr; const BYTE* inr;
U32 skip_num, cur, cur2, match_num, last_pos, litlen, price; U32 skip_num, cur, cur2, match_num, last_pos, litlen, price;
const U32 sufficient_len = ctx->params.sufficientLength; const U32 sufficient_len = ctx->params.sufficientLength;
@ -472,6 +436,7 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
/* Match Loop */ /* Match Loop */
while (ip < ilimit) { while (ip < ilimit) {
U32 u;
U32 mlen=0; U32 mlen=0;
U32 best_mlen=0; U32 best_mlen=0;
U32 best_off=0; U32 best_off=0;
@ -518,8 +483,7 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
opt[0].rep2 = rep_2; opt[0].rep2 = rep_2;
opt[0].mlen = 1; opt[0].mlen = 1;
if (match_num && matches[match_num-1].len > sufficient_len) if (match_num && matches[match_num-1].len > sufficient_len) {
{
best_mlen = matches[match_num-1].len; best_mlen = matches[match_num-1].len;
best_off = matches[match_num-1].off; best_off = matches[match_num-1].off;
cur = 0; cur = 0;
@ -528,17 +492,16 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
} }
// set prices using matches at position = 0 // set prices using matches at position = 0
for (U32 i = 0; i < match_num; i++) for (u = 0; u < match_num; u++) {
{ mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
mlen = (i>0) ? matches[i-1].len+1 : best_mlen; best_mlen = (matches[u].len < ZSTD_OPT_NUM) ? matches[u].len : ZSTD_OPT_NUM;
best_mlen = (matches[i].len < ZSTD_OPT_NUM) ? matches[i].len : ZSTD_OPT_NUM;
ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[i].len, matches[i].off, (int)best_mlen, (int)last_pos); ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[i].len, matches[i].off, (int)best_mlen, (int)last_pos);
litlen = opt[0].litlen; litlen = opt[0].litlen;
while (mlen <= best_mlen) while (mlen <= best_mlen)
{ {
price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[i].off, mlen - MINMATCH); price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
if (mlen > last_pos || price < opt[mlen].price) if (mlen > last_pos || price < opt[mlen].price)
SET_PRICE(mlen, mlen, matches[i].off, litlen, price); SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
mlen++; mlen++;
} }
} }
@ -552,21 +515,17 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
// check further positions // check further positions
for (skip_num = 0, cur = 1; cur <= last_pos; cur++) for (skip_num = 0, cur = 1; cur <= last_pos; cur++)
{ {
size_t cur_rep;
inr = ip + cur; inr = ip + cur;
if (opt[cur-1].mlen == 1) if (opt[cur-1].mlen == 1) {
{
litlen = opt[cur-1].litlen + 1; litlen = opt[cur-1].litlen + 1;
if (cur > litlen) if (cur > litlen) {
{
price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen); price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen);
ZSTD_LOG_TRY_PRICE("%d: TRY1 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen); ZSTD_LOG_TRY_PRICE("%d: TRY1 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen);
} } else
else
price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor); price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor);
} } else {
else
{
litlen = 1; litlen = 1;
price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1); price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1);
ZSTD_LOG_TRY_PRICE("%d: TRY3 price=%d cur=%d litlen=%d litonly=%d\n", (int)(inr-base), price, cur, litlen, (int)ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1)); ZSTD_LOG_TRY_PRICE("%d: TRY3 price=%d cur=%d litlen=%d litonly=%d\n", (int)(inr-base), price, cur, litlen, (int)ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1));
@ -584,52 +543,39 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
mlen = opt[cur].mlen; mlen = opt[cur].mlen;
if (opt[cur-mlen].off) if (opt[cur-mlen].off) {
{
opt[cur].rep2 = opt[cur-mlen].rep; opt[cur].rep2 = opt[cur-mlen].rep;
opt[cur].rep = opt[cur-mlen].off; opt[cur].rep = opt[cur-mlen].off;
ZSTD_LOG_PARSER("%d: COPYREP1 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: COPYREP1 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2);
} } else {
else if (cur!=mlen && opt[cur-mlen].litlen == 0) {
{
if (cur!=mlen && opt[cur-mlen].litlen == 0)
{
opt[cur].rep2 = opt[cur-mlen].rep; opt[cur].rep2 = opt[cur-mlen].rep;
opt[cur].rep = opt[cur-mlen].rep2; opt[cur].rep = opt[cur-mlen].rep2;
ZSTD_LOG_PARSER("%d: COPYREP2 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: COPYREP2 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2);
} } else {
else
{
opt[cur].rep2 = opt[cur-mlen].rep2; opt[cur].rep2 = opt[cur-mlen].rep2;
opt[cur].rep = opt[cur-mlen].rep; opt[cur].rep = opt[cur-mlen].rep;
ZSTD_LOG_PARSER("%d: COPYREP3 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: COPYREP3 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2);
} } }
}
ZSTD_LOG_PARSER("%d: CURRENT price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: CURRENT price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep, opt[cur].rep2);
size_t cur_rep;
best_mlen = 0; best_mlen = 0;
if (!opt[cur].off && opt[cur].mlen != 1) { if (!opt[cur].off && opt[cur].mlen != 1) {
cur_rep = opt[cur].rep2; cur_rep = opt[cur].rep2;
ZSTD_LOG_PARSER("%d: try REP2 rep2=%d mlen=%d\n", (int)(inr-base), cur_rep, mlen); ZSTD_LOG_PARSER("%d: try REP2 rep2=%d mlen=%d\n", (int)(inr-base), cur_rep, mlen);
} } else {
else {
cur_rep = opt[cur].rep; cur_rep = opt[cur].rep;
ZSTD_LOG_PARSER("%d: try REP1 rep=%d mlen=%d\n", (int)(inr-base), cur_rep, mlen); ZSTD_LOG_PARSER("%d: try REP1 rep=%d mlen=%d\n", (int)(inr-base), cur_rep, mlen);
} }
if (MEM_read32(inr) == MEM_read32(inr - cur_rep)) // check rep if (MEM_read32(inr) == MEM_read32(inr - cur_rep)) { // check rep
{
mlen = (U32)ZSTD_count(inr+MINMATCH, inr+MINMATCH - cur_rep, iend) + MINMATCH; 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); 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) if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
{
best_mlen = mlen; best_mlen = mlen;
best_off = 0; best_off = 0;
ZSTD_LOG_PARSER("%d: REP sufficient_len=%d best_mlen=%d best_off=%d last_pos=%d\n", (int)(inr-base), sufficient_len, best_mlen, best_off, last_pos); ZSTD_LOG_PARSER("%d: REP sufficient_len=%d best_mlen=%d best_off=%d last_pos=%d\n", (int)(inr-base), sufficient_len, best_mlen, best_off, last_pos);
@ -637,20 +583,15 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
goto _storeSequence; goto _storeSequence;
} }
if (opt[cur].mlen == 1) if (opt[cur].mlen == 1) {
{
litlen = opt[cur].litlen; litlen = opt[cur].litlen;
if (cur > litlen) if (cur > litlen) {
{
price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, 0, mlen - MINMATCH); price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, 0, mlen - MINMATCH);
ZSTD_LOG_TRY_PRICE("%d: TRY5 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen); ZSTD_LOG_TRY_PRICE("%d: TRY5 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen);
} } else
else
price = ZSTD_getPrice(seqStorePtr, litlen, anchor, 0, mlen - MINMATCH); price = ZSTD_getPrice(seqStorePtr, litlen, anchor, 0, mlen - MINMATCH);
} } else {
else
{
litlen = 0; litlen = 0;
price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen - MINMATCH); price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen - MINMATCH);
ZSTD_LOG_TRY_PRICE("%d: TRY7 price=%d cur=%d litlen=0 getprice=%d\n", (int)(inr-base), price, cur, (int)ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen - MINMATCH)); ZSTD_LOG_TRY_PRICE("%d: TRY7 price=%d cur=%d litlen=0 getprice=%d\n", (int)(inr-base), price, cur, (int)ZSTD_getPrice(seqStorePtr, 0, NULL, 0, mlen - MINMATCH));
@ -662,21 +603,14 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d price=%d litlen=%d price[%d]=%d\n", (int)(inr-base), mlen, 0, price, litlen, cur - litlen, opt[cur - litlen].price); ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d price=%d litlen=%d price[%d]=%d\n", (int)(inr-base), mlen, 0, price, litlen, cur - litlen, opt[cur - litlen].price);
do do {
{
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 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); SET_PRICE(cur + mlen, mlen, 0, litlen, price);
mlen--; mlen--;
} } while (mlen >= MINMATCH);
while (mlen >= MINMATCH);
} }
if (faster_get_matches && skip_num > 0) { skip_num--; continue; }
if (faster_get_matches && skip_num > 0)
{
skip_num--;
continue;
}
best_mlen = (best_mlen > MINMATCH) ? best_mlen : MINMATCH; best_mlen = (best_mlen > MINMATCH) ? best_mlen : MINMATCH;
@ -685,8 +619,7 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num); ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
if (match_num > 0 && matches[match_num-1].len > sufficient_len) if (match_num > 0 && matches[match_num-1].len > sufficient_len) {
{
cur -= matches[match_num-1].back; cur -= matches[match_num-1].back;
best_mlen = matches[match_num-1].len; best_mlen = matches[match_num-1].len;
best_off = matches[match_num-1].off; best_off = matches[match_num-1].off;
@ -695,42 +628,36 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
} }
// set prices using matches at position = cur /* set prices using matches at position = cur */
for (U32 i = 0; i < match_num; i++) for (u = 0; u < match_num; u++) {
{ mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
mlen = (i>0) ? matches[i-1].len+1 : best_mlen; cur2 = cur - matches[u].back;
cur2 = cur - matches[i].back; best_mlen = (cur2 + matches[u].len < ZSTD_OPT_NUM) ? matches[u].len : ZSTD_OPT_NUM - cur2;
best_mlen = (cur2 + matches[i].len < ZSTD_OPT_NUM) ? matches[i].len : ZSTD_OPT_NUM - cur2;
ZSTD_LOG_PARSER("%d: Found1 cur=%d cur2=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, cur2, matches[i].len, matches[i].off, best_mlen, last_pos); ZSTD_LOG_PARSER("%d: Found1 cur=%d cur2=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, cur2, matches[u].len, matches[i].off, best_mlen, last_pos);
if (mlen < matches[i].back + 1) if (mlen < matches[u].back + 1)
mlen = matches[i].back + 1; mlen = matches[u].back + 1;
while (mlen <= best_mlen) while (mlen <= best_mlen) {
{ if (opt[cur2].mlen == 1) {
if (opt[cur2].mlen == 1)
{
litlen = opt[cur2].litlen; litlen = opt[cur2].litlen;
if (cur2 > litlen) if (cur2 > litlen)
price = opt[cur2 - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur2-litlen, matches[i].off, mlen - MINMATCH); price = opt[cur2 - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur2-litlen, matches[u].off, mlen - MINMATCH);
else else
price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[i].off, mlen - MINMATCH); price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
} } else {
else
{
litlen = 0; litlen = 0;
price = opt[cur2].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[i].off, mlen - MINMATCH); price = opt[cur2].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen - MINMATCH);
} }
ZSTD_LOG_PARSER("%d: Found2 pred=%d mlen=%d best_mlen=%d off=%d price=%d litlen=%d price[%d]=%d\n", (int)(inr-base), matches[i].back, mlen, best_mlen, matches[i].off, price, litlen, cur - litlen, opt[cur - litlen].price); ZSTD_LOG_PARSER("%d: Found2 pred=%d mlen=%d best_mlen=%d off=%d price=%d litlen=%d price[%d]=%d\n", (int)(inr-base), matches[u].back, mlen, best_mlen, matches[u].off, price, litlen, cur - litlen, opt[cur - litlen].price);
ZSTD_LOG_TRY_PRICE("%d: TRY8 price=%d opt[%d].price=%d\n", (int)(inr-base), price, cur2 + mlen, opt[cur2 + mlen].price); ZSTD_LOG_TRY_PRICE("%d: TRY8 price=%d opt[%d].price=%d\n", (int)(inr-base), price, cur2 + mlen, opt[cur2 + mlen].price);
if (cur2 + mlen > last_pos || (price < opt[cur2 + mlen].price)) if (cur2 + mlen > last_pos || (price < opt[cur2 + mlen].price))
SET_PRICE(cur2 + mlen, mlen, matches[i].off, litlen, price); SET_PRICE(cur2 + mlen, mlen, matches[u].off, litlen, price);
mlen++; mlen++;
} } }
}
} // for (skip_num = 0, cur = 1; cur <= last_pos; cur++) } // for (skip_num = 0, cur = 1; cur <= last_pos; cur++)
@ -741,15 +668,14 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
/* store sequence */ /* store sequence */
_storeSequence: // cur, last_pos, best_mlen, best_off have to be set _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
for (U32 i = 1; i <= last_pos; i++) for (u = 1; u <= last_pos; u++)
ZSTD_LOG_PARSER("%d: price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+i), i, last_pos, opt[i].price, opt[i].off, opt[i].mlen, opt[i].litlen, opt[i].rep, opt[i].rep2); ZSTD_LOG_PARSER("%d: price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep, opt[u].rep2);
ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep); ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep);
opt[0].mlen = 1; opt[0].mlen = 1;
U32 offset; U32 offset;
while (1) while (1) {
{
mlen = opt[cur].mlen; mlen = opt[cur].mlen;
ZSTD_LOG_PARSER("%d: cur=%d mlen=%d\n", (int)(ip-base), cur, mlen); ZSTD_LOG_PARSER("%d: cur=%d mlen=%d\n", (int)(ip-base), cur, mlen);
offset = opt[cur].off; offset = opt[cur].off;
@ -762,10 +688,9 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
cur -= mlen; cur -= mlen;
} }
for (U32 i = 0; i <= last_pos;) for (u = 0; u <= last_pos;) {
{ ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep, opt[u].rep2);
ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+i), i, last_pos, opt[i].price, opt[i].off, opt[i].mlen, opt[i].litlen, opt[i].rep, opt[i].rep2); u += opt[u].mlen;
i += opt[i].mlen;
} }
cur = 0; cur = 0;
@ -880,7 +805,7 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
ZSTD_optimal_t opt[ZSTD_OPT_NUM+4]; ZSTD_optimal_t opt[ZSTD_OPT_NUM+4];
ZSTD_match_t matches[ZSTD_OPT_NUM+1]; ZSTD_match_t matches[ZSTD_OPT_NUM+1];
const uint8_t *inr; const BYTE* inr;
U32 skip_num, cur, cur2, match_num, last_pos, litlen, price; U32 skip_num, cur, cur2, match_num, last_pos, litlen, price;
const U32 sufficient_len = ctx->params.sufficientLength; const U32 sufficient_len = ctx->params.sufficientLength;
@ -894,6 +819,8 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
/* Match Loop */ /* Match Loop */
while (ip < ilimit) { while (ip < ilimit) {
U32 u;
U32 offset;
U32 mlen=0; U32 mlen=0;
U32 best_mlen=0; U32 best_mlen=0;
U32 best_off=0; U32 best_off=0;
@ -922,16 +849,13 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
} }
litlen = opt[0].litlen + 1; litlen = opt[0].litlen + 1;
do do {
{
price = ZSTD_getPrice(seqStorePtr, litlen, anchor, 0, mlen - MINMATCH); price = ZSTD_getPrice(seqStorePtr, litlen, anchor, 0, mlen - MINMATCH);
if (mlen + 1 > last_pos || price < opt[mlen + 1].price) if (mlen + 1 > last_pos || price < opt[mlen + 1].price)
SET_PRICE(mlen + 1, mlen, 0, litlen, price); SET_PRICE(mlen + 1, mlen, 0, litlen, price);
mlen--; mlen--;
} } while (mlen >= MINMATCH);
while (mlen >= MINMATCH); } }
}
}
best_mlen = (last_pos) ? last_pos : MINMATCH; best_mlen = (last_pos) ? last_pos : MINMATCH;
@ -947,8 +871,7 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
opt[0].rep2 = rep_2; opt[0].rep2 = rep_2;
opt[0].mlen = 1; opt[0].mlen = 1;
if (match_num && matches[match_num-1].len > sufficient_len) if (match_num && matches[match_num-1].len > sufficient_len) {
{
best_mlen = matches[match_num-1].len; best_mlen = matches[match_num-1].len;
best_off = matches[match_num-1].off; best_off = matches[match_num-1].off;
cur = 0; cur = 0;
@ -957,20 +880,17 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
} }
// set prices using matches at position = 0 // set prices using matches at position = 0
for (U32 i = 0; i < match_num; i++) for (u = 0; u < match_num; u++) {
{ mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
mlen = (i>0) ? matches[i-1].len+1 : best_mlen; best_mlen = (matches[u].len < ZSTD_OPT_NUM) ? matches[u].len : ZSTD_OPT_NUM;
best_mlen = (matches[i].len < ZSTD_OPT_NUM) ? matches[i].len : ZSTD_OPT_NUM; 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);
ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[i].len, matches[i].off, (int)best_mlen, (int)last_pos);
litlen = opt[0].litlen; litlen = opt[0].litlen;
while (mlen <= best_mlen) while (mlen <= best_mlen) {
{ price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[i].off, mlen - MINMATCH);
if (mlen > last_pos || price < opt[mlen].price) if (mlen > last_pos || price < opt[mlen].price)
SET_PRICE(mlen, mlen, matches[i].off, litlen, price); SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
mlen++; mlen++;
} } }
}
if (last_pos < MINMATCH) { if (last_pos < MINMATCH) {
// ip += ((ip-anchor) >> g_searchStrength) + 1; /* jump faster over incompressible sections */ // ip += ((ip-anchor) >> g_searchStrength) + 1; /* jump faster over incompressible sections */
@ -981,21 +901,17 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
// check further positions // check further positions
for (skip_num = 0, cur = 1; cur <= last_pos; cur++) for (skip_num = 0, cur = 1; cur <= last_pos; cur++)
{ {
size_t cur_rep;
inr = ip + cur; inr = ip + cur;
if (opt[cur-1].mlen == 1) if (opt[cur-1].mlen == 1) {
{
litlen = opt[cur-1].litlen + 1; litlen = opt[cur-1].litlen + 1;
if (cur > litlen) if (cur > litlen) {
{
price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen); price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen);
ZSTD_LOG_TRY_PRICE("%d: TRY1 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen); ZSTD_LOG_TRY_PRICE("%d: TRY1 opt[%d].price=%d price=%d cur=%d litlen=%d\n", (int)(inr-base), cur - litlen, opt[cur - litlen].price, price, cur, litlen);
} } else
else
price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor); price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor);
} } else {
else
{
litlen = 1; litlen = 1;
price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1); price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1);
ZSTD_LOG_TRY_PRICE("%d: TRY3 price=%d cur=%d litlen=%d litonly=%d\n", (int)(inr-base), price, cur, litlen, (int)ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1)); ZSTD_LOG_TRY_PRICE("%d: TRY3 price=%d cur=%d litlen=%d litonly=%d\n", (int)(inr-base), price, cur, litlen, (int)ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1));
@ -1013,33 +929,25 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
mlen = opt[cur].mlen; mlen = opt[cur].mlen;
if (opt[cur-mlen].off) if (opt[cur-mlen].off) {
{
opt[cur].rep2 = opt[cur-mlen].rep; opt[cur].rep2 = opt[cur-mlen].rep;
opt[cur].rep = opt[cur-mlen].off; opt[cur].rep = opt[cur-mlen].off;
ZSTD_LOG_PARSER("%d: COPYREP1 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: COPYREP1 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2);
} } else {
else if (cur!=mlen && opt[cur-mlen].litlen == 0) {
{
if (cur!=mlen && opt[cur-mlen].litlen == 0)
{
opt[cur].rep2 = opt[cur-mlen].rep; opt[cur].rep2 = opt[cur-mlen].rep;
opt[cur].rep = opt[cur-mlen].rep2; opt[cur].rep = opt[cur-mlen].rep2;
ZSTD_LOG_PARSER("%d: COPYREP2 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: COPYREP2 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2);
} } else {
else
{
opt[cur].rep2 = opt[cur-mlen].rep2; opt[cur].rep2 = opt[cur-mlen].rep2;
opt[cur].rep = opt[cur-mlen].rep; opt[cur].rep = opt[cur-mlen].rep;
ZSTD_LOG_PARSER("%d: COPYREP3 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: COPYREP3 cur=%d mlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep, opt[cur].rep2);
} } }
}
ZSTD_LOG_PARSER("%d: CURRENT price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: CURRENT price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep, opt[cur].rep2);
size_t cur_rep;
best_mlen = 0; best_mlen = 0;
if (!opt[cur].off && opt[cur].mlen != 1) { if (!opt[cur].off && opt[cur].mlen != 1) {
@ -1118,8 +1026,7 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num); ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
if (match_num > 0 && matches[match_num-1].len > sufficient_len) if (match_num > 0 && matches[match_num-1].len > sufficient_len) {
{
cur -= matches[match_num-1].back; cur -= matches[match_num-1].back;
best_mlen = matches[match_num-1].len; best_mlen = matches[match_num-1].len;
best_off = matches[match_num-1].off; best_off = matches[match_num-1].off;
@ -1129,41 +1036,35 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
// set prices using matches at position = cur // set prices using matches at position = cur
for (U32 i = 0; i < match_num; i++) for (u = 0; u < match_num; u++) {
{ mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
mlen = (i>0) ? matches[i-1].len+1 : best_mlen; cur2 = cur - matches[u].back;
cur2 = cur - matches[i].back; best_mlen = (cur2 + matches[u].len < ZSTD_OPT_NUM) ? matches[u].len : ZSTD_OPT_NUM - cur2;
best_mlen = (cur2 + matches[i].len < ZSTD_OPT_NUM) ? matches[i].len : ZSTD_OPT_NUM - cur2;
ZSTD_LOG_PARSER("%d: Found1 cur=%d cur2=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, cur2, matches[i].len, matches[i].off, best_mlen, last_pos); ZSTD_LOG_PARSER("%d: Found1 cur=%d cur2=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, cur2, matches[u].len, matches[u].off, best_mlen, last_pos);
if (mlen < matches[i].back + 1) if (mlen < matches[u].back + 1)
mlen = matches[i].back + 1; mlen = matches[u].back + 1;
while (mlen <= best_mlen) while (mlen <= best_mlen) {
{ if (opt[cur2].mlen == 1) {
if (opt[cur2].mlen == 1)
{
litlen = opt[cur2].litlen; litlen = opt[cur2].litlen;
if (cur2 > litlen) if (cur2 > litlen)
price = opt[cur2 - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur2-litlen, matches[i].off, mlen - MINMATCH); price = opt[cur2 - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur2-litlen, matches[u].off, mlen - MINMATCH);
else else
price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[i].off, mlen - MINMATCH); price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
} } else {
else
{
litlen = 0; litlen = 0;
price = opt[cur2].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[i].off, mlen - MINMATCH); price = opt[cur2].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen - MINMATCH);
} }
ZSTD_LOG_PARSER("%d: Found2 pred=%d mlen=%d best_mlen=%d off=%d price=%d litlen=%d price[%d]=%d\n", (int)(inr-base), matches[i].back, mlen, best_mlen, matches[i].off, price, litlen, cur - litlen, opt[cur - litlen].price); ZSTD_LOG_PARSER("%d: Found2 pred=%d mlen=%d best_mlen=%d off=%d price=%d litlen=%d price[%d]=%d\n", (int)(inr-base), matches[u].back, mlen, best_mlen, matches[u].off, price, litlen, cur - litlen, opt[cur - litlen].price);
ZSTD_LOG_TRY_PRICE("%d: TRY8 price=%d opt[%d].price=%d\n", (int)(inr-base), price, cur2 + mlen, opt[cur2 + mlen].price); ZSTD_LOG_TRY_PRICE("%d: TRY8 price=%d opt[%d].price=%d\n", (int)(inr-base), price, cur2 + mlen, opt[cur2 + mlen].price);
if (cur2 + mlen > last_pos || (price < opt[cur2 + mlen].price)) if (cur2 + mlen > last_pos || (price < opt[cur2 + mlen].price))
SET_PRICE(cur2 + mlen, mlen, matches[i].off, litlen, price); SET_PRICE(cur2 + mlen, mlen, matches[u].off, litlen, price);
mlen++; mlen++;
} } }
}
} // for (skip_num = 0, cur = 1; cur <= last_pos; cur++) } // for (skip_num = 0, cur = 1; cur <= last_pos; cur++)
@ -1174,15 +1075,13 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
/* store sequence */ /* store sequence */
_storeSequence: // cur, last_pos, best_mlen, best_off have to be set _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
for (U32 i = 1; i <= last_pos; i++) for (u = 1; u <= last_pos; u++)
ZSTD_LOG_PARSER("%d: price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+i), i, last_pos, opt[i].price, opt[i].off, opt[i].mlen, opt[i].litlen, opt[i].rep, opt[i].rep2); ZSTD_LOG_PARSER("%d: price[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u]litlen, opt[u].rep, opt[u].rep2);
ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep); ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep);
opt[0].mlen = 1; opt[0].mlen = 1;
U32 offset;
while (1) while (1) {
{
mlen = opt[cur].mlen; mlen = opt[cur].mlen;
ZSTD_LOG_PARSER("%d: cur=%d mlen=%d\n", (int)(ip-base), cur, mlen); ZSTD_LOG_PARSER("%d: cur=%d mlen=%d\n", (int)(ip-base), cur, mlen);
offset = opt[cur].off; offset = opt[cur].off;
@ -1195,40 +1094,33 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
cur -= mlen; cur -= mlen;
} }
for (U32 i = 0; i <= last_pos;) for (u = 0; u <= last_pos;) {
{ ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep, opt[u].rep2);
ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+i), i, last_pos, opt[i].price, opt[i].off, opt[i].mlen, opt[i].litlen, opt[i].rep, opt[i].rep2); u += opt[u].mlen;
i += opt[i].mlen;
} }
cur = 0; cur = 0;
while (cur < last_pos) while (cur < last_pos) {
{ U32 litLength;
ZSTD_LOG_PARSER("%d: price3[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+cur), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep, opt[cur].rep2); ZSTD_LOG_PARSER("%d: price3[%d/%d]=%d off=%d mlen=%d litlen=%d rep=%d rep2=%d\n", (int)(ip-base+cur), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep, opt[cur].rep2);
mlen = opt[cur].mlen; mlen = opt[cur].mlen;
if (mlen == 1) { ip++; cur++; continue; } if (mlen == 1) { ip++; cur++; continue; }
offset = opt[cur].off; offset = opt[cur].off;
cur += mlen; cur += mlen;
litLength = (U32)(ip - anchor);
U32 litLength = (U32)(ip - anchor);
ZSTD_LOG_ENCODE("%d/%d: ENCODE1 literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep_1, (int)rep_2); ZSTD_LOG_ENCODE("%d/%d: ENCODE1 literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep_1, (int)rep_2);
if (offset) if (offset) {
{
rep_2 = rep_1; rep_2 = rep_1;
rep_1 = offset; rep_1 = offset;
} } else {
else if (litLength == 0) {
{
if (litLength == 0)
{
best_off = rep_2; best_off = rep_2;
rep_2 = rep_1; rep_2 = rep_1;
rep_1 = best_off; rep_1 = best_off;
} } }
}
ZSTD_LOG_ENCODE("%d/%d: ENCODE2 literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep_1, (int)rep_2); ZSTD_LOG_ENCODE("%d/%d: ENCODE2 literals=%d mlen=%d off=%d rep1=%d rep2=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep_1, (int)rep_2);
@ -1258,14 +1150,14 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
} }
// check immediate repcode /* check immediate repcode */
while (anchor <= ilimit) { while (anchor <= ilimit) {
const U32 repIndex = (U32)((anchor-base) - rep_2); const U32 repIndex = (U32)((anchor-base) - rep_2);
const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
const BYTE* const repMatch = repBase + repIndex; const BYTE* const repMatch = repBase + repIndex;
if ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow */ if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow */
if (MEM_read32(anchor) == MEM_read32(repMatch)) { && (MEM_read32(anchor) == MEM_read32(repMatch)) ) {
/* repcode detected we should take it */ /* repcode detected, let's take it */
const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
mlen = (U32)ZSTD_count_2segments(anchor+MINMATCH, repMatch+MINMATCH, iend, repEnd, prefixStart) + MINMATCH; 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 */ offset = rep_2; rep_2 = rep_1; rep_1 = offset; /* swap offset history */
@ -1277,8 +1169,7 @@ _storeSequence: // cur, last_pos, best_mlen, best_off have to be set
continue; /* faster when present ... (?) */ continue; /* faster when present ... (?) */
} }
break; break;
} } }
}
/* Last Literals */ /* Last Literals */
{ {

7
lib/zstd_static.h
View File

@ -54,6 +54,8 @@ extern "C" {
#define ZSTD_WINDOWLOG_MAX 26 #define ZSTD_WINDOWLOG_MAX 26
#define ZSTD_WINDOWLOG_MIN 18 #define ZSTD_WINDOWLOG_MIN 18
#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11 #define ZSTD_WINDOWLOG_ABSOLUTEMIN 11
#define ZSTD_TARGETLENGTH_MIN 4
#define ZSTD_TARGETLENGTH_MAX 999
#define ZSTD_CONTENTLOG_MAX (ZSTD_WINDOWLOG_MAX+1) #define ZSTD_CONTENTLOG_MAX (ZSTD_WINDOWLOG_MAX+1)
#define ZSTD_CONTENTLOG_MIN 4 #define ZSTD_CONTENTLOG_MIN 4
#define ZSTD_HASHLOG_MAX 28 #define ZSTD_HASHLOG_MAX 28
@ -63,7 +65,7 @@ extern "C" {
#define ZSTD_SEARCHLENGTH_MAX 7 #define ZSTD_SEARCHLENGTH_MAX 7
#define ZSTD_SEARCHLENGTH_MIN 4 #define ZSTD_SEARCHLENGTH_MIN 4
/** from faster to stronger */ /* from faster to stronger */
typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2, ZSTD_opt, ZSTD_opt_bt } ZSTD_strategy; typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2, ZSTD_opt, ZSTD_opt_bt } ZSTD_strategy;
typedef struct typedef struct
@ -72,7 +74,7 @@ typedef struct
U32 sufficientLength; /* size of matches which is acceptable (used only by the optimal parser): larger == more compression, slower */ U32 sufficientLength; /* size of matches which is acceptable (used only by the optimal parser): larger == more compression, slower */
U32 windowLog; /* largest match distance : larger == more compression, more memory needed during decompression */ U32 windowLog; /* largest match distance : larger == more compression, more memory needed during decompression */
U32 contentLog; /* full search segment : larger == more compression, slower, more memory (useless for fast) */ U32 contentLog; /* full search segment : larger == more compression, slower, more memory (useless for fast) */
U32 hashLog; /* dispatch table : larger == more memory, faster */ U32 hashLog; /* dispatch table : larger == faster, more memory */
U32 searchLog; /* nb of searches : larger == more compression, slower */ U32 searchLog; /* nb of searches : larger == more compression, slower */
U32 searchLength; /* size of matches : larger == faster decompression, sometimes less compression */ U32 searchLength; /* size of matches : larger == faster decompression, sometimes less compression */
ZSTD_strategy strategy; ZSTD_strategy strategy;
@ -82,7 +84,6 @@ typedef struct
/* ************************************* /* *************************************
* Advanced functions * Advanced functions
***************************************/ ***************************************/
#define ZSTD_MAX_CLEVEL 24
ZSTDLIB_API unsigned ZSTD_maxCLevel (void); ZSTDLIB_API unsigned ZSTD_maxCLevel (void);
/*! ZSTD_getParams() : /*! ZSTD_getParams() :

240
programs/paramgrill.c
View File

@ -1,6 +1,6 @@
/* /*
paramgrill.c - parameter tester for zstd_hc paramgrill.c - parameter tester for zstd
Copyright (C) Yann Collet 2015 Copyright (C) Yann Collet 2015-2016
GPL v2 License GPL v2 License
@ -19,11 +19,10 @@
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
You can contact the author at : You can contact the author at :
- zstd source repository : https://github.com/Cyan4973/zstd - zstd homepage : http://www.zstd.net/
- ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
*/ */
/************************************** /*-************************************
* Compiler Options * Compiler Options
**************************************/ **************************************/
/* Disable some Visual warning messages */ /* Disable some Visual warning messages */
@ -48,8 +47,8 @@
#endif #endif
/************************************** /*-************************************
* Includes * Dependencies
**************************************/ **************************************/
#include <stdlib.h> /* malloc */ #include <stdlib.h> /* malloc */
#include <stdio.h> /* fprintf, fopen, ftello64 */ #include <stdio.h> /* fprintf, fopen, ftello64 */
@ -71,7 +70,7 @@
#include "xxhash.h" #include "xxhash.h"
/************************************** /*-************************************
* Compiler Options * Compiler Options
**************************************/ **************************************/
/* S_ISREG & gettimeofday() are not supported by MSVC */ /* S_ISREG & gettimeofday() are not supported by MSVC */
@ -80,7 +79,7 @@
#endif #endif
/************************************** /*-************************************
* Constants * Constants
**************************************/ **************************************/
#define PROGRAM_DESCRIPTION "ZSTD_HC parameters tester" #define PROGRAM_DESCRIPTION "ZSTD_HC parameters tester"
@ -98,6 +97,8 @@
#define NBLOOPS 2 #define NBLOOPS 2
#define TIMELOOP 2000 #define TIMELOOP 2000
#define NB_LEVELS_TRACKED 30
static const size_t maxMemory = (sizeof(size_t)==4) ? (2 GB - 64 MB) : (size_t)(1ULL << ((sizeof(size_t)*8)-31)); static const size_t maxMemory = (sizeof(size_t)==4) ? (2 GB - 64 MB) : (size_t)(1ULL << ((sizeof(size_t)*8)-31));
#define DEFAULT_CHUNKSIZE (4<<20) #define DEFAULT_CHUNKSIZE (4<<20)
@ -110,13 +111,13 @@ static const int g_maxVariationTime = 60000; /* 60 sec */
static const int g_maxNbVariations = 64; static const int g_maxNbVariations = 64;
/************************************** /*-************************************
* Macros * Macros
**************************************/ **************************************/
#define DISPLAY(...) fprintf(stderr, __VA_ARGS__) #define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
/************************************** /*-************************************
* Benchmark Parameters * Benchmark Parameters
**************************************/ **************************************/
static U32 g_nbIterations = NBLOOPS; static U32 g_nbIterations = NBLOOPS;
@ -126,7 +127,7 @@ static U32 g_rand = 1;
static U32 g_singleRun = 0; static U32 g_singleRun = 0;
static U32 g_target = 0; static U32 g_target = 0;
static U32 g_noSeed = 0; static U32 g_noSeed = 0;
static ZSTD_parameters g_params = { 0, 0, 0, 0, 0, 0, ZSTD_greedy }; static ZSTD_parameters g_params = { 0, 0, 0, 0, 0, 0, 0, ZSTD_greedy };
void BMK_SetNbIterations(int nbLoops) void BMK_SetNbIterations(int nbLoops)
{ {
@ -135,7 +136,7 @@ void BMK_SetNbIterations(int nbLoops)
} }
/********************************************************* /*-*******************************************************
* Private functions * Private functions
*********************************************************/ *********************************************************/
@ -187,8 +188,7 @@ static size_t BMK_findMaxMem(U64 requiredMem)
if (requiredMem > maxMemory) requiredMem = maxMemory; if (requiredMem > maxMemory) requiredMem = maxMemory;
requiredMem += 2*step; requiredMem += 2*step;
while (!testmem) while (!testmem) {
{
requiredMem -= step; requiredMem -= step;
testmem = (BYTE*) malloc ((size_t)requiredMem); testmem = (BYTE*) malloc ((size_t)requiredMem);
} }
@ -226,7 +226,7 @@ U32 FUZ_rand(U32* src)
} }
/********************************************************* /*-*******************************************************
* Bench functions * Bench functions
*********************************************************/ *********************************************************/
typedef struct { typedef struct {
@ -265,14 +265,14 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
U32 Hlog = params.hashLog; U32 Hlog = params.hashLog;
U32 Slog = params.searchLog; U32 Slog = params.searchLog;
U32 Slength = params.searchLength; U32 Slength = params.searchLength;
U32 Tlength = params.sufficientLength;
ZSTD_strategy strat = params.strategy; ZSTD_strategy strat = params.strategy;
char name[30] = { 0 }; char name[30] = { 0 };
U64 crcOrig; U64 crcOrig;
/* Memory allocation & restrictions */ /* Memory allocation & restrictions */
snprintf(name, 30, "Sw%02uc%02uh%02us%02ul%1ut%1u", Wlog, Clog, Hlog, Slog, Slength, strat); snprintf(name, 30, "Sw%02uc%02uh%02us%02ul%1ut%03uS%1u", Wlog, Clog, Hlog, Slog, Slength, Tlength, strat);
if (!compressedBuffer || !resultBuffer || !blockTable) if (!compressedBuffer || !resultBuffer || !blockTable) {
{
DISPLAY("\nError: not enough memory!\n"); DISPLAY("\nError: not enough memory!\n");
free(compressedBuffer); free(compressedBuffer);
free(resultBuffer); free(resultBuffer);
@ -290,8 +290,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
const char* srcPtr = (const char*)srcBuffer; const char* srcPtr = (const char*)srcBuffer;
char* cPtr = (char*)compressedBuffer; char* cPtr = (char*)compressedBuffer;
char* resPtr = (char*)resultBuffer; char* resPtr = (char*)resultBuffer;
for (i=0; i<nbBlocks; i++) for (i=0; i<nbBlocks; i++) {
{
size_t thisBlockSize = MIN(remaining, blockSize); size_t thisBlockSize = MIN(remaining, blockSize);
blockTable[i].srcPtr = srcPtr; blockTable[i].srcPtr = srcPtr;
blockTable[i].cPtr = cPtr; blockTable[i].cPtr = cPtr;
@ -302,8 +301,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
cPtr += blockTable[i].cRoom; cPtr += blockTable[i].cRoom;
resPtr += thisBlockSize; resPtr += thisBlockSize;
remaining -= thisBlockSize; remaining -= thisBlockSize;
} } }
}
/* warmimg up memory */ /* warmimg up memory */
RDG_genBuffer(compressedBuffer, maxCompressedSize, 0.10, 0.10, 1); RDG_genBuffer(compressedBuffer, maxCompressedSize, 0.10, 0.10, 1);
@ -318,8 +316,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
const int startTime =BMK_GetMilliStart(); const int startTime =BMK_GetMilliStart();
DISPLAY("\r%79s\r", ""); DISPLAY("\r%79s\r", "");
for (loopNb = 1; loopNb <= g_nbIterations; loopNb++) for (loopNb = 1; loopNb <= g_nbIterations; loopNb++) {
{
int nbLoops; int nbLoops;
int milliTime; int milliTime;
U32 blockNb; U32 blockNb;
@ -336,8 +333,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
milliTime = BMK_GetMilliStart(); milliTime = BMK_GetMilliStart();
while (BMK_GetMilliStart() == milliTime); while (BMK_GetMilliStart() == milliTime);
milliTime = BMK_GetMilliStart(); milliTime = BMK_GetMilliStart();
while (BMK_GetMilliSpan(milliTime) < TIMELOOP) while (BMK_GetMilliSpan(milliTime) < TIMELOOP) {
{
for (blockNb=0; blockNb<nbBlocks; blockNb++) for (blockNb=0; blockNb<nbBlocks; blockNb++)
blockTable[blockNb].cSize = ZSTD_compress_advanced(ctx, blockTable[blockNb].cSize = ZSTD_compress_advanced(ctx,
blockTable[blockNb].cPtr, blockTable[blockNb].cRoom, blockTable[blockNb].cPtr, blockTable[blockNb].cRoom,
@ -367,8 +363,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
milliTime = BMK_GetMilliStart(); milliTime = BMK_GetMilliStart();
while (BMK_GetMilliStart() == milliTime); while (BMK_GetMilliStart() == milliTime);
milliTime = BMK_GetMilliStart(); milliTime = BMK_GetMilliStart();
for ( ; BMK_GetMilliSpan(milliTime) < TIMELOOP; nbLoops++) for ( ; BMK_GetMilliSpan(milliTime) < TIMELOOP; nbLoops++) {
{
for (blockNb=0; blockNb<nbBlocks; blockNb++) for (blockNb=0; blockNb<nbBlocks; blockNb++)
blockTable[blockNb].resSize = ZSTD_decompress(blockTable[blockNb].resPtr, blockTable[blockNb].srcSize, blockTable[blockNb].resSize = ZSTD_decompress(blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
blockTable[blockNb].cPtr, blockTable[blockNb].cSize); blockTable[blockNb].cPtr, blockTable[blockNb].cSize);
@ -384,24 +379,19 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
/* CRC Checking */ /* CRC Checking */
crcCheck = XXH64(resultBuffer, srcSize, 0); crcCheck = XXH64(resultBuffer, srcSize, 0);
if (crcOrig!=crcCheck) if (crcOrig!=crcCheck) {
{
unsigned u; unsigned u;
unsigned eBlockSize = (unsigned)(MIN(65536*2, blockSize)); unsigned eBlockSize = (unsigned)(MIN(65536*2, blockSize));
DISPLAY("\n!!! WARNING !!! Invalid Checksum : %x != %x\n", (unsigned)crcOrig, (unsigned)crcCheck); DISPLAY("\n!!! WARNING !!! Invalid Checksum : %x != %x\n", (unsigned)crcOrig, (unsigned)crcCheck);
for (u=0; u<srcSize; u++) for (u=0; u<srcSize; u++) {
{ if (((const BYTE*)srcBuffer)[u] != ((BYTE*)resultBuffer)[u]) {
if (((const BYTE*)srcBuffer)[u] != ((BYTE*)resultBuffer)[u])
{
printf("Decoding error at pos %u (block %u, pos %u) \n", u, u / eBlockSize, u % eBlockSize); printf("Decoding error at pos %u (block %u, pos %u) \n", u, u / eBlockSize, u % eBlockSize);
break; break;
} } }
}
break; break;
} }
#endif #endif
} } }
}
/* End cleaning */ /* End cleaning */
DISPLAY("\r"); DISPLAY("\r");
@ -415,21 +405,23 @@ const char* g_stratName[] = { "ZSTD_fast ",
"ZSTD_greedy ", "ZSTD_greedy ",
"ZSTD_lazy ", "ZSTD_lazy ",
"ZSTD_lazy2 ", "ZSTD_lazy2 ",
"ZSTD_btlazy2" }; "ZSTD_btlazy2",
"ZSTD_opt ",
"ZSTD_opt_bt " };
static void BMK_printWinner(FILE* f, U32 cLevel, BMK_result_t result, ZSTD_parameters params, size_t srcSize) static void BMK_printWinner(FILE* f, U32 cLevel, BMK_result_t result, ZSTD_parameters params, size_t srcSize)
{ {
DISPLAY("\r%79s\r", ""); DISPLAY("\r%79s\r", "");
fprintf(f," {%3u,%3u,%3u,%3u,%3u,%3u, %s }, ", fprintf(f," {%3u,%3u,%3u,%3u,%3u,%3u,%3u, %s }, ",
0, params.windowLog, params.contentLog, params.hashLog, params.searchLog, params.searchLength, 0, params.windowLog, params.contentLog, params.hashLog, params.searchLog, params.searchLength,
g_stratName[(U32)(params.strategy)]); params.sufficientLength, g_stratName[(U32)(params.strategy)]);
fprintf(f, fprintf(f,
"/* level %2u */ /* R:%5.3f at %5.1f MB/s - %5.1f MB/s */\n", "/* 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.); cLevel, (double)srcSize / result.cSize, (double)result.cSpeed / 1000., (double)result.dSpeed / 1000.);
} }
static U32 g_cSpeedTarget[ZSTD_MAX_CLEVEL+1] = { 0 }; static U32 g_cSpeedTarget[NB_LEVELS_TRACKED] = { 0 }; /* NB_LEVELS_TRACKED : to check */
typedef struct { typedef struct {
BMK_result_t result; BMK_result_t result;
@ -438,14 +430,12 @@ typedef struct {
static void BMK_printWinners2(FILE* f, const winnerInfo_t* winners, size_t srcSize) static void BMK_printWinners2(FILE* f, const winnerInfo_t* winners, size_t srcSize)
{ {
int cLevel; unsigned cLevel;
fprintf(f, "\n /* Proposed configurations : */ \n"); fprintf(f, "\n /* Proposed configurations : */ \n");
fprintf(f, "#define ZSTD_MAX_CLEVEL %2u \n", ZSTD_MAX_CLEVEL);
fprintf(f, "static const ZSTD_parameters ZSTD_defaultParameters[ZSTD_MAX_CLEVEL+1] = {\n");
fprintf(f, " /* l, W, C, H, S, L, strat */ \n"); fprintf(f, " /* l, W, C, H, S, L, strat */ \n");
for (cLevel=0; cLevel <= ZSTD_MAX_CLEVEL; cLevel++) for (cLevel=0; cLevel <= ZSTD_maxCLevel(); cLevel++)
BMK_printWinner(f, cLevel, winners[cLevel].result, winners[cLevel].params, srcSize); BMK_printWinner(f, cLevel, winners[cLevel].result, winners[cLevel].params, srcSize);
} }
@ -465,16 +455,14 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
{ {
BMK_result_t testResult; BMK_result_t testResult;
int better = 0; int better = 0;
int cLevel; unsigned cLevel;
BMK_benchParam(&testResult, srcBuffer, srcSize, ctx, params); BMK_benchParam(&testResult, srcBuffer, srcSize, ctx, params);
for (cLevel = 1; cLevel <= ZSTD_MAX_CLEVEL; cLevel++) for (cLevel = 1; cLevel <= ZSTD_maxCLevel(); cLevel++) {
{
if (testResult.cSpeed < g_cSpeedTarget[cLevel]) if (testResult.cSpeed < g_cSpeedTarget[cLevel])
continue; /* not fast enough for this level */ continue; /* not fast enough for this level */
if (winners[cLevel].result.cSize==0) if (winners[cLevel].result.cSize==0) {
{
/* first solution for this cLevel */ /* first solution for this cLevel */
winners[cLevel].result = testResult; winners[cLevel].result = testResult;
winners[cLevel].params = params; winners[cLevel].params = params;
@ -483,8 +471,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
continue; continue;
} }
if ((double)testResult.cSize <= ((double)winners[cLevel].result.cSize * (1. + (0.02 / cLevel))) ) if ((double)testResult.cSize <= ((double)winners[cLevel].result.cSize * (1. + (0.02 / cLevel))) ) {
{
/* Validate solution is "good enough" */ /* Validate solution is "good enough" */
double W_ratio = (double)srcSize / testResult.cSize; double W_ratio = (double)srcSize / testResult.cSize;
double O_ratio = (double)srcSize / winners[cLevel].result.cSize; double O_ratio = (double)srcSize / winners[cLevel].result.cSize;
@ -509,8 +496,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
double O_DSpeed_note = O_ratioNote * ( 20 + 2*cLevel) + log((double)winners[cLevel].result.dSpeed); double O_DSpeed_note = O_ratioNote * ( 20 + 2*cLevel) + log((double)winners[cLevel].result.dSpeed);
if (W_DMemUsed_note < O_DMemUsed_note) if (W_DMemUsed_note < O_DMemUsed_note) {
{
/* uses too much Decompression memory for too little benefit */ /* uses too much Decompression memory for too little benefit */
if (W_ratio > O_ratio) if (W_ratio > O_ratio)
DISPLAY ("Decompression Memory : %5.3f @ %4.1f MB vs %5.3f @ %4.1f MB : not enough for level %i\n", DISPLAY ("Decompression Memory : %5.3f @ %4.1f MB vs %5.3f @ %4.1f MB : not enough for level %i\n",
@ -518,8 +504,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
O_ratio, (double)(O_DMemUsed) / 1024 / 1024, cLevel); O_ratio, (double)(O_DMemUsed) / 1024 / 1024, cLevel);
continue; continue;
} }
if (W_CMemUsed_note < O_CMemUsed_note) if (W_CMemUsed_note < O_CMemUsed_note) {
{
/* uses too much memory for compression for too little benefit */ /* uses too much memory for compression for too little benefit */
if (W_ratio > O_ratio) if (W_ratio > O_ratio)
DISPLAY ("Compression Memory : %5.3f @ %4.1f MB vs %5.3f @ %4.1f MB : not enough for level %i\n", DISPLAY ("Compression Memory : %5.3f @ %4.1f MB vs %5.3f @ %4.1f MB : not enough for level %i\n",
@ -527,8 +512,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
O_ratio, (double)(O_CMemUsed) / 1024 / 1024, cLevel); O_ratio, (double)(O_CMemUsed) / 1024 / 1024, cLevel);
continue; continue;
} }
if (W_CSpeed_note < O_CSpeed_note ) if (W_CSpeed_note < O_CSpeed_note ) {
{
/* too large compression speed difference for the compression benefit */ /* too large compression speed difference for the compression benefit */
if (W_ratio > O_ratio) if (W_ratio > O_ratio)
DISPLAY ("Compression Speed : %5.3f @ %4.1f MB/s vs %5.3f @ %4.1f MB/s : not enough for level %i\n", DISPLAY ("Compression Speed : %5.3f @ %4.1f MB/s vs %5.3f @ %4.1f MB/s : not enough for level %i\n",
@ -536,8 +520,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
O_ratio, (double)(winners[cLevel].result.cSpeed) / 1000., cLevel); O_ratio, (double)(winners[cLevel].result.cSpeed) / 1000., cLevel);
continue; continue;
} }
if (W_DSpeed_note < O_DSpeed_note ) if (W_DSpeed_note < O_DSpeed_note ) {
{
/* too large decompression speed difference for the compression benefit */ /* too large decompression speed difference for the compression benefit */
if (W_ratio > O_ratio) if (W_ratio > O_ratio)
DISPLAY ("Decompression Speed : %5.3f @ %4.1f MB/s vs %5.3f @ %4.1f MB/s : not enough for level %i\n", DISPLAY ("Decompression Speed : %5.3f @ %4.1f MB/s vs %5.3f @ %4.1f MB/s : not enough for level %i\n",
@ -554,9 +537,7 @@ static int BMK_seed(winnerInfo_t* winners, const ZSTD_parameters params,
BMK_printWinner(stdout, cLevel, testResult, params, srcSize); BMK_printWinner(stdout, cLevel, testResult, params, srcSize);
better = 1; better = 1;
} } }
}
return better; return better;
} }
@ -567,10 +548,9 @@ static ZSTD_parameters* sanitizeParams(ZSTD_parameters params)
{ {
g_params = params; g_params = params;
if (params.strategy == ZSTD_fast) if (params.strategy == ZSTD_fast)
{ g_params.contentLog = 0, g_params.searchLog = 0;
g_params.contentLog = 0; if ((params.strategy != ZSTD_opt) && (params.strategy != ZSTD_opt_bt))
g_params.searchLog = 0; g_params.sufficientLength = 0;
}
return &g_params; return &g_params;
} }
@ -578,8 +558,7 @@ static ZSTD_parameters* sanitizeParams(ZSTD_parameters params)
static void paramVariation(ZSTD_parameters* p) static void paramVariation(ZSTD_parameters* p)
{ {
U32 nbChanges = (FUZ_rand(&g_rand) & 3) + 1; U32 nbChanges = (FUZ_rand(&g_rand) & 3) + 1;
for (; nbChanges; nbChanges--) for (; nbChanges; nbChanges--) {
{
const U32 changeID = FUZ_rand(&g_rand) % 12; const U32 changeID = FUZ_rand(&g_rand) % 12;
switch(changeID) switch(changeID)
{ {
@ -607,6 +586,10 @@ static void paramVariation(ZSTD_parameters* p)
p->strategy = (ZSTD_strategy)(((U32)p->strategy)+1); break; p->strategy = (ZSTD_strategy)(((U32)p->strategy)+1); break;
case 11: case 11:
p->strategy = (ZSTD_strategy)(((U32)p->strategy)-1); break; p->strategy = (ZSTD_strategy)(((U32)p->strategy)-1); break;
case 12:
p->sufficientLength *= 1 + ((double)(FUZ_rand(&g_rand)&255)) / 256.; break;
case 13:
p->sufficientLength /= 1 + ((double)(FUZ_rand(&g_rand)&255)) / 256.; break;
} }
} }
ZSTD_validateParams(p); ZSTD_validateParams(p);
@ -632,8 +615,7 @@ static void playAround(FILE* f, winnerInfo_t* winners,
int nbVariations = 0; int nbVariations = 0;
const int startTime = BMK_GetMilliStart(); const int startTime = BMK_GetMilliStart();
while (BMK_GetMilliSpan(startTime) < g_maxVariationTime) while (BMK_GetMilliSpan(startTime) < g_maxVariationTime) {
{
ZSTD_parameters p = params; ZSTD_parameters p = params;
if (nbVariations++ > g_maxNbVariations) break; if (nbVariations++ > g_maxNbVariations) break;
@ -658,15 +640,15 @@ static void playAround(FILE* f, winnerInfo_t* winners,
static void potentialRandomParams(ZSTD_parameters* p, U32 inverseChance) static void potentialRandomParams(ZSTD_parameters* p, U32 inverseChance)
{ {
U32 chance = (FUZ_rand(&g_rand) % (inverseChance+1)); U32 chance = (FUZ_rand(&g_rand) % (inverseChance+1));
if (!chance) if (!chance) {
{
/* totally random entry */ /* totally random entry */
p->contentLog = FUZ_rand(&g_rand) % (ZSTD_CONTENTLOG_MAX+1 - ZSTD_CONTENTLOG_MIN) + ZSTD_CONTENTLOG_MIN; p->contentLog = FUZ_rand(&g_rand) % (ZSTD_CONTENTLOG_MAX+1 - ZSTD_CONTENTLOG_MIN) + ZSTD_CONTENTLOG_MIN;
p->hashLog = FUZ_rand(&g_rand) % (ZSTD_HASHLOG_MAX+1 - ZSTD_HASHLOG_MIN) + ZSTD_HASHLOG_MIN; p->hashLog = FUZ_rand(&g_rand) % (ZSTD_HASHLOG_MAX+1 - ZSTD_HASHLOG_MIN) + ZSTD_HASHLOG_MIN;
p->searchLog = FUZ_rand(&g_rand) % (ZSTD_SEARCHLOG_MAX+1 - ZSTD_SEARCHLOG_MIN) + ZSTD_SEARCHLOG_MIN; p->searchLog = FUZ_rand(&g_rand) % (ZSTD_SEARCHLOG_MAX+1 - ZSTD_SEARCHLOG_MIN) + ZSTD_SEARCHLOG_MIN;
p->windowLog = FUZ_rand(&g_rand) % (ZSTD_WINDOWLOG_MAX+1 - ZSTD_WINDOWLOG_MIN) + ZSTD_WINDOWLOG_MIN; p->windowLog = FUZ_rand(&g_rand) % (ZSTD_WINDOWLOG_MAX+1 - ZSTD_WINDOWLOG_MIN) + ZSTD_WINDOWLOG_MIN;
p->searchLength=FUZ_rand(&g_rand) % (ZSTD_SEARCHLENGTH_MAX+1 - ZSTD_SEARCHLENGTH_MIN) + ZSTD_SEARCHLENGTH_MIN; p->searchLength=FUZ_rand(&g_rand) % (ZSTD_SEARCHLENGTH_MAX+1 - ZSTD_SEARCHLENGTH_MIN) + ZSTD_SEARCHLENGTH_MIN;
p->strategy = (ZSTD_strategy) (FUZ_rand(&g_rand) % (ZSTD_btlazy2+1)); p->sufficientLength=FUZ_rand(&g_rand) % (ZSTD_TARGETLENGTH_MAX+1 - ZSTD_TARGETLENGTH_MIN) + ZSTD_TARGETLENGTH_MIN;
p->strategy = (ZSTD_strategy) (FUZ_rand(&g_rand) % (ZSTD_opt_bt+1));
ZSTD_validateParams(p); ZSTD_validateParams(p);
} }
} }
@ -676,9 +658,8 @@ static void BMK_selectRandomStart(
const void* srcBuffer, size_t srcSize, const void* srcBuffer, size_t srcSize,
ZSTD_CCtx* ctx) ZSTD_CCtx* ctx)
{ {
U32 id = (FUZ_rand(&g_rand) % (ZSTD_MAX_CLEVEL+1)); U32 id = (FUZ_rand(&g_rand) % (ZSTD_maxCLevel()+1));
if ((id==0) || (winners[id].params.windowLog==0)) if ((id==0) || (winners[id].params.windowLog==0)) {
{
/* totally random entry */ /* totally random entry */
ZSTD_parameters p; ZSTD_parameters p;
potentialRandomParams(&p, 1); potentialRandomParams(&p, 1);
@ -695,14 +676,14 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
{ {
ZSTD_CCtx* ctx = ZSTD_createCCtx(); ZSTD_CCtx* ctx = ZSTD_createCCtx();
ZSTD_parameters params; ZSTD_parameters params;
winnerInfo_t winners[ZSTD_MAX_CLEVEL+1]; winnerInfo_t winners[NB_LEVELS_TRACKED];
int i; int i;
unsigned u;
const char* rfName = "grillResults.txt"; const char* rfName = "grillResults.txt";
FILE* f; FILE* f;
const size_t blockSize = g_blockSize ? g_blockSize : srcSize; const size_t blockSize = g_blockSize ? g_blockSize : srcSize;
if (g_singleRun) if (g_singleRun) {
{
BMK_result_t testResult; BMK_result_t testResult;
g_params.srcSize = blockSize; g_params.srcSize = blockSize;
ZSTD_validateParams(&g_params); ZSTD_validateParams(&g_params);
@ -718,8 +699,7 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
if (g_target) if (g_target)
g_cSpeedTarget[1] = g_target * 1000; g_cSpeedTarget[1] = g_target * 1000;
else else {
{
/* baseline config for level 1 */ /* baseline config for level 1 */
BMK_result_t testResult; BMK_result_t testResult;
params = ZSTD_getParams(1, blockSize); params = ZSTD_getParams(1, blockSize);
@ -728,14 +708,13 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
} }
/* establish speed objectives (relative to level 1) */ /* establish speed objectives (relative to level 1) */
for (i=2; i<=ZSTD_MAX_CLEVEL; i++) for (u=2; u<=ZSTD_maxCLevel(); u++)
g_cSpeedTarget[i] = (g_cSpeedTarget[i-1] * 25) >> 5; g_cSpeedTarget[u] = (g_cSpeedTarget[u-1] * 25) >> 5;
/* populate initial solution */ /* populate initial solution */
{ {
const int maxSeeds = g_noSeed ? 1 : ZSTD_MAX_CLEVEL; const int maxSeeds = g_noSeed ? 1 : ZSTD_maxCLevel();
for (i=1; i<=maxSeeds; i++) for (i=1; i<=maxSeeds; i++) {
{
params = ZSTD_getParams(i, blockSize); params = ZSTD_getParams(i, blockSize);
ZSTD_validateParams(&params); ZSTD_validateParams(&params);
BMK_seed(winners, params, srcBuffer, srcSize, ctx); BMK_seed(winners, params, srcBuffer, srcSize, ctx);
@ -746,8 +725,7 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
/* start tests */ /* start tests */
{ {
const int milliStart = BMK_GetMilliStart(); const int milliStart = BMK_GetMilliStart();
do do {
{
BMK_selectRandomStart(f, winners, srcBuffer, srcSize, ctx); BMK_selectRandomStart(f, winners, srcBuffer, srcSize, ctx);
} while (BMK_GetMilliSpan(milliStart) < g_grillDuration); } while (BMK_GetMilliSpan(milliStart) < g_grillDuration);
} }
@ -764,17 +742,13 @@ static void BMK_benchMem(void* srcBuffer, size_t srcSize)
static int benchSample(void) static int benchSample(void)
{ {
char* origBuff; void* origBuff;
size_t benchedSize = sampleSize; size_t benchedSize = sampleSize;
const char* name = "Sample 10MiB"; const char* name = "Sample 10MiB";
/* Allocation */ /* Allocation */
origBuff = (char*) malloc((size_t)benchedSize); origBuff = malloc(benchedSize);
if(!origBuff) if (!origBuff) { DISPLAY("\nError: not enough memory!\n"); return 12; }
{
DISPLAY("\nError: not enough memory!\n");
return 12;
}
/* Fill buffer */ /* Fill buffer */
RDG_genBuffer(origBuff, benchedSize, g_compressibility, 0.0, 0); RDG_genBuffer(origBuff, benchedSize, g_compressibility, 0.0, 0);
@ -794,8 +768,7 @@ int benchFiles(char** fileNamesTable, int nbFiles)
int fileIdx=0; int fileIdx=0;
/* Loop for each file */ /* Loop for each file */
while (fileIdx<nbFiles) while (fileIdx<nbFiles) {
{
FILE* inFile; FILE* inFile;
char* inFileName; char* inFileName;
U64 inFileSize; U64 inFileSize;
@ -806,25 +779,21 @@ int benchFiles(char** fileNamesTable, int nbFiles)
/* Check file existence */ /* Check file existence */
inFileName = fileNamesTable[fileIdx++]; inFileName = fileNamesTable[fileIdx++];
inFile = fopen( inFileName, "rb" ); inFile = fopen( inFileName, "rb" );
if (inFile==NULL) if (inFile==NULL) {
{
DISPLAY( "Pb opening %s\n", inFileName); DISPLAY( "Pb opening %s\n", inFileName);
return 11; return 11;
} }
/* Memory allocation & restrictions */ /* Memory allocation & restrictions */
inFileSize = BMK_GetFileSize(inFileName); inFileSize = BMK_GetFileSize(inFileName);
benchedSize = (size_t) BMK_findMaxMem(inFileSize*3) / 3; benchedSize = BMK_findMaxMem(inFileSize*3) / 3;
if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize; if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
if (benchedSize < inFileSize) if (benchedSize < inFileSize)
{
DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize>>20)); DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize>>20));
}
/* Alloc */ /* Alloc */
origBuff = (char*) malloc((size_t)benchedSize); origBuff = (char*) malloc((size_t)benchedSize);
if(!origBuff) if(!origBuff) {
{
DISPLAY("\nError: not enough memory!\n"); DISPLAY("\nError: not enough memory!\n");
fclose(inFile); fclose(inFile);
return 12; return 12;
@ -835,8 +804,7 @@ int benchFiles(char** fileNamesTable, int nbFiles)
readSize = fread(origBuff, 1, benchedSize, inFile); readSize = fread(origBuff, 1, benchedSize, inFile);
fclose(inFile); fclose(inFile);
if(readSize != benchedSize) if(readSize != benchedSize) {
{
DISPLAY("\nError: problem reading file '%s' !! \n", inFileName); DISPLAY("\nError: problem reading file '%s' !! \n", inFileName);
free(origBuff); free(origBuff);
return 13; return 13;
@ -862,8 +830,7 @@ int optimizeForSize(char* inFileName)
/* Check file existence */ /* Check file existence */
inFile = fopen( inFileName, "rb" ); inFile = fopen( inFileName, "rb" );
if (inFile==NULL) if (inFile==NULL) {
{
DISPLAY( "Pb opening %s\n", inFileName); DISPLAY( "Pb opening %s\n", inFileName);
return 11; return 11;
} }
@ -873,14 +840,11 @@ int optimizeForSize(char* inFileName)
benchedSize = (size_t) BMK_findMaxMem(inFileSize*3) / 3; benchedSize = (size_t) BMK_findMaxMem(inFileSize*3) / 3;
if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize; if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
if (benchedSize < inFileSize) if (benchedSize < inFileSize)
{
DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize>>20)); DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize>>20));
}
/* Alloc */ /* Alloc */
origBuff = (char*) malloc((size_t)benchedSize); origBuff = (char*) malloc((size_t)benchedSize);
if(!origBuff) if(!origBuff) {
{
DISPLAY("\nError: not enough memory!\n"); DISPLAY("\nError: not enough memory!\n");
fclose(inFile); fclose(inFile);
return 12; return 12;
@ -891,8 +855,7 @@ int optimizeForSize(char* inFileName)
readSize = fread(origBuff, 1, benchedSize, inFile); readSize = fread(origBuff, 1, benchedSize, inFile);
fclose(inFile); fclose(inFile);
if(readSize != benchedSize) if(readSize != benchedSize) {
{
DISPLAY("\nError: problem reading file '%s' !! \n", inFileName); DISPLAY("\nError: problem reading file '%s' !! \n", inFileName);
free(origBuff); free(origBuff);
return 13; return 13;
@ -916,9 +879,8 @@ int optimizeForSize(char* inFileName)
/* find best solution from default params */ /* find best solution from default params */
{ {
const int maxSeeds = g_noSeed ? 1 : ZSTD_MAX_CLEVEL; const int maxSeeds = g_noSeed ? 1 : ZSTD_maxCLevel();
for (i=1; i<=maxSeeds; i++) for (i=1; i<=maxSeeds; i++) {
{
params = ZSTD_getParams(i, blockSize); params = ZSTD_getParams(i, blockSize);
BMK_benchParam(&candidate, origBuff, benchedSize, ctx, params); BMK_benchParam(&candidate, origBuff, benchedSize, ctx, params);
if ( (candidate.cSize < winner.result.cSize) if ( (candidate.cSize < winner.result.cSize)
@ -927,16 +889,14 @@ int optimizeForSize(char* inFileName)
winner.params = params; winner.params = params;
winner.result = candidate; winner.result = candidate;
BMK_printWinner(stdout, i, winner.result, winner.params, benchedSize); BMK_printWinner(stdout, i, winner.result, winner.params, benchedSize);
} } }
}
} }
BMK_printWinner(stdout, 99, winner.result, winner.params, benchedSize); BMK_printWinner(stdout, 99, winner.result, winner.params, benchedSize);
/* start tests */ /* start tests */
{ {
const int milliStart = BMK_GetMilliStart(); const int milliStart = BMK_GetMilliStart();
do do {
{
params = winner.params; params = winner.params;
paramVariation(&params); paramVariation(&params);
potentialRandomParams(&params, 16); potentialRandomParams(&params, 16);
@ -950,13 +910,11 @@ int optimizeForSize(char* inFileName)
/* improvement found => new winner */ /* improvement found => new winner */
if ( (candidate.cSize < winner.result.cSize) if ( (candidate.cSize < winner.result.cSize)
||((candidate.cSize == winner.result.cSize) && (candidate.cSpeed > winner.result.cSpeed)) ) ||((candidate.cSize == winner.result.cSize) && (candidate.cSpeed > winner.result.cSpeed)) ) {
{
winner.params = params; winner.params = params;
winner.result = candidate; winner.result = candidate;
BMK_printWinner(stdout, 99, winner.result, winner.params, benchedSize); BMK_printWinner(stdout, 99, winner.result, winner.params, benchedSize);
} }
} while (BMK_GetMilliSpan(milliStart) < g_grillDuration); } while (BMK_GetMilliSpan(milliStart) < g_grillDuration);
} }
@ -1008,6 +966,12 @@ int main(int argc, char** argv)
U32 optimizer = 0; U32 optimizer = 0;
U32 main_pause = 0; U32 main_pause = 0;
/* checks */
if (NB_LEVELS_TRACKED <= ZSTD_maxCLevel()) {
DISPLAY("Error : NB_LEVELS_TRACKED <= ZSTD_maxCLevel() \n");
exit(1);
}
/* Welcome message */ /* Welcome message */
DISPLAY(WELCOME_MESSAGE); DISPLAY(WELCOME_MESSAGE);
@ -1022,12 +986,10 @@ int main(int argc, char** argv)
if(!strcmp(argument,"--no-seed")) { g_noSeed = 1; continue; } if(!strcmp(argument,"--no-seed")) { g_noSeed = 1; continue; }
/* Decode command (note : aggregated commands are allowed) */ /* Decode command (note : aggregated commands are allowed) */
if (argument[0]=='-') if (argument[0]=='-') {
{
argument++; argument++;
while (argument[0]!=0) while (argument[0]!=0) {
{
switch(argument[0]) switch(argument[0])
{ {
@ -1050,8 +1012,7 @@ int main(int argc, char** argv)
argument++; argument++;
{ {
U32 proba32 = 0; U32 proba32 = 0;
while ((argument[0]>= '0') && (argument[0]<= '9')) while ((argument[0]>= '0') && (argument[0]<= '9')) {
{
proba32 *= 10; proba32 *= 10;
proba32 += argument[0] - '0'; proba32 += argument[0] - '0';
argument++; argument++;
@ -1070,8 +1031,7 @@ int main(int argc, char** argv)
g_singleRun = 1; g_singleRun = 1;
argument++; argument++;
g_params = ZSTD_getParams(2, g_blockSize); g_params = ZSTD_getParams(2, g_blockSize);
for ( ; ; ) for ( ; ; ) {
{
switch(*argument) switch(*argument)
{ {
case 'w': case 'w':
@ -1107,8 +1067,7 @@ int main(int argc, char** argv)
case 't': /* strategy */ case 't': /* strategy */
g_params.strategy = (ZSTD_strategy)0; g_params.strategy = (ZSTD_strategy)0;
argument++; argument++;
while ((*argument>= '0') && (*argument<='9')) while ((*argument>= '0') && (*argument<='9')) {
{
g_params.strategy = (ZSTD_strategy)((U32)g_params.strategy *10); g_params.strategy = (ZSTD_strategy)((U32)g_params.strategy *10);
g_params.strategy = (ZSTD_strategy)((U32)g_params.strategy + *argument++ - '0'); g_params.strategy = (ZSTD_strategy)((U32)g_params.strategy + *argument++ - '0');
} }
@ -1132,8 +1091,7 @@ int main(int argc, char** argv)
case 'T': case 'T':
argument++; argument++;
g_target = 0; g_target = 0;
while ((*argument >= '0') && (*argument <= '9')) while ((*argument >= '0') && (*argument <= '9')) {
{
g_target *= 10; g_target *= 10;
g_target += *argument - '0'; g_target += *argument - '0';
argument++; argument++;
@ -1167,8 +1125,7 @@ int main(int argc, char** argv)
if (filenamesStart==0) if (filenamesStart==0)
result = benchSample(); result = benchSample();
else else {
{
if (optimizer) if (optimizer)
result = optimizeForSize(input_filename); result = optimizeForSize(input_filename);
else else
@ -1179,4 +1136,3 @@ int main(int argc, char** argv)
return result; return result;
} }