From 27caf2afca1ade42e7fd42d49ecdaa768758ec60 Mon Sep 17 00:00:00 2001
From: Yann Collet <yann.collet.73@gmail.com>
Date: Fri, 1 Apr 2016 15:48:48 +0200
Subject: [PATCH] minor variable isolation

---
 lib/zbuff.c          |  77 +++----
 lib/zbuff.h          |  13 +-
 lib/zstd_compress.c  |  36 +--
 programs/result      | 519 +++++++++++++++++++++++++++++++++++++++++++
 programs/tmp.mgz     | Bin 0 -> 5549 bytes
 programs/tmp.zstd    | Bin 0 -> 6317 bytes
 programs/zbufftest.c |  99 +++------
 7 files changed, 614 insertions(+), 130 deletions(-)
 create mode 100644 programs/result
 create mode 100644 programs/tmp.mgz
 create mode 100644 programs/tmp.zstd

diff --git a/lib/zbuff.c b/lib/zbuff.c
index e26072d81..1027c6973 100644
--- a/lib/zbuff.c
+++ b/lib/zbuff.c
@@ -128,18 +128,14 @@ size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
                                    const void* dict, size_t dictSize,
                                    ZSTD_parameters params, U64 pledgedSrcSize)
 {
-    size_t neededInBuffSize;
-
-    ZSTD_adjustCParams(&params.cParams, pledgedSrcSize, dictSize);
-    neededInBuffSize = (size_t)1 << params.cParams.windowLog;
-
     /* allocate buffers */
-    if (zbc->inBuffSize < neededInBuffSize) {
-        zbc->inBuffSize = neededInBuffSize;
-        free(zbc->inBuff);   /* should not be necessary */
-        zbc->inBuff = (char*)malloc(neededInBuffSize);
-        if (zbc->inBuff == NULL) return ERROR(memory_allocation);
-    }
+    {   size_t const neededInBuffSize = (size_t)1 << params.cParams.windowLog;
+        if (zbc->inBuffSize < neededInBuffSize) {
+            zbc->inBuffSize = neededInBuffSize;
+            free(zbc->inBuff);   /* should not be necessary */
+            zbc->inBuff = (char*)malloc(neededInBuffSize);
+            if (zbc->inBuff == NULL) return ERROR(memory_allocation);
+    }   }
     zbc->blockSize = MIN(ZSTD_BLOCKSIZE_MAX, zbc->inBuffSize);
     if (zbc->outBuffSize < ZSTD_compressBound(zbc->blockSize)+1) {
         zbc->outBuffSize = ZSTD_compressBound(zbc->blockSize)+1;
@@ -148,23 +144,24 @@ size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
         if (zbc->outBuff == NULL) return ERROR(memory_allocation);
     }
 
-    zbc->outBuffContentSize = ZSTD_compressBegin_advanced(zbc->zc, dict, dictSize, params, pledgedSrcSize);
-    if (ZSTD_isError(zbc->outBuffContentSize)) return zbc->outBuffContentSize;
+    { size_t const errorCode = ZSTD_compressBegin_advanced(zbc->zc, dict, dictSize, params, pledgedSrcSize);
+      if (ZSTD_isError(errorCode)) return errorCode; }
 
     zbc->inToCompress = 0;
     zbc->inBuffPos = 0;
     zbc->inBuffTarget = zbc->blockSize;
     zbc->outBuffFlushedSize = 0;
-    zbc->stage = ZBUFFcs_flush;   /* starts by flushing the header */
+    zbc->stage = ZBUFFcs_load;
     return 0;   /* ready to go */
 }
 
 
-ZSTDLIB_API size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)
+size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)
 {
     ZSTD_parameters params;
     params.cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
     params.fParams.contentSizeFlag = 0;
+    ZSTD_adjustCParams(&params.cParams, 0, dictSize);
     return ZBUFF_compressInit_advanced(zbc, dict, dictSize, params, 0);
 }
 
@@ -190,11 +187,11 @@ static size_t ZBUFF_compressContinue_generic(ZBUFF_CCtx* zbc,
 {
     U32 notDone = 1;
     const char* const istart = (const char*)src;
-    const char* ip = istart;
     const char* const iend = istart + *srcSizePtr;
+    const char* ip = istart;
     char* const ostart = (char*)dst;
-    char* op = ostart;
     char* const oend = ostart + *dstCapacityPtr;
+    char* op = ostart;
 
     while (notDone) {
         switch(zbc->stage)
@@ -203,19 +200,17 @@ static size_t ZBUFF_compressContinue_generic(ZBUFF_CCtx* zbc,
 
         case ZBUFFcs_load:
             /* complete inBuffer */
-            {
-                size_t toLoad = zbc->inBuffTarget - zbc->inBuffPos;
-                size_t loaded = ZBUFF_limitCopy(zbc->inBuff + zbc->inBuffPos, toLoad, ip, iend-ip);
+            {   size_t const toLoad = zbc->inBuffTarget - zbc->inBuffPos;
+                size_t const loaded = ZBUFF_limitCopy(zbc->inBuff + zbc->inBuffPos, toLoad, ip, iend-ip);
                 zbc->inBuffPos += loaded;
                 ip += loaded;
                 if ( (zbc->inBuffPos==zbc->inToCompress) || (!flush && (toLoad != loaded)) ) {
                     notDone = 0; break;  /* not enough input to get a full block : stop there, wait for more */
             }   }
             /* compress current block (note : this stage cannot be stopped in the middle) */
-            {
-                void* cDst;
+            {   void* cDst;
                 size_t cSize;
-                size_t iSize = zbc->inBuffPos - zbc->inToCompress;
+                size_t const iSize = zbc->inBuffPos - zbc->inToCompress;
                 size_t oSize = oend-op;
                 if (oSize >= ZSTD_compressBound(iSize))
                     cDst = op;   /* compress directly into output buffer (avoid flush stage) */
@@ -231,15 +226,13 @@ static size_t ZBUFF_compressContinue_generic(ZBUFF_CCtx* zbc,
                 if (cDst == op) { op += cSize; break; }   /* no need to flush */
                 zbc->outBuffContentSize = cSize;
                 zbc->outBuffFlushedSize = 0;
-                zbc->stage = ZBUFFcs_flush;
-                // break;   /* flush stage follows */
+                zbc->stage = ZBUFFcs_flush;   /* continue to flush stage */
             }
 
         case ZBUFFcs_flush:
             /* flush into dst */
-            {
-                size_t toFlush = zbc->outBuffContentSize - zbc->outBuffFlushedSize;
-                size_t flushed = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outBuffFlushedSize, toFlush);
+            {   size_t const toFlush = zbc->outBuffContentSize - zbc->outBuffFlushedSize;
+                size_t const flushed = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outBuffFlushedSize, toFlush);
                 op += flushed;
                 zbc->outBuffFlushedSize += flushed;
                 if (toFlush!=flushed) { notDone = 0; break; } /* not enough space within dst to store compressed block : stop there */
@@ -255,8 +248,7 @@ static size_t ZBUFF_compressContinue_generic(ZBUFF_CCtx* zbc,
 
     *srcSizePtr = ip - istart;
     *dstCapacityPtr = op - ostart;
-    {
-        size_t hintInSize = zbc->inBuffTarget - zbc->inBuffPos;
+    {   size_t hintInSize = zbc->inBuffTarget - zbc->inBuffPos;
         if (hintInSize==0) hintInSize = zbc->blockSize;
         return hintInSize;
     }
@@ -276,7 +268,7 @@ size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc,
 size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
 {
     size_t srcSize = 0;
-    ZBUFF_compressContinue_generic(zbc, dst, dstCapacityPtr, &srcSize, &srcSize, 1);  /* use a valid src address instead of NULL, as some sanitizer don't like it */
+    ZBUFF_compressContinue_generic(zbc, dst, dstCapacityPtr, &srcSize, &srcSize, 1);  /* use a valid src address instead of NULL */
     return zbc->outBuffContentSize - zbc->outBuffFlushedSize;
 }
 
@@ -284,8 +276,8 @@ size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
 size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
 {
     BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
     BYTE* const oend = ostart + *dstCapacityPtr;
+    BYTE* op = ostart;
     size_t outSize = *dstCapacityPtr;
     size_t epilogueSize, remaining;
     ZBUFF_compressFlush(zbc, dst, &outSize);    /* flush any remaining inBuff */
@@ -411,7 +403,7 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
                     return headerSize;
             }   }
 
-            /* Frame header provides buffer sizes */
+            /* Frame header instruct buffer sizes */
             {   size_t const neededInSize = ZSTD_BLOCKSIZE_MAX;   /* a block is never > ZSTD_BLOCKSIZE_MAX */
                 if (zbc->inBuffSize < neededInSize) {
                     free(zbc->inBuff);
@@ -419,8 +411,7 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
                     zbc->inBuff = (char*)malloc(neededInSize);
                     if (zbc->inBuff == NULL) return ERROR(memory_allocation);
             }   }
-            {
-                size_t const neededOutSize = (size_t)1 << zbc->fParams.windowLog;
+            {   size_t const neededOutSize = (size_t)1 << zbc->fParams.windowLog;
                 if (zbc->outBuffSize < neededOutSize) {
                     free(zbc->outBuff);
                     zbc->outBuffSize = neededOutSize;
@@ -430,8 +421,7 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
             zbc->stage = ZBUFFds_read;
 
         case ZBUFFds_read:
-            {
-                size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
+            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
                 if (neededInSize==0) {  /* end of frame */
                     zbc->stage = ZBUFFds_init;
                     notDone = 0;
@@ -454,8 +444,7 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
             }
 
         case ZBUFFds_load:
-            {
-                size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
+            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
                 size_t const toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */
                 size_t loadedSize;
                 if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */
@@ -463,8 +452,8 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
                 ip += loadedSize;
                 zbc->inPos += loadedSize;
                 if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
-                {
-                    size_t const decodedSize = ZSTD_decompressContinue(zbc->zc,
+                /* decode loaded input */
+                {   size_t const decodedSize = ZSTD_decompressContinue(zbc->zc,
                         zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
                         zbc->inBuff, neededInSize);
                     if (ZSTD_isError(decodedSize)) return decodedSize;
@@ -475,8 +464,7 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
                     // break; /* ZBUFFds_flush follows */
             }   }
         case ZBUFFds_flush:
-            {
-                size_t const toFlushSize = zbc->outEnd - zbc->outStart;
+            {   size_t const toFlushSize = zbc->outEnd - zbc->outStart;
                 size_t const flushedSize = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);
                 op += flushedSize;
                 zbc->outStart += flushedSize;
@@ -496,8 +484,7 @@ size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc,
     /* result */
     *srcSizePtr = ip-istart;
     *dstCapacityPtr = op-ostart;
-    {
-        size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zbc->zc);
+    {   size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zbc->zc);
         if (nextSrcSizeHint > ZSTD_blockHeaderSize) nextSrcSizeHint+= ZSTD_blockHeaderSize;   /* get following block header too */
         nextSrcSizeHint -= zbc->inPos;   /* already loaded*/
         return nextSrcSizeHint;
diff --git a/lib/zbuff.h b/lib/zbuff.h
index 7a914a4a7..e2482054c 100644
--- a/lib/zbuff.h
+++ b/lib/zbuff.h
@@ -31,11 +31,6 @@
 #ifndef ZSTD_BUFFERED_H
 #define ZSTD_BUFFERED_H
 
-/* The objects defined into this file should be considered experimental.
- * They are not considered stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
@@ -89,12 +84,12 @@ ZSTDLIB_API size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCap
 *  *srcSizePtr and *dstCapacityPtr can be any size.
 *  The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr.
 *  Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data.
-*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst .
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst .
 *  @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency)
 *            or an error code, which can be tested using ZBUFF_isError().
 *
 *  At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush().
-*  The nb of bytes written into @dst will be reported into *dstCapacityPtr.
+*  The nb of bytes written into `dst` will be reported into *dstCapacityPtr.
 *  Note that the function cannot output more than *dstCapacityPtr,
 *  therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small.
 *  @return : nb of bytes still present into internal buffer (0 if it's empty)
@@ -139,13 +134,13 @@ ZSTDLIB_API size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx,
 *  *srcSizePtr and *dstCapacityPtr can be any size.
 *  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
 *  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
-*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change @dst.
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
 *  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
 *            or 0 when a frame is completely decoded,
 *            or an error code, which can be tested using ZBUFF_isError().
 *
 *  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize()
-*  output : ZBUFF_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
+*  output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
 *  input  : ZBUFF_recommendedDInSize == 128KB + 3;
 *           just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
 * *******************************************************************************/
diff --git a/lib/zstd_compress.c b/lib/zstd_compress.c
index 3cec2778f..b25291228 100644
--- a/lib/zstd_compress.c
+++ b/lib/zstd_compress.c
@@ -208,7 +208,8 @@ size_t ZSTD_sizeofCCtx(ZSTD_compressionParameters cParams)   /* hidden interface
       return ccsize; }
 }
 
-
+/*! ZSTD_resetCCtx_advanced() :
+    note : 'params' is expected to be validated */
 static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,
                                        ZSTD_parameters params)
 {   /* note : params considered validated here */
@@ -1200,8 +1201,8 @@ static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx,
             hashTable[ZSTD_hashPtr(ip-2, hBits, mls)] = (U32)(ip-2-base);
             /* check immediate repcode */
             while (ip <= ilimit) {
-                U32 current2 = (U32)(ip-base);
-                const U32 repIndex2 = current2 - offset_2;
+                U32 const current2 = (U32)(ip-base);
+                U32 const repIndex2 = current2 - offset_2;
                 const BYTE* repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2;
                 if ( ((repIndex2 <= dictLimit-4) || (repIndex2 >= dictLimit))
                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
@@ -2233,18 +2234,12 @@ static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* zc, const void* dict, si
 }
 
 
-/*! ZSTD_compressBegin_advanced() :
+/*! ZSTD_compressBegin_internal() :
 *   @return : 0, or an error code */
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* zc,
+static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* zc,
                              const void* dict, size_t dictSize,
                                    ZSTD_parameters params, U64 pledgedSrcSize)
 {
-    /* compression parameters verification and optimization */
-    { size_t const errorCode = ZSTD_checkCParams_advanced(params.cParams, pledgedSrcSize);
-      if (ZSTD_isError(errorCode)) return errorCode; }
-
-    ZSTD_adjustCParams(&params.cParams, pledgedSrcSize, dictSize);
-
     { size_t const errorCode = ZSTD_resetCCtx_advanced(zc, params);
       if (ZSTD_isError(errorCode)) return errorCode; }
 
@@ -2272,13 +2267,28 @@ size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* zc,
 }
 
 
+/*! ZSTD_compressBegin_advanced() :
+*   @return : 0, or an error code */
+size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* zc,
+                             const void* dict, size_t dictSize,
+                                   ZSTD_parameters params, U64 pledgedSrcSize)
+{
+    /* compression parameters verification and optimization */
+    { size_t const errorCode = ZSTD_checkCParams_advanced(params.cParams, pledgedSrcSize);
+      if (ZSTD_isError(errorCode)) return errorCode; }
+
+    return ZSTD_compressBegin_internal(zc, dict, dictSize, params, pledgedSrcSize);
+}
+
+
 size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* zc, const void* dict, size_t dictSize, int compressionLevel)
 {
     ZSTD_parameters params;
     params.cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
     params.fParams.contentSizeFlag = 0;
+    ZSTD_adjustCParams(&params.cParams, 0, dictSize);
     ZSTD_LOG_BLOCK("%p: ZSTD_compressBegin_usingDict compressionLevel=%d\n", zc->base, compressionLevel);
-    return ZSTD_compressBegin_advanced(zc, dict, dictSize, params, 0);
+    return ZSTD_compressBegin_internal(zc, dict, dictSize, params, 0);
 }
 
 size_t ZSTD_compressBegin(ZSTD_CCtx* zc, int compressionLevel)
@@ -2342,7 +2352,7 @@ static size_t ZSTD_compress_internal (ZSTD_CCtx* ctx,
     BYTE* op = ostart;
 
     /* Init */
-    { size_t const errorCode = ZSTD_compressBegin_advanced(ctx, dict, dictSize, params, srcSize);
+    { size_t const errorCode = ZSTD_compressBegin_internal(ctx, dict, dictSize, params, srcSize);
       if(ZSTD_isError(errorCode)) return errorCode; }
 
     /* body (compression) */
diff --git a/programs/result b/programs/result
new file mode 100644
index 000000000..0d18ea646
--- /dev/null
+++ b/programs/result
@@ -0,0 +1,519 @@
+/*
+    bench.c - Demo module to benchmark open-source compression algorithms
+    Copyright (C) Yann Collet 2012-2015
+
+    GPL v2 License
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    You can contact the author at :
+    - zstd source repository : https://github.com/Cyan4973/zstd
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+/* **************************************
+*  Compiler Options
+****************************************/
+/* Disable some Visual warning messages */
+#ifdef _MSC_VER
+#  define _CRT_SECURE_NO_WARNINGS                /* fopen */
+#  pragma warning(disable : 4127)                /* disable: C4127: conditional expression is constant */
+#endif
+
+/* Unix Large Files support (>4GB) */
+#define _FILE_OFFSET_BITS 64
+#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
+#  define _LARGEFILE_SOURCE
+#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
+#  define _LARGEFILE64_SOURCE
+#endif
+
+
+/* *************************************
+*  Includes
+***************************************/
+#include <stdlib.h>      /* malloc, free */
+#include <string.h>      /* memset */
+#include <stdio.h>       /* fprintf, fopen, ftello64 */
+#include <sys/types.h>   /* stat64 */
+#include <sys/stat.h>    /* stat64 */
+#include <time.h>        /* clock_t, clock, CLOCKS_PER_SEC */
+
+/* sleep : posix - windows - others */
+#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
+#  include <unistd.h>         /* sleep */
+#  include <sys/resource.h>   /* setpriority */
+#  define BMK_sleep(s) sleep(s)
+#  define HIGH_PRIORITY setpriority(PRIO_PROCESS, 0, -20)
+#elif defined(_WIN32)
+#  include <windows.h>
+#  define BMK_sleep(s) Sleep(1000*s)
+#  define HIGH_PRIORITY SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
+#else
+#  define BMK_sleep(s)   /* disabled */
+#  define HIGH_PRIORITY
+#endif
+
+#include "mem.h"
+#include "zstd_static.h"
+#include "xxhash.h"
+#include "datagen.h"     /* RDG_genBuffer */
+
+
+/* *************************************
+*  Compiler specifics
+***************************************/
+#if !defined(S_ISREG)
+#  define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
+#endif
+
+#ifdef _MSC_VER
+#define snprintf sprintf_s
+#endif
+
+
+/* *************************************
+*  Constants
+***************************************/
+#define NBLOOPS          3
+#define TIMELOOP_S       1
+#define ACTIVEPERIOD_S  70
+#define COOLPERIOD_S    10
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+static const size_t maxMemory = (sizeof(size_t)==4)  ?  (2 GB - 64 MB) : (size_t)(1ULL << ((sizeof(size_t)*8)-31));
+#define DEFAULT_CHUNKSIZE   (4 MB)
+
+static U32 g_compressibilityDefault = 50;
+
+
+/* *************************************
+*  console display
+***************************************/
+#define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
+#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
+static U32 g_displayLevel = 2;   /* 0 : no display;   1: errors;   2 : + result + interaction + warnings;   3 : + progression;   4 : + information */
+
+
+/* *************************************
+*  Exceptions
+***************************************/
+#ifndef DEBUG
+#  define DEBUG 0
+#endif
+#define DEBUGOUTPUT(...) if (DEBUG) DISPLAY(__VA_ARGS__);
+#define EXM_THROW(error, ...)                                             \
+{                                                                         \
+    DEBUGOUTPUT("Error defined at %s, line %i : \n", __FILE__, __LINE__); \
+    DISPLAYLEVEL(1, "Error %i : ", error);                                \
+    DISPLAYLEVEL(1, __VA_ARGS__);                                         \
+    DISPLAYLEVEL(1, "\n");                                                \
+    exit(error);                                                          \
+}
+
+
+/* *************************************
+*  Benchmark Parameters
+***************************************/
+static U32 g_nbIterations = NBLOOPS;
+static size_t g_blockSize = 0;
+
+void BMK_SetNbIterations(unsigned nbLoops)
+{
+    g_nbIterations = nbLoops;
+    DISPLAY("- %i iterations -\n", g_nbIterations);
+}
+
+void BMK_SetBlockSize(size_t blockSize)
+{
+    g_blockSize = blockSize;
+    DISPLAY("using blocks of size %u KB \n", (U32)(blockSize>>10));
+}
+
+
+/* ********************************************************
+*  Private functions
+**********************************************************/
+static clock_t BMK_clockSpan( clock_t clockStart )
+{
+    return clock() - clockStart;   /* works even if overflow, span limited to <= ~30mn */
+}
+
+
+static U64 BMK_getFileSize(const char* infilename)
+{
+    int r;
+#if defined(_MSC_VER)
+    struct _stat64 statbuf;
+    r = _stat64(infilename, &statbuf);
+#else
+    struct stat statbuf;
+    r = stat(infilename, &statbuf);
+#endif
+    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
+    return (U64)statbuf.st_size;
+}
+
+
+/* ********************************************************
+*  Bench functions
+**********************************************************/
+typedef struct
+{
+    const char* srcPtr;
+    size_t srcSize;
+    char*  cPtr;
+    size_t cRoom;
+    size_t cSize;
+    char*  resPtr;
+    size_t resSize;
+} blockParam_t;
+
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
+
+static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
+                        const char* displayName, int cLevel,
+                        const size_t* fileSizes, U32 nbFiles,
+                        const void* dictBuffer, size_t dictBufferSize)
+{
+    size_t const blockSize = (g_blockSize ? g_blockSize : srcSize) + (!srcSize);   /* avoid div by 0 */
+    U32 const maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;
+    blockParam_t* const blockTable = (blockParam_t*) malloc(maxNbBlocks * sizeof(blockParam_t));
+    size_t const maxCompressedSize = ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);   /* add some room for safety */
+    void* const compressedBuffer = malloc(maxCompressedSize);
+    void* const resultBuffer = malloc(srcSize);
+    ZSTD_CCtx* refCtx = ZSTD_createCCtx();
+    ZSTD_CCtx* ctx = ZSTD_createCCtx();
+    ZSTD_DCtx* refDCtx = ZSTD_createDCtx();
+    ZSTD_DCtx* dctx = ZSTD_createDCtx();
+    U32 nbBlocks;
+
+    /* checks */
+    if (!compressedBuffer || !resultBuffer || !blockTable || !refCtx || !ctx || !refDCtx || !dctx)
+        EXM_THROW(31, "not enough memory");
+
+    /* init */
+    if (strlen(displayName)>17) displayName += strlen(displayName)-17;   /* can only display 17 characters */
+    HIGH_PRIORITY;
+
+    /* Init blockTable data */
+    {   const char* srcPtr = (const char*)srcBuffer;
+        char* cPtr = (char*)compressedBuffer;
+        char* resPtr = (char*)resultBuffer;
+        U32 fileNb;
+        for (nbBlocks=0, fileNb=0; fileNb<nbFiles; fileNb++) {
+            size_t remaining = fileSizes[fileNb];
+            U32 const nbBlocksforThisFile = (U32)((remaining + (blockSize-1)) / blockSize);
+            U32 const blockEnd = nbBlocks + nbBlocksforThisFile;
+            for ( ; nbBlocks<blockEnd; nbBlocks++) {
+                size_t const thisBlockSize = MIN(remaining, blockSize);
+                blockTable[nbBlocks].srcPtr = srcPtr;
+                blockTable[nbBlocks].cPtr = cPtr;
+                blockTable[nbBlocks].resPtr = resPtr;
+                blockTable[nbBlocks].srcSize = thisBlockSize;
+                blockTable[nbBlocks].cRoom = ZSTD_compressBound(thisBlockSize);
+                srcPtr += thisBlockSize;
+                cPtr += blockTable[nbBlocks].cRoom;
+                resPtr += thisBlockSize;
+                remaining -= thisBlockSize;
+    }   }   }
+
+    /* warmimg up memory */
+    RDG_genBuffer(compressedBuffer, maxCompressedSize, 0.10, 0.50, 1);
+
+    /* Bench */
+    {   double fastestC = 100000000., fastestD = 100000000.;
+        U64 const crcOrig = XXH64(srcBuffer, srcSize, 0);
+        clock_t coolTime = clock();
+        U32 testNb;
+
+        DISPLAY("\r%79s\r", "");
+        for (testNb = 1; testNb <= (g_nbIterations + !g_nbIterations); testNb++) {
+            size_t cSize;
+            double ratio = 0.;
+            clock_t clockStart;
+            clock_t const clockLoop = g_nbIterations ? TIMELOOP_S * CLOCKS_PER_SEC : 10;
+
+            /* overheat protection */
+            if (BMK_clockSpan(coolTime) > ACTIVEPERIOD_S * CLOCKS_PER_SEC) {
+                DISPLAY("\rcooling down ...    \r");
+                BMK_sleep(COOLPERIOD_S);
+                coolTime = clock();
+            }
+
+            /* Compression */
+            DISPLAY("%2i-%-17.17s :%10u ->\r", testNb, displayName, (U32)srcSize);
+            memset(compressedBuffer, 0xE5, maxCompressedSize);  /* warm up and erase result buffer */
+
+            clockStart = clock();
+            while (clock() == clockStart);
+            clockStart = clock();
+            {   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;
+            }   }
+
+            cSize = 0;
+            { U32 blockNb; for (blockNb=0; blockNb<nbBlocks; blockNb++) cSize += blockTable[blockNb].cSize; }
+            ratio = (double)srcSize / (double)cSize;
+            DISPLAY("%2i-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s\r",
+                    testNb, displayName, (U32)srcSize, (U32)cSize, ratio,
+                    (double)srcSize / 1000000. / (fastestC / CLOCKS_PER_SEC) );
+
+            (void)fastestD; (void)crcOrig;   /*  unused when decompression disabled */
+#if 1
+            /* Decompression */
+            memset(resultBuffer, 0xD6, srcSize);  /* warm result buffer */
+
+            clockStart = clock();
+            while (clock() == clockStart);
+            clockStart = clock();
+
+            {   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));
+                            clockStart -= clockLoop+1;   /* force immediate test end */
+                            break;
+                        }
+                        blockTable[blockNb].resSize = regenSize;
+                }   }
+                {   clock_t const 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 */
+            {   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;
+                        }
+                        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);
+    }   /* Bench */
+
+    /* clean up */
+    free(compressedBuffer);
+    free(resultBuffer);
+    ZSTD_freeCCtx(refCtx);
+    ZSTD_freeCCtx(ctx);
+    ZSTD_freeDCtx(refDCtx);
+    ZSTD_freeDCtx(dctx);
+    return 0;
+}
+
+
+static size_t BMK_findMaxMem(U64 requiredMem)
+{
+    size_t const step = 64 MB;
+    BYTE* testmem = NULL;
+
+    requiredMem = (((requiredMem >> 26) + 1) << 26);
+    requiredMem += step;
+    if (requiredMem > maxMemory) requiredMem = maxMemory;
+
+    do {
+        testmem = (BYTE*)malloc((size_t)requiredMem);
+        requiredMem -= step;
+    } while (!testmem);
+
+    free(testmem);
+    return (size_t)(requiredMem);
+}
+
+static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
+                            const char* displayName, int cLevel,
+                            const size_t* fileSizes, unsigned nbFiles,
+                            const void* dictBuffer, size_t dictBufferSize)
+{
+    if (cLevel < 0) {  /* range mode : test all levels from 1 to l */
+        int l;
+        for (l=1; l <= -cLevel; l++) {
+            BMK_benchMem(srcBuffer, benchedSize,
+                         displayName, l,
+                         fileSizes, nbFiles,
+                         dictBuffer, dictBufferSize);
+        }
+        return;
+    }
+    BMK_benchMem(srcBuffer, benchedSize,
+                 displayName, cLevel,
+                 fileSizes, nbFiles,
+                 dictBuffer, dictBufferSize);
+}
+
+static U64 BMK_getTotalFileSize(const char** fileNamesTable, unsigned nbFiles)
+{
+    U64 total = 0;
+    unsigned n;
+    for (n=0; n<nbFiles; n++)
+        total += BMK_getFileSize(fileNamesTable[n]);
+    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 nbFiles)
+{
+    size_t pos = 0;
+
+    unsigned n;
+    for (n=0; n<nbFiles; n++) {
+        U64 fileSize = BMK_getFileSize(fileNamesTable[n]);
+        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, 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);
+    }
+}
+
+static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
+                               const char* dictFileName, int cLevel)
+{
+    void* srcBuffer;
+    size_t benchedSize;
+    void* dictBuffer = NULL;
+    size_t dictBufferSize = 0;
+    size_t* fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
+    U64 totalSizeToLoad = BMK_getTotalFileSize(fileNamesTable, nbFiles);
+    char mfName[20] = {0};
+    const char* displayName = NULL;
+
+    if (!fileSizes) EXM_THROW(12, "not enough memory for fileSizes");
+
+    /* Load dictionary */
+    if (dictFileName != NULL) {
+        U64 dictFileSize = BMK_getFileSize(dictFileName);
+        if (dictFileSize > 64 MB) EXM_THROW(10, "dictionary file %s too large", dictFileName);
+        dictBufferSize = (size_t)dictFileSize;
+        dictBuffer = malloc(dictBufferSize);
+        if (dictBuffer==NULL) EXM_THROW(11, "not enough memory for dictionary (%u bytes)", (U32)dictBufferSize);
+        BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1);
+    }
+
+    /* Memory allocation & restrictions */
+    benchedSize = BMK_findMaxMem(totalSizeToLoad * 3) / 3;
+    if ((U64)benchedSize > totalSizeToLoad) benchedSize = (size_t)totalSizeToLoad;
+    if (benchedSize < totalSizeToLoad)
+        DISPLAY("Not enough memory; testing %u MB only...\n", (U32)(benchedSize >> 20));
+    srcBuffer = malloc(benchedSize);
+    if (!srcBuffer) EXM_THROW(12, "not enough memory");
+
+    /* Load input buffer */
+    BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles);
+
+    /* Bench */
+    snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
+    if (nbFiles > 1) displayName = mfName;
+    else displayName = fileNamesTable[0];
+
+    BMK_benchCLevel(srcBuffer, benchedSize,
+                    displayName, cLevel,
+                    fileSizes, nbFiles,
+                    dictBuffer, dictBufferSize);
+
+    /* clean up */
+    free(srcBuffer);
+    free(dictBuffer);
+    free(fileSizes);
+}
+
+
+static void BMK_syntheticTest(int cLevel, double compressibility)
+{
+    char name[20] = {0};
+    size_t benchedSize = 10000000;
+    void* srcBuffer = malloc(benchedSize);
+
+    /* Memory allocation */
+    if (!srcBuffer) EXM_THROW(21, "not enough memory");
+
+    /* Fill input buffer */
+    RDG_genBuffer(srcBuffer, benchedSize, compressibility, 0.0, 0);
+
+    /* Bench */
+    snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
+    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, &benchedSize, 1, NULL, 0);
+
+    /* clean up */
+    free(srcBuffer);
+}
+
+
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
+                   const char* dictFileName, int cLevel)
+{
+    double const compressibility = (double)g_compressibilityDefault / 100;
+
+    if (nbFiles == 0)
+        BMK_syntheticTest(cLevel, compressibility);
+    else
+        BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel);
+    return 0;
+}
+
diff --git a/programs/tmp.mgz b/programs/tmp.mgz
new file mode 100644
index 0000000000000000000000000000000000000000..165a506f973944c12a4a4dbf42d17b733097f1d8
GIT binary patch
literal 5549
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

literal 0
HcmV?d00001

diff --git a/programs/tmp.zstd b/programs/tmp.zstd
new file mode 100644
index 0000000000000000000000000000000000000000..6f0296f66bdaf65851b97f0f417482e182131ac2
GIT binary patch
literal 6317
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
IA7Eer07CsVBme*a

literal 0
HcmV?d00001

diff --git a/programs/zbufftest.c b/programs/zbufftest.c
index aa57b576a..fd18c9e59 100644
--- a/programs/zbufftest.c
+++ b/programs/zbufftest.c
@@ -1,6 +1,6 @@
 /*
     Fuzzer test tool for zstd_buffered
-    Copyright (C) Yann Collet 2105
+    Copyright (C) Yann Collet 2015-2016
 
     GPL v2 License
 
@@ -19,11 +19,10 @@
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
     You can contact the author at :
-    - ZSTD source repository : https://github.com/Cyan4973/zstd
-    - ZSTD public forum : https://groups.google.com/forum/#!forum/lz4c
+    - ZSTD homepage : https://www.zstd.net/
 */
 
-/**************************************
+/*-************************************
 *  Compiler specific
 **************************************/
 #ifdef _MSC_VER    /* Visual Studio */
@@ -33,7 +32,7 @@
 #endif
 
 
-/**************************************
+/*-************************************
 *  Includes
 **************************************/
 #include <stdlib.h>      /* free */
@@ -47,8 +46,8 @@
 #include "xxhash.h"      /* XXH64 */
 
 
-/**************************************
- Constants
+/*-************************************
+*  Constants
 **************************************/
 #ifndef ZSTD_VERSION
 #  define ZSTD_VERSION ""
@@ -66,7 +65,7 @@ static const U32 prime2 = 2246822519U;
 
 
 
-/**************************************
+/*-************************************
 *  Display Macros
 **************************************/
 #define DISPLAY(...)          fprintf(stderr, __VA_ARGS__)
@@ -83,7 +82,7 @@ static U32 g_displayTime = 0;
 static U32 g_testTime = 0;
 
 
-/*********************************************************
+/*-*******************************************************
 *  Fuzzer functions
 *********************************************************/
 #define MAX(a,b) ((a)>(b)?(a):(b))
@@ -149,8 +148,7 @@ static int basicUnitTests(U32 seed, double compressibility)
     CNBuffer = malloc(CNBufferSize);
     compressedBuffer = malloc(compressedBufferSize);
     decodedBuffer = malloc(decodedBufferSize);
-    if (!CNBuffer || !compressedBuffer || !decodedBuffer || !zc || !zd)
-    {
+    if (!CNBuffer || !compressedBuffer || !decodedBuffer || !zc || !zd) {
         DISPLAY("Not enough memory, aborting\n");
         goto _output_error;
     }
@@ -183,11 +181,9 @@ static int basicUnitTests(U32 seed, double compressibility)
     DISPLAYLEVEL(4, "OK \n");
 
     /* check regenerated data is byte exact */
-    {
-        size_t i;
+    {   size_t i;
         DISPLAYLEVEL(4, "test%3i : check decompressed result : ", testNb++);
-        for (i=0; i<CNBufferSize; i++)
-        {
+        for (i=0; i<CNBufferSize; i++) {
             if (((BYTE*)decodedBuffer)[i] != ((BYTE*)CNBuffer)[i]) goto _output_error;;
         }
         DISPLAYLEVEL(4, "OK \n");
@@ -213,8 +209,7 @@ static size_t findDiff(const void* buf1, const void* buf2, size_t max)
     const BYTE* b1 = (const BYTE*)buf1;
     const BYTE* b2 = (const BYTE*)buf2;
     size_t i;
-    for (i=0; i<max; i++)
-    {
+    for (i=0; i<max; i++) {
         if (b1[i] != b2[i]) break;
     }
     return i;
@@ -228,7 +223,7 @@ static size_t findDiff(const void* buf1, const void* buf2, size_t max)
 static const U32 maxSrcLog = 24;
 static const U32 maxSampleLog = 19;
 
-int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibility)
+static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibility)
 {
     BYTE* cNoiseBuffer[5];
     BYTE* srcBuffer;
@@ -276,8 +271,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         FUZ_rand(&coreSeed);
 
     /* test loop */
-    for ( ; (testNb <= nbTests) || (FUZ_GetMilliSpan(startTime) < g_testTime); testNb++ )
-    {
+    for ( ; (testNb <= nbTests) || (FUZ_GetMilliSpan(startTime) < g_testTime); testNb++ ) {
         size_t sampleSize, sampleStart;
         const BYTE* dict;
         size_t cSize, dictSize;
@@ -294,20 +288,15 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         lseed = coreSeed ^ prime1;
         buffNb = FUZ_rand(&lseed) & 127;
         if (buffNb & 7) buffNb=2;   /* select buffer */
-        else
-        {
+        else {
             buffNb >>= 3;
-            if (buffNb & 7)
-            {
+            if (buffNb & 7) {
                 const U32 tnb[2] = { 1, 3 };
                 buffNb = tnb[buffNb >> 3];
-            }
-            else
-            {
+            } else {
                 const U32 tnb[2] = { 0, 4 };
                 buffNb = tnb[buffNb >> 3];
-            }
-        }
+        }   }
         srcBuffer = cNoiseBuffer[buffNb];
 
         /* Multi - segments compression test */
@@ -327,8 +316,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
 
         totalTestSize = 0;
         cSize = 0;
-        for (n=0; n<nbChunks; n++)
-        {
+        for (n=0; n<nbChunks; n++) {
             sampleSizeLog = FUZ_rand(&lseed) % maxSampleLog;
             sampleSize = (size_t)1 << sampleSizeLog;
             sampleSize += FUZ_rand(&lseed) & (sampleSize-1);
@@ -349,8 +337,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
             cSize += genSize;
             totalTestSize += readSize;
 
-            if ((FUZ_rand(&lseed) & 15) == 0)
-            {
+            if ((FUZ_rand(&lseed) & 15) == 0) {
                 /* add a few random flushes operations, to mess around */
                 sampleSizeLog = FUZ_rand(&lseed) % maxSampleLog;
                 sampleSize = (size_t)1 << sampleSizeLog;
@@ -374,8 +361,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         ZBUFF_decompressInitDictionary(zd, dict, dictSize);
         totalCSize = 0;
         totalGenSize = 0;
-        while (totalCSize < cSize)
-        {
+        while (totalCSize < cSize) {
             sampleSizeLog  = FUZ_rand(&lseed) % maxSampleLog;
             sampleSize  = (size_t)1 << sampleSizeLog;
             sampleSize += FUZ_rand(&lseed) & (sampleSize-1);
@@ -399,8 +385,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         /* noisy/erroneous src decompression test */
         /* add some noise */
         nbChunks = (FUZ_rand(&lseed) & 7) + 2;
-        for (n=0; n<nbChunks; n++)
-        {
+        for (n=0; n<nbChunks; n++) {
             size_t cStart;
 
             sampleSizeLog = FUZ_rand(&lseed) % maxSampleLog;
@@ -417,8 +402,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
         ZBUFF_decompressInit(zd);
         totalCSize = 0;
         totalGenSize = 0;
-        while ( (totalCSize < cSize) && (totalGenSize < dstBufferSize) )
-        {
+        while ( (totalCSize < cSize) && (totalGenSize < dstBufferSize) ) {
             sampleSizeLog  = FUZ_rand(&lseed) % maxSampleLog;
             sampleSize  = (size_t)1 << sampleSizeLog;
             sampleSize += FUZ_rand(&lseed) & (sampleSize-1);
@@ -431,8 +415,7 @@ int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibilit
             if (ZBUFF_isError(errorCode)) break;   /* error correctly detected */
             totalGenSize += genSize;
             totalCSize += readSize;
-        }
-    }
+    }   }
     DISPLAY("\r%u fuzzer tests completed   \n", testNb);
 
 _cleanup:
@@ -454,7 +437,7 @@ _output_error:
 }
 
 
-/*********************************************************
+/*-*******************************************************
 *  Command line
 *********************************************************/
 int FUZ_usage(char* programName)
@@ -488,19 +471,16 @@ int main(int argc, char** argv)
 
     /* Check command line */
     programName = argv[0];
-    for(argNb=1; argNb<argc; argNb++)
-    {
+    for(argNb=1; argNb<argc; argNb++) {
         char* argument = argv[argNb];
 
         if(!argument) continue;   /* Protection if argument empty */
 
         /* Handle commands. Aggregated commands are allowed */
-        if (argument[0]=='-')
-        {
+        if (argument[0]=='-') {
             argument++;
 
-            while (*argument!=0)
-            {
+            while (*argument!=0) {
                 switch(*argument)
                 {
                 case 'h':
@@ -521,8 +501,7 @@ int main(int argc, char** argv)
                 case 'i':
                     argument++;
                     nbTests=0; g_testTime=0;
-                    while ((*argument>='0') && (*argument<='9'))
-                    {
+                    while ((*argument>='0') && (*argument<='9')) {
                         nbTests *= 10;
                         nbTests += *argument - '0';
                         argument++;
@@ -532,8 +511,7 @@ int main(int argc, char** argv)
                 case 'T':
                     argument++;
                     nbTests=0; g_testTime=0;
-                    while ((*argument>='0') && (*argument<='9'))
-                    {
+                    while ((*argument>='0') && (*argument<='9')) {
                         g_testTime *= 10;
                         g_testTime += *argument - '0';
                         argument++;
@@ -547,8 +525,7 @@ int main(int argc, char** argv)
                     argument++;
                     seed=0;
                     seedset=1;
-                    while ((*argument>='0') && (*argument<='9'))
-                    {
+                    while ((*argument>='0') && (*argument<='9')) {
                         seed *= 10;
                         seed += *argument - '0';
                         argument++;
@@ -558,8 +535,7 @@ int main(int argc, char** argv)
                 case 't':
                     argument++;
                     testNb=0;
-                    while ((*argument>='0') && (*argument<='9'))
-                    {
+                    while ((*argument>='0') && (*argument<='9')) {
                         testNb *= 10;
                         testNb += *argument - '0';
                         argument++;
@@ -569,8 +545,7 @@ int main(int argc, char** argv)
                 case 'P':   /* compressibility % */
                     argument++;
                     proba=0;
-                    while ((*argument>='0') && (*argument<='9'))
-                    {
+                    while ((*argument>='0') && (*argument<='9')) {
                         proba *= 10;
                         proba += *argument - '0';
                         argument++;
@@ -582,9 +557,7 @@ int main(int argc, char** argv)
                 default:
                     return FUZ_usage(programName);
                 }
-            }
-        }
-    }
+    }   }   }
 
     /* Get Seed */
     DISPLAY("Starting zstd_buffered tester (%i-bits, %s)\n", (int)(sizeof(size_t)*8), ZSTD_VERSION);
@@ -598,8 +571,8 @@ int main(int argc, char** argv)
     if (testNb==0) result = basicUnitTests(0, ((double)proba) / 100);  /* constant seed for predictability */
     if (!result)
         result = fuzzerTests(seed, nbTests, testNb, ((double)proba) / 100);
-    if (mainPause)
-    {
+
+    if (mainPause) {
         int unused;
         DISPLAY("Press Enter \n");
         unused = getchar();