facebook/zstd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename ZSTD_{malloc,calloc,free} to ZSTD_custom{Malloc,Calloc,Free}

Browse Source
This commit is contained in:
Nick Terrell 2020-08-10 12:42:03 -07:00
parent 80f577baa2
commit a686d306d2
9 changed files with 67 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/common/pool.c
View File

@ -12,7 +12,7 @@
/* ====== Dependencies ======= */ /* ====== Dependencies ======= */
#include "zstd_deps.h" /* size_t */ #include "zstd_deps.h" /* size_t */
#include "debug.h" /* assert */ #include "debug.h" /* assert */
#include "zstd_internal.h" /* ZSTD_malloc, ZSTD_free */ #include "zstd_internal.h" /* ZSTD_customMalloc, ZSTD_customFree */
#include "pool.h" #include "pool.h"
/* ====== Compiler specifics ====== */ /* ====== Compiler specifics ====== */
@ -115,14 +115,14 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
/* Check parameters */ /* Check parameters */
if (!numThreads) { return NULL; } if (!numThreads) { return NULL; }
/* Allocate the context and zero initialize */ /* Allocate the context and zero initialize */
ctx = (POOL_ctx*)ZSTD_calloc(sizeof(POOL_ctx), customMem); ctx = (POOL_ctx*)ZSTD_customCalloc(sizeof(POOL_ctx), customMem);
if (!ctx) { return NULL; } if (!ctx) { return NULL; }
/* Initialize the job queue. /* Initialize the job queue.
* It needs one extra space since one space is wasted to differentiate * It needs one extra space since one space is wasted to differentiate
* empty and full queues. * empty and full queues.
*/ */
ctx->queueSize = queueSize + 1; ctx->queueSize = queueSize + 1;
ctx->queue = (POOL_job*)ZSTD_malloc(ctx->queueSize * sizeof(POOL_job), customMem); ctx->queue = (POOL_job*)ZSTD_customMalloc(ctx->queueSize * sizeof(POOL_job), customMem);
ctx->queueHead = 0; ctx->queueHead = 0;
ctx->queueTail = 0; ctx->queueTail = 0;
ctx->numThreadsBusy = 0; ctx->numThreadsBusy = 0;
@ -136,7 +136,7 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
} }
ctx->shutdown = 0; ctx->shutdown = 0;
/* Allocate space for the thread handles */ /* Allocate space for the thread handles */
ctx->threads = (ZSTD_pthread_t*)ZSTD_malloc(numThreads * sizeof(ZSTD_pthread_t), customMem); ctx->threads = (ZSTD_pthread_t*)ZSTD_customMalloc(numThreads * sizeof(ZSTD_pthread_t), customMem);
ctx->threadCapacity = 0; ctx->threadCapacity = 0;
ctx->customMem = customMem; ctx->customMem = customMem;
/* Check for errors */ /* Check for errors */
@ -179,9 +179,9 @@ void POOL_free(POOL_ctx *ctx) {
ZSTD_pthread_mutex_destroy(&ctx->queueMutex); ZSTD_pthread_mutex_destroy(&ctx->queueMutex);
ZSTD_pthread_cond_destroy(&ctx->queuePushCond); ZSTD_pthread_cond_destroy(&ctx->queuePushCond);
ZSTD_pthread_cond_destroy(&ctx->queuePopCond); ZSTD_pthread_cond_destroy(&ctx->queuePopCond);
ZSTD_free(ctx->queue, ctx->customMem); ZSTD_customFree(ctx->queue, ctx->customMem);
ZSTD_free(ctx->threads, ctx->customMem); ZSTD_customFree(ctx->threads, ctx->customMem);
ZSTD_free(ctx, ctx->customMem); ZSTD_customFree(ctx, ctx->customMem);
} }
@ -203,11 +203,11 @@ static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
return 0; return 0;
} }
/* numThreads > threadCapacity */ /* numThreads > threadCapacity */
{ ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_malloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem); { ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_customMalloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);
if (!threadPool) return 1; if (!threadPool) return 1;
/* replace existing thread pool */ /* replace existing thread pool */
memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(*threadPool)); memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(*threadPool));
ZSTD_free(ctx->threads, ctx->customMem); ZSTD_customFree(ctx->threads, ctx->customMem);
ctx->threads = threadPool; ctx->threads = threadPool;
/* Initialize additional threads */ /* Initialize additional threads */
{ size_t threadId; { size_t threadId;

6
lib/common/zstd_common.c
View File

@ -53,14 +53,14 @@ const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString
/*=************************************************************** /*=**************************************************************
* Custom allocator * Custom allocator
****************************************************************/ ****************************************************************/
void* ZSTD_malloc(size_t size, ZSTD_customMem customMem) void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem)
{ {
if (customMem.customAlloc) if (customMem.customAlloc)
return customMem.customAlloc(customMem.opaque, size); return customMem.customAlloc(customMem.opaque, size);
return malloc(size); return malloc(size);
} }
void* ZSTD_calloc(size_t size, ZSTD_customMem customMem) void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)
{ {
if (customMem.customAlloc) { if (customMem.customAlloc) {
/* calloc implemented as malloc+memset; /* calloc implemented as malloc+memset;
@ -72,7 +72,7 @@ void* ZSTD_calloc(size_t size, ZSTD_customMem customMem)
return calloc(1, size); return calloc(1, size);
} }
void ZSTD_free(void* ptr, ZSTD_customMem customMem) void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)
{ {
if (ptr!=NULL) { if (ptr!=NULL) {
if (customMem.customFree) if (customMem.customFree)

6
lib/common/zstd_internal.h
View File

@ -386,9 +386,9 @@ const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx); /* compress & dictBu
void ZSTD_seqToCodes(const seqStore_t* seqStorePtr); /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */ void ZSTD_seqToCodes(const seqStore_t* seqStorePtr); /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
/* custom memory allocation functions */ /* custom memory allocation functions */
void* ZSTD_malloc(size_t size, ZSTD_customMem customMem); void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem);
void* ZSTD_calloc(size_t size, ZSTD_customMem customMem); void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem);
void ZSTD_free(void* ptr, ZSTD_customMem customMem); void ZSTD_customFree(void* ptr, ZSTD_customMem customMem);
MEM_STATIC U32 ZSTD_highbit32(U32 val) /* compress, dictBuilder, decodeCorpus */ MEM_STATIC U32 ZSTD_highbit32(U32 val) /* compress, dictBuilder, decodeCorpus */

22
lib/compress/zstd_compress.c
View File

@ -82,7 +82,7 @@ ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
ZSTD_STATIC_ASSERT(zcss_init==0); ZSTD_STATIC_ASSERT(zcss_init==0);
ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1)); ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
if (!customMem.customAlloc ^ !customMem.customFree) return NULL; if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
{ ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_malloc(sizeof(ZSTD_CCtx), customMem); { ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_customMalloc(sizeof(ZSTD_CCtx), customMem);
if (!cctx) return NULL; if (!cctx) return NULL;
ZSTD_initCCtx(cctx, customMem); ZSTD_initCCtx(cctx, customMem);
return cctx; return cctx;
@ -118,7 +118,7 @@ ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)
*/ */
static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx) static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
{ {
ZSTD_free(cctx->localDict.dictBuffer, cctx->customMem); ZSTD_customFree(cctx->localDict.dictBuffer, cctx->customMem);
ZSTD_freeCDict(cctx->localDict.cdict); ZSTD_freeCDict(cctx->localDict.cdict);
memset(&cctx->localDict, 0, sizeof(cctx->localDict)); memset(&cctx->localDict, 0, sizeof(cctx->localDict));
memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict)); memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
@ -152,7 +152,7 @@ size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx); int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx);
ZSTD_freeCCtxContent(cctx); ZSTD_freeCCtxContent(cctx);
if (!cctxInWorkspace) { if (!cctxInWorkspace) {
ZSTD_free(cctx, cctx->customMem); ZSTD_customFree(cctx, cctx->customMem);
} }
} }
return 0; return 0;
@ -205,7 +205,7 @@ static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(
{ {
ZSTD_CCtx_params* params; ZSTD_CCtx_params* params;
if (!customMem.customAlloc ^ !customMem.customFree) return NULL; if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
params = (ZSTD_CCtx_params*)ZSTD_calloc( params = (ZSTD_CCtx_params*)ZSTD_customCalloc(
sizeof(ZSTD_CCtx_params), customMem); sizeof(ZSTD_CCtx_params), customMem);
if (!params) { return NULL; } if (!params) { return NULL; }
params->customMem = customMem; params->customMem = customMem;
@ -222,7 +222,7 @@ ZSTD_CCtx_params* ZSTD_createCCtxParams(void)
size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params) size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params)
{ {
if (params == NULL) { return 0; } if (params == NULL) { return 0; }
ZSTD_free(params, params->customMem); ZSTD_customFree(params, params->customMem);
return 0; return 0;
} }
@ -902,7 +902,7 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
if (dictLoadMethod == ZSTD_dlm_byRef) { if (dictLoadMethod == ZSTD_dlm_byRef) {
cctx->localDict.dict = dict; cctx->localDict.dict = dict;
} else { } else {
void* dictBuffer = ZSTD_malloc(dictSize, cctx->customMem); void* dictBuffer = ZSTD_customMalloc(dictSize, cctx->customMem);
RETURN_ERROR_IF(!dictBuffer, memory_allocation, "NULL pointer!"); RETURN_ERROR_IF(!dictBuffer, memory_allocation, "NULL pointer!");
memcpy(dictBuffer, dict, dictSize); memcpy(dictBuffer, dict, dictSize);
cctx->localDict.dictBuffer = dictBuffer; cctx->localDict.dictBuffer = dictBuffer;
@ -2369,7 +2369,7 @@ size_t ZSTD_getSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,
size_t outSeqsSize, const void* src, size_t srcSize) size_t outSeqsSize, const void* src, size_t srcSize)
{ {
const size_t dstCapacity = ZSTD_compressBound(srcSize); const size_t dstCapacity = ZSTD_compressBound(srcSize);
void* dst = ZSTD_malloc(dstCapacity, ZSTD_defaultCMem); void* dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem);
SeqCollector seqCollector; SeqCollector seqCollector;
RETURN_ERROR_IF(dst == NULL, memory_allocation, "NULL pointer!"); RETURN_ERROR_IF(dst == NULL, memory_allocation, "NULL pointer!");
@ -2381,7 +2381,7 @@ size_t ZSTD_getSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,
zc->seqCollector = seqCollector; zc->seqCollector = seqCollector;
ZSTD_compress2(zc, dst, dstCapacity, src, srcSize); ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);
ZSTD_free(dst, ZSTD_defaultCMem); ZSTD_customFree(dst, ZSTD_defaultCMem);
return zc->seqCollector.seqIndex; return zc->seqCollector.seqIndex;
} }
@ -3420,12 +3420,12 @@ ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0) + ZSTD_sizeof_matchState(&cParams, /* forCCtx */ 0) +
(dictLoadMethod == ZSTD_dlm_byRef ? 0 (dictLoadMethod == ZSTD_dlm_byRef ? 0
: ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*)))); : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))));
void* const workspace = ZSTD_malloc(workspaceSize, customMem); void* const workspace = ZSTD_customMalloc(workspaceSize, customMem);
ZSTD_cwksp ws; ZSTD_cwksp ws;
ZSTD_CDict* cdict; ZSTD_CDict* cdict;
if (!workspace) { if (!workspace) {
ZSTD_free(workspace, customMem); ZSTD_customFree(workspace, customMem);
return NULL; return NULL;
} }
@ -3475,7 +3475,7 @@ size_t ZSTD_freeCDict(ZSTD_CDict* cdict)
int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict); int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict);
ZSTD_cwksp_free(&cdict->workspace, cMem); ZSTD_cwksp_free(&cdict->workspace, cMem);
if (!cdictInWorkspace) { if (!cdictInWorkspace) {
ZSTD_free(cdict, cMem); ZSTD_customFree(cdict, cMem);
} }
return 0; return 0;
} }

6
lib/compress/zstd_cwksp.h
View File

@ -92,7 +92,7 @@ typedef enum {
* *
* - Static objects: this is optionally the enclosing ZSTD_CCtx or ZSTD_CDict, * - Static objects: this is optionally the enclosing ZSTD_CCtx or ZSTD_CDict,
* so that literally everything fits in a single buffer. Note: if present, * so that literally everything fits in a single buffer. Note: if present,
* this must be the first object in the workspace, since ZSTD_free{CCtx, * this must be the first object in the workspace, since ZSTD_customFree{CCtx,
* CDict}() rely on a pointer comparison to see whether one or two frees are * CDict}() rely on a pointer comparison to see whether one or two frees are
* required. * required.
* *
@ -456,7 +456,7 @@ MEM_STATIC void ZSTD_cwksp_init(ZSTD_cwksp* ws, void* start, size_t size) {
} }
MEM_STATIC size_t ZSTD_cwksp_create(ZSTD_cwksp* ws, size_t size, ZSTD_customMem customMem) { MEM_STATIC size_t ZSTD_cwksp_create(ZSTD_cwksp* ws, size_t size, ZSTD_customMem customMem) {
void* workspace = ZSTD_malloc(size, customMem); void* workspace = ZSTD_customMalloc(size, customMem);
DEBUGLOG(4, "cwksp: creating new workspace with %zd bytes", size); DEBUGLOG(4, "cwksp: creating new workspace with %zd bytes", size);
RETURN_ERROR_IF(workspace == NULL, memory_allocation, "NULL pointer!"); RETURN_ERROR_IF(workspace == NULL, memory_allocation, "NULL pointer!");
ZSTD_cwksp_init(ws, workspace, size); ZSTD_cwksp_init(ws, workspace, size);
@ -467,7 +467,7 @@ MEM_STATIC void ZSTD_cwksp_free(ZSTD_cwksp* ws, ZSTD_customMem customMem) {
void *ptr = ws->workspace; void *ptr = ws->workspace;
DEBUGLOG(4, "cwksp: freeing workspace"); DEBUGLOG(4, "cwksp: freeing workspace");
memset(ws, 0, sizeof(ZSTD_cwksp)); memset(ws, 0, sizeof(ZSTD_cwksp));
ZSTD_free(ptr, customMem); ZSTD_customFree(ptr, customMem);
} }
/** /**

48
lib/compress/zstdmt_compress.c
View File

@ -105,11 +105,11 @@ typedef struct ZSTDMT_bufferPool_s {
static ZSTDMT_bufferPool* ZSTDMT_createBufferPool(unsigned nbWorkers, ZSTD_customMem cMem) static ZSTDMT_bufferPool* ZSTDMT_createBufferPool(unsigned nbWorkers, ZSTD_customMem cMem)
{ {
unsigned const maxNbBuffers = 2*nbWorkers + 3; unsigned const maxNbBuffers = 2*nbWorkers + 3;
ZSTDMT_bufferPool* const bufPool = (ZSTDMT_bufferPool*)ZSTD_calloc( ZSTDMT_bufferPool* const bufPool = (ZSTDMT_bufferPool*)ZSTD_customCalloc(
sizeof(ZSTDMT_bufferPool) + (maxNbBuffers-1) * sizeof(buffer_t), cMem); sizeof(ZSTDMT_bufferPool) + (maxNbBuffers-1) * sizeof(buffer_t), cMem);
if (bufPool==NULL) return NULL; if (bufPool==NULL) return NULL;
if (ZSTD_pthread_mutex_init(&bufPool->poolMutex, NULL)) { if (ZSTD_pthread_mutex_init(&bufPool->poolMutex, NULL)) {
ZSTD_free(bufPool, cMem); ZSTD_customFree(bufPool, cMem);
return NULL; return NULL;
} }
bufPool->bufferSize = 64 KB; bufPool->bufferSize = 64 KB;
@ -126,10 +126,10 @@ static void ZSTDMT_freeBufferPool(ZSTDMT_bufferPool* bufPool)
if (!bufPool) return; /* compatibility with free on NULL */ if (!bufPool) return; /* compatibility with free on NULL */
for (u=0; u<bufPool->totalBuffers; u++) { for (u=0; u<bufPool->totalBuffers; u++) {
DEBUGLOG(4, "free buffer %2u (address:%08X)", u, (U32)(size_t)bufPool->bTable[u].start); DEBUGLOG(4, "free buffer %2u (address:%08X)", u, (U32)(size_t)bufPool->bTable[u].start);
ZSTD_free(bufPool->bTable[u].start, bufPool->cMem); ZSTD_customFree(bufPool->bTable[u].start, bufPool->cMem);
} }
ZSTD_pthread_mutex_destroy(&bufPool->poolMutex); ZSTD_pthread_mutex_destroy(&bufPool->poolMutex);
ZSTD_free(bufPool, bufPool->cMem); ZSTD_customFree(bufPool, bufPool->cMem);
} }
/* only works at initialization, not during compression */ /* only works at initialization, not during compression */
@ -200,13 +200,13 @@ static buffer_t ZSTDMT_getBuffer(ZSTDMT_bufferPool* bufPool)
} }
/* size conditions not respected : scratch this buffer, create new one */ /* size conditions not respected : scratch this buffer, create new one */
DEBUGLOG(5, "ZSTDMT_getBuffer: existing buffer does not meet size conditions => freeing"); DEBUGLOG(5, "ZSTDMT_getBuffer: existing buffer does not meet size conditions => freeing");
ZSTD_free(buf.start, bufPool->cMem); ZSTD_customFree(buf.start, bufPool->cMem);
} }
ZSTD_pthread_mutex_unlock(&bufPool->poolMutex); ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
/* create new buffer */ /* create new buffer */
DEBUGLOG(5, "ZSTDMT_getBuffer: create a new buffer"); DEBUGLOG(5, "ZSTDMT_getBuffer: create a new buffer");
{ buffer_t buffer; { buffer_t buffer;
void* const start = ZSTD_malloc(bSize, bufPool->cMem); void* const start = ZSTD_customMalloc(bSize, bufPool->cMem);
buffer.start = start; /* note : start can be NULL if malloc fails ! */ buffer.start = start; /* note : start can be NULL if malloc fails ! */
buffer.capacity = (start==NULL) ? 0 : bSize; buffer.capacity = (start==NULL) ? 0 : bSize;
if (start==NULL) { if (start==NULL) {
@ -228,7 +228,7 @@ static buffer_t ZSTDMT_resizeBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buffer)
{ {
size_t const bSize = bufPool->bufferSize; size_t const bSize = bufPool->bufferSize;
if (buffer.capacity < bSize) { if (buffer.capacity < bSize) {
void* const start = ZSTD_malloc(bSize, bufPool->cMem); void* const start = ZSTD_customMalloc(bSize, bufPool->cMem);
buffer_t newBuffer; buffer_t newBuffer;
newBuffer.start = start; newBuffer.start = start;
newBuffer.capacity = start == NULL ? 0 : bSize; newBuffer.capacity = start == NULL ? 0 : bSize;
@ -260,7 +260,7 @@ static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf)
ZSTD_pthread_mutex_unlock(&bufPool->poolMutex); ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
/* Reached bufferPool capacity (should not happen) */ /* Reached bufferPool capacity (should not happen) */
DEBUGLOG(5, "ZSTDMT_releaseBuffer: pool capacity reached => freeing "); DEBUGLOG(5, "ZSTDMT_releaseBuffer: pool capacity reached => freeing ");
ZSTD_free(buf.start, bufPool->cMem); ZSTD_customFree(buf.start, bufPool->cMem);
} }
@ -353,7 +353,7 @@ static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
for (cid=0; cid<pool->totalCCtx; cid++) for (cid=0; cid<pool->totalCCtx; cid++)
ZSTD_freeCCtx(pool->cctx[cid]); /* note : compatible with free on NULL */ ZSTD_freeCCtx(pool->cctx[cid]); /* note : compatible with free on NULL */
ZSTD_pthread_mutex_destroy(&pool->poolMutex); ZSTD_pthread_mutex_destroy(&pool->poolMutex);
ZSTD_free(pool, pool->cMem); ZSTD_customFree(pool, pool->cMem);
} }
/* ZSTDMT_createCCtxPool() : /* ZSTDMT_createCCtxPool() :
@ -361,12 +361,12 @@ static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers, static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,
ZSTD_customMem cMem) ZSTD_customMem cMem)
{ {
ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_calloc( ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_customCalloc(
sizeof(ZSTDMT_CCtxPool) + (nbWorkers-1)*sizeof(ZSTD_CCtx*), cMem); sizeof(ZSTDMT_CCtxPool) + (nbWorkers-1)*sizeof(ZSTD_CCtx*), cMem);
assert(nbWorkers > 0); assert(nbWorkers > 0);
if (!cctxPool) return NULL; if (!cctxPool) return NULL;
if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) { if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) {
ZSTD_free(cctxPool, cMem); ZSTD_customFree(cctxPool, cMem);
return NULL; return NULL;
} }
cctxPool->cMem = cMem; cctxPool->cMem = cMem;
@ -498,12 +498,12 @@ ZSTDMT_serialState_reset(serialState_t* serialState,
ZSTD_window_init(&serialState->ldmState.window); ZSTD_window_init(&serialState->ldmState.window);
/* Resize tables and output space if necessary. */ /* Resize tables and output space if necessary. */
if (serialState->ldmState.hashTable == NULL || serialState->params.ldmParams.hashLog < hashLog) { if (serialState->ldmState.hashTable == NULL || serialState->params.ldmParams.hashLog < hashLog) {
ZSTD_free(serialState->ldmState.hashTable, cMem); ZSTD_customFree(serialState->ldmState.hashTable, cMem);
serialState->ldmState.hashTable = (ldmEntry_t*)ZSTD_malloc(hashSize, cMem); serialState->ldmState.hashTable = (ldmEntry_t*)ZSTD_customMalloc(hashSize, cMem);
} }
if (serialState->ldmState.bucketOffsets == NULL || prevBucketLog < bucketLog) { if (serialState->ldmState.bucketOffsets == NULL || prevBucketLog < bucketLog) {
ZSTD_free(serialState->ldmState.bucketOffsets, cMem); ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem);
serialState->ldmState.bucketOffsets = (BYTE*)ZSTD_malloc(bucketSize, cMem); serialState->ldmState.bucketOffsets = (BYTE*)ZSTD_customMalloc(bucketSize, cMem);
} }
if (!serialState->ldmState.hashTable || !serialState->ldmState.bucketOffsets) if (!serialState->ldmState.hashTable || !serialState->ldmState.bucketOffsets)
return 1; return 1;
@ -551,8 +551,8 @@ static void ZSTDMT_serialState_free(serialState_t* serialState)
ZSTD_pthread_cond_destroy(&serialState->cond); ZSTD_pthread_cond_destroy(&serialState->cond);
ZSTD_pthread_mutex_destroy(&serialState->ldmWindowMutex); ZSTD_pthread_mutex_destroy(&serialState->ldmWindowMutex);
ZSTD_pthread_cond_destroy(&serialState->ldmWindowCond); ZSTD_pthread_cond_destroy(&serialState->ldmWindowCond);
ZSTD_free(serialState->ldmState.hashTable, cMem); ZSTD_customFree(serialState->ldmState.hashTable, cMem);
ZSTD_free(serialState->ldmState.bucketOffsets, cMem); ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem);
} }
static void ZSTDMT_serialState_update(serialState_t* serialState, static void ZSTDMT_serialState_update(serialState_t* serialState,
@ -841,7 +841,7 @@ static void ZSTDMT_freeJobsTable(ZSTDMT_jobDescription* jobTable, U32 nbJobs, ZS
ZSTD_pthread_mutex_destroy(&jobTable[jobNb].job_mutex); ZSTD_pthread_mutex_destroy(&jobTable[jobNb].job_mutex);
ZSTD_pthread_cond_destroy(&jobTable[jobNb].job_cond); ZSTD_pthread_cond_destroy(&jobTable[jobNb].job_cond);
} }
ZSTD_free(jobTable, cMem); ZSTD_customFree(jobTable, cMem);
} }
/* ZSTDMT_allocJobsTable() /* ZSTDMT_allocJobsTable()
@ -853,7 +853,7 @@ static ZSTDMT_jobDescription* ZSTDMT_createJobsTable(U32* nbJobsPtr, ZSTD_custom
U32 const nbJobs = 1 << nbJobsLog2; U32 const nbJobs = 1 << nbJobsLog2;
U32 jobNb; U32 jobNb;
ZSTDMT_jobDescription* const jobTable = (ZSTDMT_jobDescription*) ZSTDMT_jobDescription* const jobTable = (ZSTDMT_jobDescription*)
ZSTD_calloc(nbJobs * sizeof(ZSTDMT_jobDescription), cMem); ZSTD_customCalloc(nbJobs * sizeof(ZSTDMT_jobDescription), cMem);
int initError = 0; int initError = 0;
if (jobTable==NULL) return NULL; if (jobTable==NULL) return NULL;
*nbJobsPtr = nbJobs; *nbJobsPtr = nbJobs;
@ -902,7 +902,7 @@ MEM_STATIC ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced_internal(unsigned nbWorkers,
/* invalid custom allocator */ /* invalid custom allocator */
return NULL; return NULL;
mtctx = (ZSTDMT_CCtx*) ZSTD_calloc(sizeof(ZSTDMT_CCtx), cMem); mtctx = (ZSTDMT_CCtx*) ZSTD_customCalloc(sizeof(ZSTDMT_CCtx), cMem);
if (!mtctx) return NULL; if (!mtctx) return NULL;
ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers); ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);
mtctx->cMem = cMem; mtctx->cMem = cMem;
@ -992,8 +992,8 @@ size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx)
ZSTDMT_serialState_free(&mtctx->serial); ZSTDMT_serialState_free(&mtctx->serial);
ZSTD_freeCDict(mtctx->cdictLocal); ZSTD_freeCDict(mtctx->cdictLocal);
if (mtctx->roundBuff.buffer) if (mtctx->roundBuff.buffer)
ZSTD_free(mtctx->roundBuff.buffer, mtctx->cMem); ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem);
ZSTD_free(mtctx, mtctx->cMem); ZSTD_customFree(mtctx, mtctx->cMem);
return 0; return 0;
} }
@ -1503,8 +1503,8 @@ size_t ZSTDMT_initCStream_internal(
size_t const capacity = MAX(windowSize, sectionsSize) + slackSize; size_t const capacity = MAX(windowSize, sectionsSize) + slackSize;
if (mtctx->roundBuff.capacity < capacity) { if (mtctx->roundBuff.capacity < capacity) {
if (mtctx->roundBuff.buffer) if (mtctx->roundBuff.buffer)
ZSTD_free(mtctx->roundBuff.buffer, mtctx->cMem); ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem);
mtctx->roundBuff.buffer = (BYTE*)ZSTD_malloc(capacity, mtctx->cMem); mtctx->roundBuff.buffer = (BYTE*)ZSTD_customMalloc(capacity, mtctx->cMem);
if (mtctx->roundBuff.buffer == NULL) { if (mtctx->roundBuff.buffer == NULL) {
mtctx->roundBuff.capacity = 0; mtctx->roundBuff.capacity = 0;
return ERROR(memory_allocation); return ERROR(memory_allocation);

8
lib/decompress/zstd_ddict.c
View File

@ -127,7 +127,7 @@ static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
ddict->dictContent = dict; ddict->dictContent = dict;
if (!dict) dictSize = 0; if (!dict) dictSize = 0;
} else { } else {
void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem); void* const internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem);
ddict->dictBuffer = internalBuffer; ddict->dictBuffer = internalBuffer;
ddict->dictContent = internalBuffer; ddict->dictContent = internalBuffer;
if (!internalBuffer) return ERROR(memory_allocation); if (!internalBuffer) return ERROR(memory_allocation);
@ -149,7 +149,7 @@ ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
{ {
if (!customMem.customAlloc ^ !customMem.customFree) return NULL; if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
{ ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(sizeof(ZSTD_DDict), customMem); { ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_customMalloc(sizeof(ZSTD_DDict), customMem);
if (ddict == NULL) return NULL; if (ddict == NULL) return NULL;
ddict->cMem = customMem; ddict->cMem = customMem;
{ size_t const initResult = ZSTD_initDDict_internal(ddict, { size_t const initResult = ZSTD_initDDict_internal(ddict,
@ -213,8 +213,8 @@ size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
{ {
if (ddict==NULL) return 0; /* support free on NULL */ if (ddict==NULL) return 0; /* support free on NULL */
{ ZSTD_customMem const cMem = ddict->cMem; { ZSTD_customMem const cMem = ddict->cMem;
ZSTD_free(ddict->dictBuffer, cMem); ZSTD_customFree(ddict->dictBuffer, cMem);
ZSTD_free(ddict, cMem); ZSTD_customFree(ddict, cMem);
return 0; return 0;
} }
} }

10
lib/decompress/zstd_decompress.c
View File

@ -138,7 +138,7 @@ ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
{ {
if (!customMem.customAlloc ^ !customMem.customFree) return NULL; if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
{ ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_malloc(sizeof(*dctx), customMem); { ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem);
if (!dctx) return NULL; if (!dctx) return NULL;
dctx->customMem = customMem; dctx->customMem = customMem;
ZSTD_initDCtx_internal(dctx); ZSTD_initDCtx_internal(dctx);
@ -166,13 +166,13 @@ size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx"); RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
{ ZSTD_customMem const cMem = dctx->customMem; { ZSTD_customMem const cMem = dctx->customMem;
ZSTD_clearDict(dctx); ZSTD_clearDict(dctx);
ZSTD_free(dctx->inBuff, cMem); ZSTD_customFree(dctx->inBuff, cMem);
dctx->inBuff = NULL; dctx->inBuff = NULL;
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
if (dctx->legacyContext) if (dctx->legacyContext)
ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion); ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);
#endif #endif
ZSTD_free(dctx, cMem); ZSTD_customFree(dctx, cMem);
return 0; return 0;
} }
} }
@ -1767,10 +1767,10 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
bufferSize > zds->staticSize - sizeof(ZSTD_DCtx), bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
memory_allocation, ""); memory_allocation, "");
} else { } else {
ZSTD_free(zds->inBuff, zds->customMem); ZSTD_customFree(zds->inBuff, zds->customMem);
zds->inBuffSize = 0; zds->inBuffSize = 0;
zds->outBuffSize = 0; zds->outBuffSize = 0;
zds->inBuff = (char*)ZSTD_malloc(bufferSize, zds->customMem); zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem);
RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, ""); RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
} }
zds->inBuffSize = neededInBuffSize; zds->inBuffSize = neededInBuffSize;

10
zlibWrapper/zstd_zlibwrapper.c
View File

@ -25,7 +25,7 @@
#include "zstd_zlibwrapper.h" #include "zstd_zlibwrapper.h"
#define ZSTD_STATIC_LINKING_ONLY /* ZSTD_isFrame, ZSTD_MAGICNUMBER */ #define ZSTD_STATIC_LINKING_ONLY /* ZSTD_isFrame, ZSTD_MAGICNUMBER */
#include "zstd.h" #include "zstd.h"
#include "zstd_internal.h" /* ZSTD_malloc, ZSTD_free */ #include "zstd_internal.h" /* ZSTD_customMalloc, ZSTD_customFree */
/* === Constants === */ /* === Constants === */
@ -107,7 +107,7 @@ static size_t ZWRAP_freeCCtx(ZWRAP_CCtx* zwc)
{ {
if (zwc==NULL) return 0; /* support free on NULL */ if (zwc==NULL) return 0; /* support free on NULL */
ZSTD_freeCStream(zwc->zbc); ZSTD_freeCStream(zwc->zbc);
ZSTD_free(zwc, zwc->customMem); ZSTD_customFree(zwc, zwc->customMem);
return 0; return 0;
} }
@ -481,8 +481,8 @@ static size_t ZWRAP_freeDCtx(ZWRAP_DCtx* zwd)
{ {
if (zwd==NULL) return 0; /* support free on null */ if (zwd==NULL) return 0; /* support free on null */
ZSTD_freeDStream(zwd->zbd); ZSTD_freeDStream(zwd->zbd);
ZSTD_free(zwd->version, zwd->customMem); ZSTD_customFree(zwd->version, zwd->customMem);
ZSTD_free(zwd, zwd->customMem); ZSTD_customFree(zwd, zwd->customMem);
return 0; return 0;
} }
@ -524,7 +524,7 @@ ZEXTERN int ZEXPORT z_inflateInit_ OF((z_streamp strm,
LOG_WRAPPERD("- inflateInit\n"); LOG_WRAPPERD("- inflateInit\n");
if (zwd == NULL) return ZWRAPD_finishWithError(zwd, strm, 0); if (zwd == NULL) return ZWRAPD_finishWithError(zwd, strm, 0);
zwd->version = (char*)ZSTD_malloc(strlen(version)+1, zwd->customMem); zwd->version = (char*)ZSTD_customMalloc(strlen(version)+1, zwd->customMem);
if (zwd->version == NULL) return ZWRAPD_finishWithError(zwd, strm, 0); if (zwd->version == NULL) return ZWRAPD_finishWithError(zwd, strm, 0);
strcpy(zwd->version, version); strcpy(zwd->version, version);