Renaming / Style fixes

diff --git a/programs/bench.c b/programs/bench.c
index 177dbe0e3a14bfbae608c95472d3030694b6b92f..b496caf27769e2656963219e23472fa2bb60e500 100644 (file)
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -294,7 +294,7 @@ BMK_customReturn_t BMK_benchFunction(
     BMK_initFn_t initFn, void* initPayload,
     size_t blockCount,
     const void* const * const srcBlockBuffers, const size_t* srcBlockSizes,
-    void* const * const dstBlockBuffers, const size_t* dstBlockCapacities, size_t* cSizes, 
+    void* const * const dstBlockBuffers, const size_t* dstBlockCapacities, size_t* blockResult, 
     unsigned nbLoops) {
     size_t dstSize = 0;
     U64 totalTime;
@@ -332,8 +332,8 @@ BMK_customReturn_t BMK_benchFunction(
                         j, (U32)dstBlockCapacities[j], ZSTD_getErrorName(res));
                 } else if(i == nbLoops - 1) {
                     dstSize += res;
-                    if(cSizes != NULL) {
-                        cSizes[j] = res;
+                    if(blockResult != NULL) {
+                        blockResult[j] = res;
                     }
                 } 
             }
@@ -358,6 +358,9 @@ void BMK_resetTimeState(BMK_timedFnState_t* r, unsigned nbSeconds) {
 
 BMK_timedFnState_t* BMK_createTimeState(unsigned nbSeconds) {
     BMK_timedFnState_t* r = (BMK_timedFnState_t*)malloc(sizeof(struct BMK_timeState_t));
+    if(r == NULL) {
+        return r;
+    }
     BMK_resetTimeState(r, nbSeconds);
     return r;
 }
@@ -373,7 +376,7 @@ BMK_customTimedReturn_t BMK_benchFunctionTimed(
     BMK_initFn_t initFn, void* initPayload,
     size_t blockCount,
     const void* const* const srcBlockBuffers, const size_t* srcBlockSizes,
-    void * const * const dstBlockBuffers, const size_t * dstBlockCapacities, size_t* dstSizes) 
+    void * const * const dstBlockBuffers, const size_t * dstBlockCapacities, size_t* blockResults) 
 {
     U64 fastest = cont->fastestTime;
     int completed = 0;
@@ -390,7 +393,7 @@ BMK_customTimedReturn_t BMK_benchFunctionTimed(
         }
         /* reinitialize capacity */
         r.result = BMK_benchFunction(benchFn, benchPayload, initFn, initPayload,
-        blockCount, srcBlockBuffers, srcBlockSizes, dstBlockBuffers, dstBlockCapacities, dstSizes, cont->nbLoops);
+        blockCount, srcBlockBuffers, srcBlockSizes, dstBlockBuffers, dstBlockCapacities, blockResults, cont->nbLoops);
         if(r.result.error) { /* completed w/ error */
             r.completed = 1;
             return r;
@@ -718,38 +721,36 @@ BMK_return_t BMK_benchMemAdvanced(const void* srcBuffer, size_t srcSize,
     U32 const maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;
 
     /* these are the blockTable parameters, just split up */
-    const void ** const srcPtrs = (const void** const)malloc(maxNbBlocks * sizeof(void*));
-    size_t* const srcSizes = (size_t* const)malloc(maxNbBlocks * sizeof(size_t));
+    const void ** const srcPtrs = (const void**)malloc(maxNbBlocks * sizeof(void*));
+    size_t* const srcSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
 
 
-    void ** const cPtrs = (void** const)malloc(maxNbBlocks * sizeof(void*));
-    size_t* const cSizes = (size_t* const)malloc(maxNbBlocks * sizeof(size_t));
-    size_t* const cCapacities = (size_t* const)malloc(maxNbBlocks * sizeof(size_t));
+    void ** const cPtrs = (void**)malloc(maxNbBlocks * sizeof(void*));
+    size_t* const cSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
+    size_t* const cCapacities = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
 
-    void ** const resPtrs = (void** const)malloc(maxNbBlocks * sizeof(void*));
-    size_t* const resSizes = (size_t* const)malloc(maxNbBlocks * sizeof(size_t));
+    void ** const resPtrs = (void**)malloc(maxNbBlocks * sizeof(void*));
+    size_t* const resSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
 
     BMK_timedFnState_t* timeStateCompress = BMK_createTimeState(adv->nbSeconds);
     BMK_timedFnState_t* timeStateDecompress = BMK_createTimeState(adv->nbSeconds);
 
-    void* compressedBuffer;
     const size_t maxCompressedSize = dstCapacity ? dstCapacity : ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);
-    void* resultBuffer = malloc(srcSize);
 
+    void* const internalDstBuffer = dstBuffer ? NULL : malloc(maxCompressedSize);
+    void* const compressedBuffer = dstBuffer ? dstBuffer : internalDstBuffer;
+
+    void* resultBuffer = malloc(srcSize);
 
     BMK_return_t results = { { 0, 0, 0, 0 }, 0 };
-    int allocationincomplete;
+    int allocationincomplete = !srcPtrs || !srcSizes || !cPtrs || 
+        !cSizes || !cCapacities || !resPtrs || !resSizes || 
+        !timeStateCompress || !timeStateDecompress || !compressedBuffer || !resultBuffer;
 
-    if(!dstCapacity) {
-        compressedBuffer = malloc(maxCompressedSize);
-    } else {
-        compressedBuffer = dstBuffer;
-    }
+    int parametersConflict = !dstBuffer ^ !dstCapacity;
 
-    allocationincomplete = !compressedBuffer || !resultBuffer ||  
-        !srcPtrs || !srcSizes || !cPtrs || !cSizes || !resPtrs || !resSizes;
 
-    if (!allocationincomplete) {
+    if (!allocationincomplete && !parametersConflict) {
         results = BMK_benchMemAdvancedNoAlloc(srcPtrs, srcSizes, cPtrs, cCapacities, cSizes,
             resPtrs, resSizes, &resultBuffer, compressedBuffer, maxCompressedSize, timeStateCompress, timeStateDecompress,
             srcBuffer, srcSize, fileSizes, nbFiles, cLevel, comprParams,
@@ -759,9 +760,8 @@ BMK_return_t BMK_benchMemAdvanced(const void* srcBuffer, size_t srcSize,
     /* clean up */
     BMK_freeTimeState(timeStateCompress);
     BMK_freeTimeState(timeStateDecompress);
-    if(!dstCapacity) { /* only free if not given */
-        free(compressedBuffer);
-    }
+    
+    free(internalDstBuffer);
     free(resultBuffer);
 
     free((void*)srcPtrs); 
@@ -775,6 +775,10 @@ BMK_return_t BMK_benchMemAdvanced(const void* srcBuffer, size_t srcSize,
     if(allocationincomplete) {
         EXM_THROW(31, BMK_return_t, "allocation error : not enough memory");
     }
+    
+    if(parametersConflict) {
+        EXM_THROW(32, BMK_return_t, "Conflicting input results");   
+    }
     return results;
 }
 

diff --git a/programs/bench.h b/programs/bench.h
index 2a9945ac8ec8713d8b9a4592b1878dc7622ca9a1..8baf33a0a5949a262f4e9b29bb71ca20161f3b14 100644 (file)
--- a/programs/bench.h
+++ b/programs/bench.h
@@ -175,7 +175,8 @@ typedef size_t (*BMK_initFn_t)(void*);
  * srcBuffers - an array of buffers to be operated on by benchFn
  * srcSizes - an array of the sizes of above buffers
  * dstBuffers - an array of buffers to be written into by benchFn
- * dstCapacitiesToSizes - an array of the capacities of above buffers. Output modified to compressed sizes of those blocks.
+ * dstCapacities - an array of the capacities of above buffers
+ * blockResults - the return value of benchFn called on each block.
  * nbLoops - defines number of times benchFn is run.
  * assumed array of size blockCount, will have compressed size of each block written to it.
  * return 
@@ -192,7 +193,7 @@ BMK_customReturn_t BMK_benchFunction(BMK_benchFn_t benchFn, void* benchPayload,
                         BMK_initFn_t initFn, void* initPayload,
                         size_t blockCount,
                         const void* const * const srcBuffers, const size_t* srcSizes,
-                        void * const * const dstBuffers, const size_t* dstCapacities, size_t* cSizes,  
+                        void * const * const dstBuffers, const size_t* dstCapacities, size_t* blockResults,  
                         unsigned nbLoops);
 
 
@@ -221,7 +222,7 @@ BMK_customTimedReturn_t BMK_benchFunctionTimed(BMK_timedFnState_t* cont,
     BMK_initFn_t initFn, void* initPayload,
     size_t blockCount,
     const void* const * const srcBlockBuffers, const size_t* srcBlockSizes,
-    void* const * const dstBlockBuffers, const size_t* dstBlockCapacities, size_t* cSizes);
+    void* const * const dstBlockBuffers, const size_t* dstBlockCapacities, size_t* blockResults);
 
 #endif   /* BENCH_H_121279284357 */
 

diff --git a/tests/README.md b/tests/README.md
index 8bedd0a3c0e3271e2feeae7e8ab7efc40367633a..2f0026fdab073cc504fb2a66d54e926c5a452b72 100644 (file)
--- a/tests/README.md
+++ b/tests/README.md
@@ -112,7 +112,6 @@ Full list of arguments
     dSpeed= - Minimum decompression speed
     cMem= - compression memory
     lvl= - Automatically sets compression speed constraint to the speed of that level
- --optimize=  : same as -O with more verbose syntax 
  -P#          : generated sample compressibility 
  -t#          : Caps runtime of operation in seconds (default : 99999 seconds (about 27 hours )) 
  -v           : Prints Benchmarking output

diff --git a/tests/paramgrill.c b/tests/paramgrill.c
index 099be36884f576b556878dd2da91e60218b18f1c..a4f4a5f1520ba85883fd181a2f7ce44d382f957b 100644 (file)
--- a/tests/paramgrill.c
+++ b/tests/paramgrill.c
@@ -986,7 +986,7 @@ static void memoTableIndInv(ZSTD_compressionParameters* ptr, const varInds_t* va
 }
 
 /* Initialize memotable, immediately mark redundant / obviously infeasible params as */
-static void memoTableInit(U8* memoTable, ZSTD_compressionParameters paramConstraints, const constraint_t target, const varInds_t* varyParams, const int varyLen, const size_t srcSize) {
+static void createMemoTable(U8* memoTable, ZSTD_compressionParameters paramConstraints, const constraint_t target, const varInds_t* varyParams, const int varyLen, const size_t srcSize) {
     size_t i;
     size_t arrayLen = memoTableLen(varyParams, varyLen);
     int cwFixed = !paramConstraints.chainLog || !paramConstraints.windowLog;
@@ -1053,23 +1053,24 @@ static void memoTableFreeAll(U8** mtAll) {
 
 /* inits memotables for all (including mallocs), all strategies */
 /* takes unsanitized varyParams */
-static U8** memoTableInitAll(ZSTD_compressionParameters paramConstraints, constraint_t target, const varInds_t* varyParams, const int varyLen, const size_t srcSize) {
+static U8** createMemoTableArray(ZSTD_compressionParameters paramConstraints, constraint_t target, const varInds_t* varyParams, const int varyLen, const size_t srcSize) {
     varInds_t varNew[NUM_PARAMS];
-    int varLenNew;
     U8** mtAll = calloc(sizeof(U8*),(ZSTD_btultra + 1));
     int i;
     if(mtAll == NULL) {
         return NULL;
     }
+
     for(i = 1; i <= (int)ZSTD_btultra; i++) {
-        varLenNew = sanitizeVarArray(varNew, varyLen, varyParams, i);
+        const int varLenNew = sanitizeVarArray(varNew, varyLen, varyParams, i);
         mtAll[i] = malloc(sizeof(U8) * memoTableLen(varNew, varLenNew));
         if(mtAll[i] == NULL) {
             memoTableFreeAll(mtAll);
             return NULL;
         }
-        memoTableInit(mtAll[i], paramConstraints, target, varNew, varLenNew, srcSize);
+        createMemoTable(mtAll[i], paramConstraints, target, varNew, varLenNew, srcSize);
     }
+    
     return mtAll;
 }
 
@@ -1187,7 +1188,7 @@ static void BMK_benchFullTable(ZSTD_CCtx* cctx, ZSTD_DCtx* dctx, const void* src
     winnerInfo_t winners[NB_LEVELS_TRACKED+1];
     const char* const rfName = "grillResults.txt";
     FILE* const f = fopen(rfName, "w");
-    const size_t blockSize = g_blockSize ? g_blockSize : ZSTD_BLOCKSIZE_MAX;   /* cut by block or not ? */
+    const size_t blockSize = g_blockSize ? g_blockSize : srcSize;   /* cut by block or not ? */
 
     /* init */
     assert(g_singleRun==0);
@@ -1638,7 +1639,7 @@ static void freeBuffers(buffers_t b) {
 }
 
 /* allocates buffer's arguments. returns success / failuere */
-static int initBuffers(buffers_t* buff, const char* const * const fileNamesTable, 
+static int createBuffers(buffers_t* buff, const char* const * const fileNamesTable, 
                           size_t nbFiles)
 {
     size_t pos = 0;
@@ -1659,7 +1660,7 @@ static int initBuffers(buffers_t* buff, const char* const * const fileNamesTable
     buff->resPtrs = (void**)calloc(maxNbBlocks, sizeof(void*));
     buff->resSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t)); 
 
-    if(!buff->srcPtrs || !buff->srcSizes || !buff->dstPtrs || !buff->dstCapacities || !buff->dstCapacities || !buff->resPtrs || !buff->resSizes) {
+    if(!buff->srcPtrs || !buff->srcSizes || !buff->dstPtrs || !buff->dstCapacities || !buff->dstSizes || !buff->resPtrs || !buff->resSizes) {
         DISPLAY("alloc error\n");
         freeBuffers(*buff);
         return 1;
@@ -1747,7 +1748,7 @@ static void freeContexts(contexts_t ctx) {
     ZSTD_freeDCtx(ctx.dctx);
 }
 
-static int initContexts(contexts_t* ctx, const char* dictFileName) {
+static int createContexts(contexts_t* ctx, const char* dictFileName) {
     FILE* f;
     size_t readSize;
     ctx->cctx = ZSTD_createCCtx();
@@ -1846,12 +1847,12 @@ static int optimizeForSize(const char* const * const fileNamesTable, const size_
     }
 
     /* load dictionary*/
-    if(initBuffers(&buf, fileNamesTable, nbFiles)) {
+    if(createBuffers(&buf, fileNamesTable, nbFiles)) {
         DISPLAY("unable to load files\n");
         return 1;
     }
 
-    if(initContexts(&ctx, dictFileName)) {
+    if(createContexts(&ctx, dictFileName)) {
         DISPLAY("unable to load dictionary\n");
         freeBuffers(buf);
         return 2;
@@ -1885,9 +1886,9 @@ static int optimizeForSize(const char* const * const fileNamesTable, const size_
             goto _cleanUp;
         }
         
-        memoTableInit(allMT[paramTarget.strategy], paramTarget, target, varNew, varLenNew, maxBlockSize);
+        createMemoTable(allMT[paramTarget.strategy], paramTarget, target, varNew, varLenNew, maxBlockSize);
     } else {
-         allMT = memoTableInitAll(paramTarget, target, varArray, varLen, maxBlockSize);
+         allMT = createMemoTableArray(paramTarget, target, varArray, varLen, maxBlockSize);
     }