convert benchmark unit to use the new naming scheme

chunks instead of blocks

diff --git a/programs/benchzstd.c b/programs/benchzstd.c
index f9274a5172c1815881436c93781adc5061bbf1c8..f55c869750450b4acaa96c4256165d7f0135a23c 100644 (file)
--- a/programs/benchzstd.c
+++ b/programs/benchzstd.c
@@ -208,7 +208,7 @@ BMK_advancedParams_t BMK_initAdvancedParams(void)
     BMK_advancedParams_t const res = {
         BMK_both,               /* mode */
         BMK_TIMETEST_DEFAULT_S, /* nbSeconds */
-        0,                      /* blockSize */
+        0,                      /* chunkSizeMax */
         0,               /* targetCBlockSize */
         0,                      /* nbWorkers */
         0,                      /* realTime */
@@ -227,16 +227,6 @@ BMK_advancedParams_t BMK_initAdvancedParams(void)
 /* ********************************************************
  *  Bench functions
  **********************************************************/
-typedef struct {
-    const void* srcPtr;
-    size_t srcSize;
-    void* cPtr;
-    size_t cRoom;
-    size_t cSize;
-    void* resPtr;
-    size_t resSize;
-} blockParam_t;
-
 #undef MIN
 #undef MAX
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
@@ -435,16 +425,16 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         const char* displayName,
         const BMK_advancedParams_t* adv)
 {
-    size_t const blockSize =
-            ((adv->blockSize >= 32 && (adv->mode != BMK_decodeOnly))
-                     ? adv->blockSize
+    size_t const chunkSizeMax =
+            ((adv->chunkSizeMax >= 32 && (adv->mode != BMK_decodeOnly))
+                     ? adv->chunkSizeMax
                      : srcSize)
             + (!srcSize); /* avoid div by 0 */
     BMK_benchResult_t benchResult;
     size_t const loadedCompressedSize = srcSize;
     size_t cSize                      = 0;
     double ratio                      = 0.;
-    U32 nbBlocks;
+    U32 nbChunks = 0;
 
     assert(cctx != NULL);
     assert(dctx != NULL);
@@ -500,41 +490,42 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         }
     }
 
-    /* Init data blocks  */
+    /* Init data chunks  */
     {
         const char* srcPtr = (const char*)srcBuffer;
         char* cPtr         = (char*)compressedBuffer;
         char* resPtr       = (char*)(*resultBufferPtr);
-        U32 fileNb;
-        for (nbBlocks = 0, fileNb = 0; fileNb < nbFiles; fileNb++) {
+        U32 fileNb, chunkID;
+        for (chunkID = 0, fileNb = 0; fileNb < nbFiles; fileNb++) {
             size_t remaining              = fileSizes[fileNb];
-            U32 const nbBlocksforThisFile = (adv->mode == BMK_decodeOnly)
+            U32 const nbChunksforThisFile = (adv->mode == BMK_decodeOnly)
                     ? 1
-                    : (U32)((remaining + (blockSize - 1)) / blockSize);
-            U32 const blockEnd            = nbBlocks + nbBlocksforThisFile;
-            for (; nbBlocks < blockEnd; nbBlocks++) {
-                size_t const thisBlockSize = MIN(remaining, blockSize);
-                srcPtrs[nbBlocks]          = srcPtr;
-                srcSizes[nbBlocks]         = thisBlockSize;
-                cPtrs[nbBlocks]            = cPtr;
-                cCapacities[nbBlocks]      = (adv->mode == BMK_decodeOnly)
-                             ? thisBlockSize
-                             : ZSTD_compressBound(thisBlockSize);
-                resPtrs[nbBlocks]          = resPtr;
-                resSizes[nbBlocks]         = (adv->mode == BMK_decodeOnly)
+                    : (U32)((remaining + (chunkSizeMax - 1)) / chunkSizeMax);
+            U32 const chunkIdEnd       = chunkID + nbChunksforThisFile;
+            for (; chunkID < chunkIdEnd; chunkID++) {
+                size_t const chunkSize = MIN(remaining, chunkSizeMax);
+                srcPtrs[chunkID]       = srcPtr;
+                srcSizes[chunkID]      = chunkSize;
+                cPtrs[chunkID]         = cPtr;
+                cCapacities[chunkID]   = (adv->mode == BMK_decodeOnly)
+                             ? chunkSize
+                             : ZSTD_compressBound(chunkSize);
+                resPtrs[chunkID]       = resPtr;
+                resSizes[chunkID]      = (adv->mode == BMK_decodeOnly)
                                 ? (size_t)ZSTD_findDecompressedSize(
-                                srcPtr, thisBlockSize)
-                                : thisBlockSize;
-                srcPtr += thisBlockSize;
-                cPtr += cCapacities[nbBlocks];
-                resPtr += thisBlockSize;
-                remaining -= thisBlockSize;
+                                srcPtr, chunkSize)
+                                : chunkSize;
+                srcPtr += chunkSize;
+                cPtr += cCapacities[chunkID];
+                resPtr += chunkSize;
+                remaining -= chunkSize;
                 if (adv->mode == BMK_decodeOnly) {
-                    cSizes[nbBlocks]  = thisBlockSize;
-                    benchResult.cSize = thisBlockSize;
+                    cSizes[chunkID]  = chunkSize;
+                    benchResult.cSize = chunkSize;
                 }
             }
         }
+        nbChunks = chunkID;
     }
 
     /* warming up `compressedBuffer` */
@@ -569,7 +560,7 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         cbp.initFn        = local_initCCtx; /* BMK_initCCtx */
         cbp.initPayload   = &cctxprep;
         cbp.errorFn       = ZSTD_isError;
-        cbp.blockCount    = nbBlocks;
+        cbp.blockCount    = nbChunks;
         cbp.srcBuffers    = srcPtrs;
         cbp.srcSizes      = srcSizes;
         cbp.dstBuffers    = cPtrs;
@@ -588,7 +579,7 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         dbp.initFn        = local_initDCtx;
         dbp.initPayload   = &dctxprep;
         dbp.errorFn       = ZSTD_isError;
-        dbp.blockCount    = nbBlocks;
+        dbp.blockCount    = nbChunks;
         dbp.srcBuffers    = (const void* const*)cPtrs;
         dbp.srcSizes      = cSizes;
         dbp.dstBuffers    = resPtrs;
@@ -690,8 +681,7 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
         } /* while (!(compressionCompleted && decompressionCompleted)) */
 
         /* CRC Checking */
-        {
-            const BYTE* resultBuffer = (const BYTE*)(*resultBufferPtr);
+        {   const BYTE* resultBuffer = (const BYTE*)(*resultBufferPtr);
             U64 const crcCheck       = XXH64(resultBuffer, srcSize, 0);
             if ((adv->mode == BMK_both) && (crcOrig != crcCheck)) {
                 size_t u;
@@ -704,14 +694,14 @@ static BMK_benchOutcome_t BMK_benchMemAdvancedNoAlloc(
                         unsigned segNb, bNb, pos;
                         size_t bacc = 0;
                         DISPLAY("Decoding error at pos %u ", (unsigned)u);
-                        for (segNb = 0; segNb < nbBlocks; segNb++) {
+                        for (segNb = 0; segNb < nbChunks; segNb++) {
                             if (bacc + srcSizes[segNb] > u)
                                 break;
                             bacc += srcSizes[segNb];
                         }
                         pos = (U32)(u - bacc);
                         bNb = pos / (128 KB);
-                        DISPLAY("(sample %u, block %u, pos %u) \n",
+                        DISPLAY("(sample %u, chunk %u, pos %u) \n",
                                 segNb,
                                 bNb,
                                 pos);
@@ -795,25 +785,24 @@ BMK_benchOutcome_t BMK_benchMemAdvanced(
     int const dstParamsError =
             !dstBuffer ^ !dstCapacity; /* must be both NULL or none */
 
-    size_t const blockSize =
-            ((adv->blockSize >= 32 && (adv->mode != BMK_decodeOnly))
-                     ? adv->blockSize
+    size_t const chunkSize =
+            ((adv->chunkSizeMax >= 32 && (adv->mode != BMK_decodeOnly))
+                     ? adv->chunkSizeMax
                      : srcSize)
             + (!srcSize) /* avoid div by 0 */;
-    U32 const maxNbBlocks =
-            (U32)((srcSize + (blockSize - 1)) / blockSize) + nbFiles;
+    U32 const nbChunksMax =
+            (U32)((srcSize + (chunkSize - 1)) / chunkSize) + nbFiles;
 
-    /* these are the blockTable parameters, just split up */
     const void** const srcPtrs =
-            (const void**)malloc(maxNbBlocks * sizeof(void*));
-    size_t* const srcSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
+            (const void**)malloc(nbChunksMax * sizeof(void*));
+    size_t* const srcSizes = (size_t*)malloc(nbChunksMax * 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 cPtrs        = (void**)malloc(nbChunksMax * sizeof(void*));
+    size_t* const cSizes      = (size_t*)malloc(nbChunksMax * sizeof(size_t));
+    size_t* const cCapacities = (size_t*)malloc(nbChunksMax * sizeof(size_t));
 
-    void** const resPtrs   = (void**)malloc(maxNbBlocks * sizeof(void*));
-    size_t* const resSizes = (size_t*)malloc(maxNbBlocks * sizeof(size_t));
+    void** const resPtrs   = (void**)malloc(nbChunksMax * sizeof(void*));
+    size_t* const resSizes = (size_t*)malloc(nbChunksMax * sizeof(size_t));
 
     BMK_timedFnState_t* timeStateCompress = BMK_createTimedFnState(
             adv->nbSeconds * 1000, BMK_RUNTEST_DEFAULT_MS);
@@ -825,7 +814,7 @@ BMK_benchOutcome_t BMK_benchMemAdvanced(
 
     const size_t maxCompressedSize = dstCapacity
             ? dstCapacity
-            : ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);
+            : ZSTD_compressBound(srcSize) + (nbChunksMax * 1024);
 
     void* const internalDstBuffer =
             dstBuffer ? NULL : malloc(maxCompressedSize);
@@ -964,12 +953,12 @@ static int BMK_benchCLevels(
     }
 
     if (displayLevel == 1 && !adv->additionalParam) /* --quiet mode */
-        OUTPUT("bench %s %s: input %u bytes, %u seconds, %u KB blocks\n",
+        OUTPUT("bench %s %s: input %u bytes, %u seconds, %u KB chunks\n",
                ZSTD_VERSION_STRING,
                ZSTD_GIT_COMMIT_STRING,
                (unsigned)benchedSize,
                adv->nbSeconds,
-               (unsigned)(adv->blockSize >> 10));
+               (unsigned)(adv->chunkSizeMax >> 10));
 
     for (level = startCLevel; level <= endCLevel; level++) {
         BMK_benchOutcome_t res = BMK_benchMemAdvanced(
@@ -1000,7 +989,7 @@ int BMK_syntheticTest(
 {
     char nameBuff[20]        = { 0 };
     const char* name         = nameBuff;
-    size_t const benchedSize = adv->blockSize ? adv->blockSize : 10000000;
+    size_t const benchedSize = adv->chunkSizeMax ? adv->chunkSizeMax : 10000000;
 
     /* Memory allocation */
     void* const srcBuffer = malloc(benchedSize);

diff --git a/programs/benchzstd.h b/programs/benchzstd.h
index db4d72f9d743f2a4f7798ad61f6d8743fda571fc..d62a33c0aec40f7cab91227c8fd853758aeea554 100644 (file)
--- a/programs/benchzstd.h
+++ b/programs/benchzstd.h
@@ -94,7 +94,7 @@ typedef enum {
 typedef struct {
     BMK_mode_t mode;        /* 0: both, 1: compress only 2: decode only */
     unsigned nbSeconds;     /* default timing is in nbSeconds */
-    size_t blockSize;       /* Maximum size of each independent chunk */
+    size_t chunkSizeMax;    /* Maximum size of each independent chunk */
     size_t targetCBlockSize;/* Approximative size of compressed blocks */
     int nbWorkers;          /* multithreading */
     unsigned realTime;      /* real time priority */

diff --git a/programs/zstdcli.c b/programs/zstdcli.c
index 38d00225fe4f27ef4f659ad6ebdd3c9c7c499807..7395e9585e07f5f15d85c3577dd1df895193cd08 100644 (file)
--- a/programs/zstdcli.c
+++ b/programs/zstdcli.c
@@ -1414,7 +1414,7 @@ int main(int argCount, const char* argv[])
             DISPLAYLEVEL(1, "benchmark mode is only compatible with zstd format \n");
             CLEAN_RETURN(1);
         }
-        benchParams.blockSize = chunkSize;
+        benchParams.chunkSizeMax = chunkSize;
         benchParams.targetCBlockSize = targetCBlockSize;
         benchParams.nbWorkers = (int)nbWorkers;
         benchParams.realTime = (unsigned)setRealTimePrio;