Lines Matching defs:cParams

223 /* Returns row matchfinder usage given an initial mode and cParams */
225                                                          const ZSTD_compressionParameters* const cParams) {
233     if (!ZSTD_rowMatchFinderSupported(cParams->strategy)) return mode;
235         if (cParams->windowLog > 14) mode = ZSTD_ps_enable;
237         if (cParams->windowLog > 17) mode = ZSTD_ps_enable;
244                                                         const ZSTD_compressionParameters* const cParams) {
246     return (cParams->strategy >= ZSTD_btopt && cParams->windowLog >= 17) ? ZSTD_ps_enable : ZSTD_ps_disable;
265                                  const ZSTD_compressionParameters* const cParams) {
267     return (cParams->strategy >= ZSTD_btopt && cParams->windowLog >= 27) ? ZSTD_ps_enable : ZSTD_ps_disable;
271         ZSTD_compressionParameters cParams)
274     /* should not matter, as all cParams are presumed properly defined */
276     cctxParams.cParams = cParams;
278     /* Adjust advanced params according to cParams */
279     cctxParams.ldmParams.enableLdm = ZSTD_resolveEnableLdm(cctxParams.ldmParams.enableLdm, &cParams);
281         ZSTD_ldm_adjustParameters(&cctxParams.ldmParams, &cParams);
285     cctxParams.useBlockSplitter = ZSTD_resolveBlockSplitterMode(cctxParams.useBlockSplitter, &cParams);
286     cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);
287     assert(!ZSTD_checkCParams(cParams));
337     assert(!ZSTD_checkCParams(params->cParams));
339     cctxParams->cParams = params->cParams;
341     /* Should not matter, as all cParams are presumed properly defined.
345     cctxParams->useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams->useRowMatchFinder, &params->cParams);
346     cctxParams->useBlockSplitter = ZSTD_resolveBlockSplitterMode(cctxParams->useBlockSplitter, &params->cParams);
347     cctxParams->ldmParams.enableLdm = ZSTD_resolveEnableLdm(cctxParams->ldmParams.enableLdm, &params->cParams);
355     FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
361  * Sets cctxParams' cParams and fParams from params, but otherwise leaves them alone.
367     assert(!ZSTD_checkCParams(params->cParams));
368     cctxParams->cParams = params->cParams;
370     /* Should not matter, as all cParams are presumed properly defined.
702         CCtxParams->cParams.windowLog = (U32)value;
703         return CCtxParams->cParams.windowLog;
708         CCtxParams->cParams.hashLog = (U32)value;
709         return CCtxParams->cParams.hashLog;
714         CCtxParams->cParams.chainLog = (U32)value;
715         return CCtxParams->cParams.chainLog;
720         CCtxParams->cParams.searchLog = (U32)value;
726         CCtxParams->cParams.minMatch = value;
727         return CCtxParams->cParams.minMatch;
731         CCtxParams->cParams.targetLength = value;
732         return CCtxParams->cParams.targetLength;
737         CCtxParams->cParams.strategy = (ZSTD_strategy)value;
738         return (size_t)CCtxParams->cParams.strategy;
890         *value = (int)CCtxParams->cParams.windowLog;
893         *value = (int)CCtxParams->cParams.hashLog;
896         *value = (int)CCtxParams->cParams.chainLog;
899         *value = CCtxParams->cParams.searchLog;
902         *value = CCtxParams->cParams.minMatch;
905         *value = CCtxParams->cParams.targetLength;
908         *value = (unsigned)CCtxParams->cParams.strategy;
1022         const ZSTD_compressionParameters* cParams);
1024         ZSTD_compressionParameters* cParams);
1163 size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
1165     BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
1166     BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
1167     BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
1168     BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
1169     BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
1170     BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
1171     BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy);
1179 ZSTD_clampCParams(ZSTD_compressionParameters cParams)
1187     CLAMP(ZSTD_c_windowLog, cParams.windowLog);
1188     CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
1189     CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
1190     CLAMP(ZSTD_c_searchLog, cParams.searchLog);
1191     CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
1192     CLAMP(ZSTD_c_targetLength,cParams.targetLength);
1193     CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
1194     return cParams;
1320               ZSTD_compressionParameters* cParams,
1323     if (overrides->windowLog)    cParams->windowLog    = overrides->windowLog;
1324     if (overrides->hashLog)      cParams->hashLog      = overrides->hashLog;
1325     if (overrides->chainLog)     cParams->chainLog     = overrides->chainLog;
1326     if (overrides->searchLog)    cParams->searchLog    = overrides->searchLog;
1327     if (overrides->minMatch)     cParams->minMatch     = overrides->minMatch;
1328     if (overrides->targetLength) cParams->targetLength = overrides->targetLength;
1329     if (overrides->strategy)     cParams->strategy     = overrides->strategy;
1335     ZSTD_compressionParameters cParams;
1339     cParams = ZSTD_getCParams_internal(CCtxParams->compressionLevel, srcSizeHint, dictSize, mode);
1340     if (CCtxParams->ldmParams.enableLdm == ZSTD_ps_enable) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
1341     ZSTD_overrideCParams(&cParams, &CCtxParams->cParams);
1342     assert(!ZSTD_checkCParams(cParams));
1344     return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize, mode);
1348 ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
1354     size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)
1355                                 ? ((size_t)1 << cParams->chainLog)
1357     size_t const hSize = ((size_t)1) << cParams->hashLog;
1358     U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
1372     size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
1375     size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
1390         const ZSTD_compressionParameters* cParams,
1398     size_t const windowSize = (size_t) BOUNDED(1ULL, 1ULL << cParams->windowLog, pledgedSrcSize);
1400     U32    const divider = (cParams->minMatch==3) ? 3 : 4;
1407     size_t const matchStateSize = ZSTD_sizeof_matchState(cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 0, /* forCCtx */ 1);
1436     ZSTD_compressionParameters const cParams =
1439                                                                                &cParams);
1446         &cParams, &params->ldmParams, 1, useRowMatchFinder, 0, 0, ZSTD_CONTENTSIZE_UNKNOWN);
1449 size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams)
1451     ZSTD_CCtx_params initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);
1452     if (ZSTD_rowMatchFinderSupported(cParams.strategy)) {
1472         /* Choose the set of cParams for a given level across all srcSizes that give the largest cctxSize */
1473         ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeTiers[tier], 0, ZSTD_cpm_noAttachDict);
1474         largestSize = MAX(ZSTD_estimateCCtxSize_usingCParams(cParams), largestSize);
1494     {   ZSTD_compressionParameters const cParams =
1496         size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
1498                 ? ((size_t)1 << cParams.windowLog) + blockSize
1503         ZSTD_paramSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params->useRowMatchFinder, &params->cParams);
1506             &cParams, &params->ldmParams, 1, useRowMatchFinder, inBuffSize, outBuffSize,
1511 size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
1513     ZSTD_CCtx_params initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);
1514     if (ZSTD_rowMatchFinderSupported(cParams.strategy)) {
1530     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
1531     return ZSTD_estimateCStreamSize_usingCParams(cParams);
1644                 const ZSTD_compressionParameters* cParams,
1651     size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder,
1653                                 ? ((size_t)1 << cParams->chainLog)
1655     size_t const hSize = ((size_t)1) << cParams->hashLog;
1656     U32    const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
1689     if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {
1699     if (ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)) {
1706             U32 const rowLog = BOUNDED(4, cParams->searchLog, 6);
1707             assert(cParams->hashLog >= rowLog);
1708             ms->rowHashLog = cParams->hashLog - rowLog;
1712     ms->cParams = *cParams;
1757                 (U32)pledgedSrcSize, params->cParams.windowLog, (int)params->useRowMatchFinder, (int)params->useBlockSplitter);
1758     assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
1773         ZSTD_ldm_adjustParameters(&zc->appliedParams.ldmParams, &params->cParams);
1778     {   size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params->cParams.windowLog), pledgedSrcSize));
1780         U32    const divider = (params->cParams.minMatch==3) ? 3 : 4;
1797                 &params->cParams, &params->ldmParams, zc->staticSize != 0, params->useRowMatchFinder,
1840         zc->blockState.matchState.cParams = params->cParams;
1891             &params->cParams,
1950     size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
1971         ZSTD_compressionParameters adjusted_cdict_cParams = cdict->matchState.cParams;
1972         unsigned const windowLog = params.cParams.windowLog;
1982         params.cParams = ZSTD_adjustCParams_internal(adjusted_cdict_cParams, pledgedSrcSize,
1984         params.cParams.windowLog = windowLog;
1989         assert(cctx->appliedParams.cParams.strategy == adjusted_cdict_cParams.strategy);
2028     const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;
2034     {   unsigned const windowLog = params.cParams.windowLog;
2037         params.cParams = *cdict_cParams;
2038         params.cParams.windowLog = windowLog;
2043         assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
2044         assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog);
2045         assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog);
2061         if (ZSTD_allocateChainTable(cctx->appliedParams.cParams.strategy, cctx->appliedParams.useRowMatchFinder, 0 /* forDDSDict */)) {
2142         params.cParams = srcCCtx->appliedParams.cParams;
2153         assert(dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog);
2154         assert(dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy);
2155         assert(dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog);
2156         assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog);
2163     {   size_t const chainSize = ZSTD_allocateChainTable(srcCCtx->appliedParams.cParams.strategy,
2166                                     ? ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog)
2168         size_t const hSize =  (size_t)1 << srcCCtx->appliedParams.cParams.hashLog;
2272     {   U32 const hSize = (U32)1 << params->cParams.hashLog;
2276     if (ZSTD_allocateChainTable(params->cParams.strategy, params->useRowMatchFinder, (U32)ms->dedicatedDictSearch)) {
2277         U32 const chainSize = (U32)1 << params->cParams.chainLog;
2278         if (params->cParams.strategy == ZSTD_btlazy2)
2491     const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
2492     ZSTD_strategy const strategy = cctxParams->cParams.strategy;
2523                                     cctxParams->cParams.strategy,
2623     {   size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
2729     ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
2731         if (zc->appliedParams.cParams.strategy >= ZSTD_btopt) {
2734             ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);
2792             ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy,
3089     ZSTD_strategy const strategy = cctxParams->cParams.strategy;
3773                 size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, zc->appliedParams.cParams.strategy);
3816     U32 const cycleLog = ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy);
3817     U32 const maxDist = (U32)1 << params->cParams.windowLog;
3851     U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
3853     assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);
3927     U32   const windowSize = (U32)1 << params->cParams.windowLog;
3929     BYTE  const windowLogByte = (BYTE)((params->cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
4092     ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
4093     assert(!ZSTD_checkCParams(cParams));
4094     return MIN (ZSTD_BLOCKSIZE_MAX, (U32)1 << cParams.windowLog);
4121     ZSTD_assertEqualCParams(params->cParams, ms->cParams);
4158     switch(params->cParams.strategy)
4177                 size_t const tagTableSize = ((size_t)1 << params->cParams.hashLog) * sizeof(U16);
4407     DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params->cParams.windowLog);
4409     assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
4450     DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params->cParams.windowLog);
4452     FORWARD_IF_ERROR( ZSTD_checkCParams(params->cParams) , "");
4573     FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
4640         size_t dictSize, ZSTD_compressionParameters cParams,
4648          + ZSTD_sizeof_matchState(&cParams, ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),
4656     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
4657     return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy);
4677     assert(!ZSTD_checkCParams(params.cParams));
4678     cdict->matchState.cParams = params.cParams;
4699         &params.cParams,
4724                                       ZSTD_compressionParameters cParams,
4734             ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, enableDedicatedDictSearch, /* forCCtx */ 0) +
4761                                       ZSTD_compressionParameters cParams,
4767     cctxParams.cParams = cParams;
4783     ZSTD_compressionParameters cParams;
4790         cParams = ZSTD_dedicatedDictSearch_getCParams(
4792         ZSTD_overrideCParams(&cParams, &cctxParams.cParams);
4794         cParams = ZSTD_getCParamsFromCCtxParams(
4798     if (!ZSTD_dedicatedDictSearch_isSupported(&cParams)) {
4801         cParams = ZSTD_getCParamsFromCCtxParams(
4806     cctxParams.cParams = cParams;
4807     cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);
4810                         dictLoadMethod, cctxParams.cParams,
4827     ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
4830                                                   cParams, ZSTD_defaultCMem);
4838     ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
4841                                      cParams, ZSTD_defaultCMem);
4867  *  cParams : use ZSTD_getCParams() to transform a compression level
4868  *            into its relevants cParams.
4878                                  ZSTD_compressionParameters cParams)
4880     ZSTD_paramSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams);
4882     size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0);
4906     params.cParams = cParams;
4922     return cdict->matchState.cParams;
4949         params.cParams = ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF
4966         cctxParams.cParams.windowLog = MAX(cctxParams.cParams.windowLog, limitedSrcLog);
5104     assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
5157     FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
5446         params.cParams = ZSTD_getCParamsFromCCtxParams(
5451     params.useBlockSplitter = ZSTD_resolveBlockSplitterMode(params.useBlockSplitter, &params.cParams);
5452     params.ldmParams.enableLdm = ZSTD_resolveEnableLdm(params.ldmParams.enableLdm, &params.cParams);
5453     params.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params.useRowMatchFinder, &params.cParams);
5456         assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
5629                                                 cctx->appliedParams.cParams.windowLog, dictSize),
5715                 if (matchLength > blockSize && firstHalfMatchLength >= cctx->appliedParams.cParams.minMatch) {
5718                     if (secondHalfMatchLength < cctx->appliedParams.cParams.minMatch) {
5720                         endPosInSequence -= cctx->appliedParams.cParams.minMatch - secondHalfMatchLength;
5721                         bytesAdjustment = cctx->appliedParams.cParams.minMatch - secondHalfMatchLength;
5752                                                    cctx->appliedParams.cParams.windowLog, dictSize),
5992     ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, 0, dictSize, ZSTD_cpm_createCDict);
5993     switch (cParams.strategy) {
6000             cParams.hashLog += ZSTD_LAZY_DDSS_BUCKET_LOG;
6008     return cParams;
6012         ZSTD_compressionParameters const* cParams)
6014     return (cParams->strategy >= ZSTD_greedy)
6015         && (cParams->strategy <= ZSTD_lazy2)
6016         && (cParams->hashLog > cParams->chainLog)
6017         && (cParams->chainLog <= 24);
6026         ZSTD_compressionParameters* cParams) {
6027     switch (cParams->strategy) {
6034             cParams->hashLog -= ZSTD_LAZY_DDSS_BUCKET_LOG;
6035             if (cParams->hashLog < ZSTD_HASHLOG_MIN) {
6036                 cParams->hashLog = ZSTD_HASHLOG_MIN;
6112     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
6115     params.cParams = cParams;