From 8fd16367761528cd1f49bcd0ab58f73e70a2e29a Mon Sep 17 00:00:00 2001 From: Stella Lau Date: Mon, 21 Aug 2017 18:10:44 -0700 Subject: [PATCH] Remove unused functions --- lib/common/zstd_internal.h | 4 +- lib/compress/zstd_compress.c | 200 +++------------------------------ lib/compress/zstdmt_compress.c | 12 +- tests/cctxParamRoundTrip.c | 2 + 4 files changed, 25 insertions(+), 193 deletions(-) diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h index ee316418..4e56f6a9 100644 --- a/lib/common/zstd_internal.h +++ b/lib/common/zstd_internal.h @@ -348,12 +348,12 @@ MEM_STATIC U32 ZSTD_highbit32(U32 val) void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); -/*! ZSTD_initCStream_internal_opaque() : +/*! ZSTD_initCStream_internal() : * Private use only. Init streaming operation. * expects params to be valid. * must receive dict, or cdict, or none, but not both. * @return : 0, or an error code */ -size_t ZSTD_initCStream_internal_opaque( +size_t ZSTD_initCStream_internal( ZSTD_CStream* zcs, const void* dict, size_t dictSize, const ZSTD_CDict* cdict, diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c index 649cf878..cfefe5c2 100644 --- a/lib/compress/zstd_compress.c +++ b/lib/compress/zstd_compress.c @@ -80,14 +80,8 @@ struct ZSTD_CCtx_s { U32 nextToUpdate3; /* index from which to continue dictionary update */ U32 hashLog3; /* dispatch table : larger == faster, more memory */ U32 loadedDictEnd; /* index of end of dictionary */ -#if 0 - U32 forceWindow; /* force back-references to respect limit of 1<cdict) { return ERROR(stage_wrong); } - /* TODO: some parameters can be set even if cctx->cdict. - * They can be set directly using ZSTD_CCtx_setParameter? - */ - /* Assume the compression and frame parameters are validated */ cctx->requestedParams.cParams = params->cParams; cctx->requestedParams.fParams = params->fParams; @@ -3611,19 +3594,6 @@ size_t ZSTD_compress(void* dst, size_t dstCapacity, const void* src, size_t srcS /* ===== Dictionary API ===== */ -#if 0 -size_t ZSTD_estimateCDictSize_advanced_opaque( - size_t dictSize, const ZSTD_CCtx_params* params) -{ - if (params == NULL) { return 0; } - DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (U32)sizeof(ZSTD_CDict)); - DEBUGLOG(5, "CCtx estimate : %u", - (U32)ZSTD_estimateCCtxSize_advanced_opaque(params)); - return sizeof(ZSTD_CDict) + ZSTD_estimateCCtxSize_advanced_opaque(params) - + (params->dictContentByRef ? 0 : dictSize); - -} -#endif /*! ZSTD_estimateCDictSize_advanced() : * Estimate amount of memory that will be needed to create a dictionary with following arguments */ @@ -3650,45 +3620,6 @@ size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict) return ZSTD_sizeof_CCtx(cdict->refContext) + (cdict->dictBuffer ? cdict->dictContentSize : 0) + sizeof(*cdict); } -#if 0 -static ZSTD_parameters ZSTD_makeParams(ZSTD_compressionParameters cParams, ZSTD_frameParameters fParams) -{ - ZSTD_parameters params; - params.cParams = cParams; - params.fParams = fParams; - return params; -} -#endif - -#if 0 -static size_t ZSTD_initCDict_internal_opaque(ZSTD_CDict* cdict, - const void* dictBuffer, size_t dictSize, - ZSTD_CCtx_params params) -{ - DEBUGLOG(5, "ZSTD_initCDict_internal_opaque, mode %u", (U32)params.dictMode); - if ((params.dictContentByRef) || (!dictBuffer) || (!dictSize)) { - cdict->dictBuffer = NULL; - cdict->dictContent = dictBuffer; - } else { - void* const internalBuffer = ZSTD_malloc(dictSize, cdict->refContext->customMem); - cdict->dictBuffer = internalBuffer; - cdict->dictContent = internalBuffer; - if (!internalBuffer) return ERROR(memory_allocation); - memcpy(internalBuffer, dictBuffer, dictSize); - } - cdict->dictContentSize = dictSize; - - /* TODO: do the frame parameters need to be zero? - * does nbThreads need to be zero? */ - CHECK_F( ZSTD_compressBegin_internal(cdict->refContext, - cdict->dictContent, dictSize, - NULL, - params, ZSTD_CONTENTSIZE_UNKNOWN, - ZSTDb_not_buffered) ); - return 0; -} -#endif - static size_t ZSTD_initCDict_internal( ZSTD_CDict* cdict, const void* dictBuffer, size_t dictSize, @@ -3710,6 +3641,7 @@ static size_t ZSTD_initCDict_internal( { ZSTD_frameParameters const fParams = { 0 /*contentSizeFlag */, 0 /* checksumFlag */, 0 /* noDictIDFlag */ }; /* dummy */ + /* TODO: correct? */ ZSTD_CCtx_params cctxParams = cdict->refContext->requestedParams; cctxParams.fParams = fParams; cctxParams.cParams = cParams; @@ -3724,35 +3656,6 @@ static size_t ZSTD_initCDict_internal( return 0; } -#if 0 -/* Internal only */ -ZSTD_CDict* ZSTD_createCDict_advanced_opaque( - const void* dictBuffer, size_t dictSize, - ZSTD_CCtx_params params, ZSTD_customMem customMem) -{ - DEBUGLOG(5, "ZSTD_createCDict_advanced_opaque, mode %u", (U32)params.dictMode); - if (!customMem.customAlloc ^ !customMem.customFree) return NULL; - - { ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem); - ZSTD_CCtx* const cctx = ZSTD_createCCtx_advanced(customMem); - if (!cdict || !cctx) { - ZSTD_free(cdict, customMem); - ZSTD_freeCCtx(cctx); - return NULL; - } - cdict->refContext = cctx; - if (ZSTD_isError( ZSTD_initCDict_internal_opaque( - cdict, - dictBuffer, dictSize, - params) )) { - ZSTD_freeCDict(cdict); - return NULL; - } - return cdict; - } -} -#endif - ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize, unsigned byReference, ZSTD_dictMode_e dictMode, ZSTD_compressionParameters cParams, ZSTD_customMem customMem) @@ -3807,45 +3710,6 @@ size_t ZSTD_freeCDict(ZSTD_CDict* cdict) } } -#if 0 -ZSTD_CDict* ZSTD_initStaticCDict_advanced_opaque( - void *workspace, size_t workspaceSize, const void* dict, - size_t dictSize, - const ZSTD_CCtx_params* params) -{ - if (params == NULL) { return NULL; } - { ZSTD_CCtx_params cctxParams = *params; - size_t const cctxSize = ZSTD_estimateCCtxSize_advanced_opaque(params); - size_t const neededSize = sizeof(ZSTD_CDict) - + (cctxParams.dictContentByRef ? 0 : dictSize) - + cctxSize; - ZSTD_CDict* const cdict = (ZSTD_CDict*) workspace; - void* ptr; - DEBUGLOG(5, "(size_t)workspace & 7 : %u", (U32)(size_t)workspace & 7); - if ((size_t)workspace & 7) return NULL; /* 8-aligned */ - DEBUGLOG(5, "(workspaceSize < neededSize) : (%u < %u) => %u", - (U32)workspaceSize, (U32)neededSize, (U32)(workspaceSize < neededSize)); - if (workspaceSize < neededSize) return NULL; - - if (!cctxParams.dictContentByRef) { - memcpy(cdict+1, dict, dictSize); - dict = cdict+1; - ptr = (char*)workspace + sizeof(ZSTD_CDict) + dictSize; - } else { - ptr = cdict+1; - } - cdict->refContext = ZSTD_initStaticCCtx(ptr, cctxSize); - cctxParams.dictContentByRef = 1; - - /* What if nbThreads > 1? */ - if (ZSTD_isError( ZSTD_initCDict_internal_opaque(cdict, dict, dictSize, cctxParams) )) - return NULL; - - return cdict; - } -} -#endif - /*! ZSTD_initStaticCDict_advanced() : * Generate a digested dictionary in provided memory area. * workspace: The memory area to emplace the dictionary into. @@ -3893,12 +3757,6 @@ ZSTD_CDict* ZSTD_initStaticCDict(void* workspace, size_t workspaceSize, return cdict; } -#if 0 -static ZSTD_parameters ZSTD_getParamsFromCDict(const ZSTD_CDict* cdict) { - return ZSTD_getParamsFromCCtx(cdict->refContext); -}a -#endif - ZSTD_CCtx_params ZSTD_getCCtxParamsFromCDict(const ZSTD_CDict* cdict) { return cdict->refContext->appliedParams; } @@ -3910,7 +3768,7 @@ size_t ZSTD_compressBegin_usingCDict_advanced( ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize) { if (cdict==NULL) return ERROR(dictionary_wrong); - { ZSTD_CCtx_params params = cdict->refContext->appliedParams; + { ZSTD_CCtx_params params = ZSTD_getCCtxParamsFromCDict(cdict); params.fParams = fParams; params.dictMode = ZSTD_dm_auto; DEBUGLOG(5, "ZSTD_compressBegin_usingCDict_advanced"); @@ -3992,7 +3850,7 @@ size_t ZSTD_CStreamOutSize(void) return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 /* 32-bits hash */ ; } -static size_t ZSTD_resetCStream_internal_opaque( +static size_t ZSTD_resetCStream_internal( ZSTD_CStream* zcs, const void* dict, size_t dictSize, const ZSTD_CDict* cdict, @@ -4018,20 +3876,6 @@ static size_t ZSTD_resetCStream_internal_opaque( return 0; /* ready to go */ } -#if 0 -static size_t ZSTD_resetCStream_internal(ZSTD_CStream* zcs, - const void* dict, size_t dictSize, ZSTD_dictMode_e dictMode, - const ZSTD_CDict* cdict, - ZSTD_parameters params, unsigned long long pledgedSrcSize) -{ - ZSTD_CCtx_params cctxParams = zcs->requestedParams; - cctxParams.cParams = params.cParams; - cctxParams.fParams = params.fParams; - return ZSTD_resetCStream_internal_opaque(zcs, dict, dictSize, - cdict, cctxParams, pledgedSrcSize); -} -#endif - size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize) { ZSTD_CCtx_params params = zcs->requestedParams; @@ -4040,10 +3884,14 @@ size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize) if (params.compressionLevel != ZSTD_CLEVEL_CUSTOM) { params.cParams = ZSTD_getCParams(params.compressionLevel, pledgedSrcSize, 0 /* dictSize */); } - return ZSTD_resetCStream_internal_opaque(zcs, NULL, 0, zcs->cdict, params, pledgedSrcSize); + return ZSTD_resetCStream_internal(zcs, NULL, 0, zcs->cdict, params, pledgedSrcSize); } -size_t ZSTD_initCStream_internal_opaque( +/*! ZSTD_initCStream_internal() : + * Note : not static (but hidden) (not exposed). Used by zstdmt_compress.c + * Assumption 1 : params are valid + * Assumption 2 : either dict, or cdict, is defined, not both */ +size_t ZSTD_initCStream_internal( ZSTD_CStream* zcs, const void* dict, size_t dictSize, const ZSTD_CDict* cdict, @@ -4079,28 +3927,10 @@ size_t ZSTD_initCStream_internal_opaque( } zcs->requestedParams = params; - return ZSTD_resetCStream_internal_opaque( + return ZSTD_resetCStream_internal( zcs, NULL, 0, zcs->cdict, params, pledgedSrcSize); } -#if 0 -/*! ZSTD_initCStream_internal() : - * Note : not static, but hidden (not exposed). Used by zstdmt_compress.c - * Assumption 1 : params are valid - * Assumption 2 : either dict, or cdict, is defined, not both */ -static size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs, - const void* dict, size_t dictSize, const ZSTD_CDict* cdict, - ZSTD_parameters params, unsigned long long pledgedSrcSize) -{ - ZSTD_CCtx_params cctxParams = zcs->requestedParams; - cctxParams.cParams = params.cParams; - cctxParams.fParams = params.fParams; - cctxParams.compressionLevel = ZSTD_CLEVEL_CUSTOM; - return ZSTD_initCStream_internal_opaque(zcs, dict, dictSize, cdict, - cctxParams, pledgedSrcSize); -} -#endif - /* ZSTD_initCStream_usingCDict_advanced() : * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, @@ -4112,7 +3942,7 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, { ZSTD_CCtx_params params = ZSTD_getCCtxParamsFromCDict(cdict); params.fParams = fParams; params.compressionLevel = ZSTD_CLEVEL_CUSTOM; - return ZSTD_initCStream_internal_opaque(zcs, + return ZSTD_initCStream_internal(zcs, NULL, 0, cdict, params, pledgedSrcSize); } @@ -4134,7 +3964,7 @@ size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, cctxParams.cParams = params.cParams; cctxParams.fParams = params.fParams; cctxParams.compressionLevel = ZSTD_CLEVEL_CUSTOM; - return ZSTD_initCStream_internal_opaque(zcs, dict, dictSize, NULL, cctxParams, pledgedSrcSize); + return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, pledgedSrcSize); } size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel) @@ -4144,7 +3974,7 @@ size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t di cctxParams.cParams = params.cParams; cctxParams.fParams = params.fParams; cctxParams.compressionLevel = compressionLevel; - return ZSTD_initCStream_internal_opaque(zcs, dict, dictSize, NULL, cctxParams, 0); + return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, 0); } size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize) @@ -4363,7 +4193,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx, } else #endif { - CHECK_F( ZSTD_resetCStream_internal_opaque(cctx, prefix, prefixSize, cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) ); + CHECK_F( ZSTD_resetCStream_internal(cctx, prefix, prefixSize, cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) ); } } /* compression stage */ diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c index cf362a75..ebedec90 100644 --- a/lib/compress/zstdmt_compress.c +++ b/lib/compress/zstdmt_compress.c @@ -186,12 +186,12 @@ static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf) ZSTD_free(buf.start, bufPool->cMem); } -/* TODO: Set relevant job parameters, initialize others to default. - * Notably, nbThreads should be zero. */ +/* Sets parameterse relevant to the compression job, initializing others to + * default values. Notably, nbThreads should probably be zero. */ static ZSTD_CCtx_params ZSTDMT_makeJobCCtxParams(ZSTD_CCtx_params const params) { ZSTD_CCtx_params jobParams; - memset(&jobParams, 0, sizeof(jobParams)); + memset(&jobParams, 0, sizeof(ZSTD_CCtx_params)); jobParams.cParams = params.cParams; jobParams.fParams = params.fParams; @@ -725,9 +725,9 @@ size_t ZSTDMT_initCStream_internal_opaque( if (zcs->nbThreads==1) { DEBUGLOG(4, "single thread mode"); - return ZSTD_initCStream_internal_opaque(zcs->cctxPool->cctx[0], - dict, dictSize, cdict, - requestedParams, pledgedSrcSize); + return ZSTD_initCStream_internal(zcs->cctxPool->cctx[0], + dict, dictSize, cdict, + requestedParams, pledgedSrcSize); } if (zcs->allJobsCompleted == 0) { /* previous compression not correctly finished */ diff --git a/tests/cctxParamRoundTrip.c b/tests/cctxParamRoundTrip.c index 906ad9ce..5ce47d4d 100644 --- a/tests/cctxParamRoundTrip.c +++ b/tests/cctxParamRoundTrip.c @@ -70,6 +70,8 @@ static size_t roundTripTest(void* resultBuff, size_t resultBuffCapacity, ZSTD_outBuffer outBuffer = {compressedBuff, compressedBuffCapacity, 0 }; CHECK_Z( ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_p_compressionLevel, 1) ); + CHECK_Z (ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_p_nbThreads, 3) ); + CHECK_Z (ZSTD_CCtxParam_setParameter(cctxParams, ZSTD_p_compressionStrategy, ZSTD_lazy) ); CHECK_Z( ZSTD_CCtx_applyCCtxParams(cctx, cctxParams) ); CHECK_Z (ZSTD_compress_generic(cctx, &outBuffer, &inBuffer, ZSTD_e_end) );