minor variable isolation

and remove a goto

diff --git a/programs/bench.c b/programs/bench.c
index 905f84edd5f801fc05506ef5f02ac81490f46185..2bde4c03cdca95547a0fcd8f37343e0a8c83ca04 100644 (file)
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -239,17 +239,15 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
     RDG_genBuffer(compressedBuffer, maxCompressedSize, 0.10, 0.50, 1);
 
     /* Bench */
-    {   size_t cSize = 0;
-        double fastestC = 100000000., fastestD = 100000000.;
-        double ratio = 0.;
-        U64 crcCheck = 0;
+    {   double fastestC = 100000000., fastestD = 100000000.;
         clock_t coolTime = clock();
         U32 testNb;
 
         DISPLAY("\r%79s\r", "");
         for (testNb = 1; testNb <= (g_nbIterations + !g_nbIterations); testNb++) {
-            int nbLoops;
-            clock_t clockStart, clockSpan;
+            size_t cSize;
+            double ratio = 0.;
+            clock_t clockStart;
             clock_t const clockLoop = g_nbIterations ? TIMELOOP_S * CLOCKS_PER_SEC : 10;
 
             /* overheat protection */
@@ -266,20 +264,21 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
             clockStart = clock();
             while (clock() == clockStart);
             clockStart = clock();
-
-            for (nbLoops = 0 ; BMK_clockSpan(clockStart) < clockLoop ; nbLoops++) {
-                U32 blockNb;
-                ZSTD_compressBegin_usingDict(refCtx, dictBuffer, dictBufferSize, cLevel);
-                for (blockNb=0; blockNb<nbBlocks; blockNb++) {
-                    size_t const rSize = ZSTD_compress_usingPreparedCCtx(ctx, refCtx,
-                                        blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
-                                        blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize);
-                    if (ZSTD_isError(rSize)) EXM_THROW(1, "ZSTD_compress_usingPreparedCCtx() failed : %s", ZSTD_getErrorName(rSize));
-                    blockTable[blockNb].cSize = rSize;
+            {   U32 nbLoops;
+                for (nbLoops = 0 ; BMK_clockSpan(clockStart) < clockLoop ; nbLoops++) {
+                    U32 blockNb;
+                    ZSTD_compressBegin_usingDict(refCtx, dictBuffer, dictBufferSize, cLevel);
+                    for (blockNb=0; blockNb<nbBlocks; blockNb++) {
+                        size_t const rSize = ZSTD_compress_usingPreparedCCtx(ctx, refCtx,
+                                            blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
+                                            blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize);
+                        if (ZSTD_isError(rSize)) EXM_THROW(1, "ZSTD_compress_usingPreparedCCtx() failed : %s", ZSTD_getErrorName(rSize));
+                        blockTable[blockNb].cSize = rSize;
+                }   }
+                {   clock_t const clockSpan = BMK_clockSpan(clockStart);
+                    if ((double)clockSpan < fastestC*nbLoops) fastestC = (double)clockSpan / nbLoops;
             }   }
-            clockSpan = BMK_clockSpan(clockStart);
 
-            if ((double)clockSpan < fastestC*nbLoops) fastestC = (double)clockSpan / nbLoops;
             cSize = 0;
             { U32 blockNb; for (blockNb=0; blockNb<nbBlocks; blockNb++) cSize += blockTable[blockNb].cSize; }
             ratio = (double)srcSize / (double)cSize;
@@ -287,7 +286,7 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     testNb, displayName, (U32)srcSize, (U32)cSize, ratio,
                     (double)srcSize / 1000000. / (fastestC / CLOCKS_PER_SEC) );
 
-            (void)crcCheck; (void)fastestD; (void)crcOrig;   /*  unused when decompression disabled */
+            (void)fastestD; (void)crcOrig;   /*  unused when decompression disabled */
 #if 1
             /* Decompression */
             memset(resultBuffer, 0xD6, srcSize);  /* warm result buffer */
@@ -296,53 +295,54 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
             while (clock() == clockStart);
             clockStart = clock();
 
-            for (nbLoops = 0 ; BMK_clockSpan(clockStart) < clockLoop ; nbLoops++) {
-                U32 blockNb;
-                ZSTD_decompressBegin_usingDict(refDCtx, dictBuffer, dictBufferSize);
-                for (blockNb=0; blockNb<nbBlocks; blockNb++) {
-                    size_t regenSize = ZSTD_decompress_usingPreparedDCtx(dctx, refDCtx,
-                        blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
-                        blockTable[blockNb].cPtr, blockTable[blockNb].cSize);
-                    if (ZSTD_isError(regenSize)) {
-                        DISPLAY("ZSTD_decompress_usingPreparedDCtx() failed on block %u : %s",
-                                  blockNb, ZSTD_getErrorName(regenSize));
-                        goto _findError;
-                    }
-                    blockTable[blockNb].resSize = regenSize;
+            {   U32 nbLoops;
+                for (nbLoops = 0 ; BMK_clockSpan(clockStart) < clockLoop ; nbLoops++) {
+                    U32 blockNb;
+                    ZSTD_decompressBegin_usingDict(refDCtx, dictBuffer, dictBufferSize);
+                    for (blockNb=0; blockNb<nbBlocks; blockNb++) {
+                        size_t const regenSize = ZSTD_decompress_usingPreparedDCtx(dctx, refDCtx,
+                            blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
+                            blockTable[blockNb].cPtr, blockTable[blockNb].cSize);
+                        if (ZSTD_isError(regenSize)) {
+                            DISPLAY("ZSTD_decompress_usingPreparedDCtx() failed on block %u : %s  \n",
+                                      blockNb, ZSTD_getErrorName(regenSize));
+                            break;
+                        }
+                        blockTable[blockNb].resSize = regenSize;
+                }   }
+                {   clock_t const clockSpan = BMK_clockSpan(clockStart);
+                    if ((double)clockSpan < fastestD*nbLoops) fastestD = (double)clockSpan / nbLoops;
             }   }
 
-            clockSpan = BMK_clockSpan(clockStart);
-            if ((double)clockSpan < fastestD*nbLoops) fastestD = (double)clockSpan / nbLoops;
             DISPLAY("%2i-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s ,%6.1f MB/s\r",
                     testNb, displayName, (U32)srcSize, (U32)cSize, ratio,
                     (double)srcSize / 1000000. / (fastestC / CLOCKS_PER_SEC),
                     (double)srcSize / 1000000. / (fastestD / CLOCKS_PER_SEC) );
 
             /* CRC Checking */
-_findError:
-            crcCheck = XXH64(resultBuffer, srcSize, 0);
-            if (crcOrig!=crcCheck) {
-                size_t u;
-                DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n", displayName, (unsigned)crcOrig, (unsigned)crcCheck);
-                for (u=0; u<srcSize; u++) {
-                    if (((const BYTE*)srcBuffer)[u] != ((const BYTE*)resultBuffer)[u]) {
-                        U32 segNb, bNb, pos;
-                        size_t bacc = 0;
-                        printf("Decoding error at pos %u ", (U32)u);
-                        for (segNb = 0; segNb < nbBlocks; segNb++) {
-                            if (bacc + blockTable[segNb].srcSize > u) break;
-                            bacc += blockTable[segNb].srcSize;
+            {   U64 const crcCheck = XXH64(resultBuffer, srcSize, 0);
+                if (crcOrig!=crcCheck) {
+                    size_t u;
+                    DISPLAY("!!! WARNING !!! %14s : Invalid Checksum : %x != %x   \n", displayName, (unsigned)crcOrig, (unsigned)crcCheck);
+                    for (u=0; u<srcSize; u++) {
+                        if (((const BYTE*)srcBuffer)[u] != ((const BYTE*)resultBuffer)[u]) {
+                            U32 segNb, bNb, pos;
+                            size_t bacc = 0;
+                            DISPLAY("Decoding error at pos %u ", (U32)u);
+                            for (segNb = 0; segNb < nbBlocks; segNb++) {
+                                if (bacc + blockTable[segNb].srcSize > u) break;
+                                bacc += blockTable[segNb].srcSize;
+                            }
+                            pos = (U32)(u - bacc);
+                            bNb = pos / (128 KB);
+                            DISPLAY("(block %u, sub %u, pos %u) \n", segNb, bNb, pos);
+                            break;
                         }
-                        pos = (U32)(u - bacc);
-                        bNb = pos / (128 KB);
-                        printf("(block %u, sub %u, pos %u) \n", segNb, bNb, pos);
-                        break;
-                    }
-                    if (u==srcSize-1) {  /* should never happen */
-                        printf("no difference detected\n");
-                }   }
-                break;
-            }   /* if (crcOrig!=crcCheck) */
+                        if (u==srcSize-1) {  /* should never happen */
+                            DISPLAY("no difference detected\n");
+                    }   }
+                    break;
+            }   }   /* CRC Checking */
 #endif
         }   /* for (testNb = 1; testNb <= (g_nbIterations + !g_nbIterations); testNb++) */
         DISPLAY("%2i#\n", cLevel);
@@ -407,23 +407,25 @@ static U64 BMK_getTotalFileSize(const char** fileNamesTable, unsigned nbFiles)
     return total;
 }
 
+/*! BMK_loadFiles() :
+    Loads `buffer` with content of files listed within `fileNamesTable`.
+    At most, fills `buffer` entirely */
 static void BMK_loadFiles(void* buffer, size_t bufferSize,
                           size_t* fileSizes,
-                          const char** fileNamesTable, unsigned const nbFiles)
+                          const char** fileNamesTable, unsigned nbFiles)
 {
     size_t pos = 0;
 
     unsigned n;
     for (n=0; n<nbFiles; n++) {
-        size_t readSize;
         U64 fileSize = BMK_getFileSize(fileNamesTable[n]);
-        FILE* f = fopen(fileNamesTable[n], "rb");
+        FILE* const f = fopen(fileNamesTable[n], "rb");
         if (f==NULL) EXM_THROW(10, "impossible to open file %s", fileNamesTable[n]);
         DISPLAYLEVEL(2, "Loading %s...       \r", fileNamesTable[n]);
-        if (fileSize > bufferSize-pos) fileSize = bufferSize-pos;
-        readSize = fread(((char*)buffer)+pos, 1, (size_t)fileSize, f);
-        if (readSize != (size_t)fileSize) EXM_THROW(11, "could not read %s", fileNamesTable[n]);
-        pos += readSize;
+        if (fileSize > bufferSize-pos) fileSize = bufferSize-pos, nbFiles=n;   /* buffer too small - stop after this file */
+        { size_t const readSize = fread(((char*)buffer)+pos, 1, (size_t)fileSize, f);
+          if (readSize != (size_t)fileSize) EXM_THROW(11, "could not read %s", fileNamesTable[n]);
+          pos += readSize; }
         fileSizes[n] = (size_t)fileSize;
         fclose(f);
     }