contrib/zstd/programs/bench.c

   1 /*
   2  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under both the BSD-style license (found in the
   6  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
   7  * in the COPYING file in the root directory of this source tree).
   8  */
   9
  10
  11
  12 /* **************************************
  13 *  Tuning parameters
  14 ****************************************/
  15 #ifndef BMK_TIMETEST_DEFAULT_S   /* default minimum time per test */
  16 #define BMK_TIMETEST_DEFAULT_S 3
  17 #endif
  18
  19
  20 /* **************************************
  21 *  Compiler Warnings
  22 ****************************************/
  23 #ifdef _MSC_VER
  24 #  pragma warning(disable : 4127)                /* disable: C4127: conditional expression is constant */
  25 #endif
  26
  27
  28 /* *************************************
  29 *  Includes
  30 ***************************************/
  31 #include "platform.h"    /* Large Files support */
  32 #include "util.h"        /* UTIL_getFileSize, UTIL_sleep */
  33 #include <stdlib.h>      /* malloc, free */
  34 #include <string.h>      /* memset */
  35 #include <stdio.h>       /* fprintf, fopen */
  36 #include <time.h>        /* clock_t, clock, CLOCKS_PER_SEC */
  37
  38 #include "mem.h"
  39 #define ZSTD_STATIC_LINKING_ONLY
  40 #include "zstd.h"
  41 #include "datagen.h"     /* RDG_genBuffer */
  42 #include "xxhash.h"
  43 #include "zstdmt_compress.h"
  44
  45
  46 /* *************************************
  47 *  Constants
  48 ***************************************/
  49 #ifndef ZSTD_GIT_COMMIT
  50 #  define ZSTD_GIT_COMMIT_STRING ""
  51 #else
  52 #  define ZSTD_GIT_COMMIT_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_GIT_COMMIT)
  53 #endif
  54
  55 #define TIMELOOP_MICROSEC     1*1000000ULL /* 1 second */
  56 #define ACTIVEPERIOD_MICROSEC 70*1000000ULL /* 70 seconds */
  57 #define COOLPERIOD_SEC        10
  58
  59 #define KB *(1 <<10)
  60 #define MB *(1 <<20)
  61 #define GB *(1U<<30)
  62
  63 static const size_t maxMemory = (sizeof(size_t)==4)  ?  (2 GB - 64 MB) : (size_t)(1ULL << ((sizeof(size_t)*8)-31));
  64
  65 static U32 g_compressibilityDefault = 50;
  66
  67
  68 /* *************************************
  69 *  console display
  70 ***************************************/
  71 #define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
  72 #define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
  73 static int g_displayLevel = 2;   /* 0 : no display;   1: errors;   2 : + result + interaction + warnings;   3 : + progression;   4 : + information */
  74
  75 #define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
  76             if ((clock() - g_time > refreshRate) || (g_displayLevel>=4)) \
  77             { g_time = clock(); DISPLAY(__VA_ARGS__); \
  78             if (g_displayLevel>=4) fflush(stderr); } }
  79 static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;
  80 static clock_t g_time = 0;
  81
  82
  83 /* *************************************
  84 *  Exceptions
  85 ***************************************/
  86 #ifndef DEBUG
  87 #  define DEBUG 0
  88 #endif
  89 #define DEBUGOUTPUT(...) { if (DEBUG) DISPLAY(__VA_ARGS__); }
  90 #define EXM_THROW(error, ...)  {                      \
  91     DEBUGOUTPUT("%s: %i: \n", __FILE__, __LINE__);    \
  92     DISPLAYLEVEL(1, "Error %i : ", error);            \
  93     DISPLAYLEVEL(1, __VA_ARGS__);                     \
  94     DISPLAYLEVEL(1, " \n");                           \
  95     exit(error);                                      \
  96 }
  97
  98
  99 /* *************************************
 100 *  Benchmark Parameters
 101 ***************************************/
 102 static int g_additionalParam = 0;
 103 static U32 g_decodeOnly = 0;
 104
 105 void BMK_setNotificationLevel(unsigned level) { g_displayLevel=level; }
 106
 107 void BMK_setAdditionalParam(int additionalParam) { g_additionalParam=additionalParam; }
 108
 109 static U32 g_nbSeconds = BMK_TIMETEST_DEFAULT_S;
 110 void BMK_setNbSeconds(unsigned nbSeconds)
 111 {
 112     g_nbSeconds = nbSeconds;
 113     DISPLAYLEVEL(3, "- test >= %u seconds per compression / decompression - \n", g_nbSeconds);
 114 }
 115
 116 static size_t g_blockSize = 0;
 117 void BMK_setBlockSize(size_t blockSize)
 118 {
 119     g_blockSize = blockSize;
 120     if (g_blockSize) DISPLAYLEVEL(2, "using blocks of size %u KB \n", (U32)(blockSize>>10));
 121 }
 122
 123 void BMK_setDecodeOnlyMode(unsigned decodeFlag) { g_decodeOnly = (decodeFlag>0); }
 124
 125 static U32 g_nbThreads = 1;
 126 void BMK_setNbThreads(unsigned nbThreads) {
 127 #ifndef ZSTD_MULTITHREAD
 128     if (nbThreads > 1) DISPLAYLEVEL(2, "Note : multi-threading is disabled \n");
 129 #endif
 130     g_nbThreads = nbThreads;
 131 }
 132
 133
 134 /* ********************************************************
 135 *  Bench functions
 136 **********************************************************/
 137 typedef struct {
 138     const void* srcPtr;
 139     size_t srcSize;
 140     void*  cPtr;
 141     size_t cRoom;
 142     size_t cSize;
 143     void*  resPtr;
 144     size_t resSize;
 145 } blockParam_t;
 146
 147
 148
 149 #undef MIN
 150 #undef MAX
 151 #define MIN(a,b)    ((a) < (b) ? (a) : (b))
 152 #define MAX(a,b)    ((a) > (b) ? (a) : (b))
 153
 154 static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
 155                         const char* displayName, int cLevel,
 156                         const size_t* fileSizes, U32 nbFiles,
 157                         const void* dictBuffer, size_t dictBufferSize,
 158                         const ZSTD_compressionParameters* comprParams)
 159 {
 160     size_t const blockSize = ((g_blockSize>=32 && !g_decodeOnly) ? g_blockSize : srcSize) + (!srcSize) /* avoid div by 0 */ ;
 161     U32 const maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;
 162     blockParam_t* const blockTable = (blockParam_t*) malloc(maxNbBlocks * sizeof(blockParam_t));
 163     size_t const maxCompressedSize = ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);   /* add some room for safety */
 164     void* const compressedBuffer = malloc(maxCompressedSize);
 165     void* resultBuffer = malloc(srcSize);
 166     ZSTDMT_CCtx* const mtctx = ZSTDMT_createCCtx(g_nbThreads);
 167     ZSTD_CCtx* const ctx = ZSTD_createCCtx();
 168     ZSTD_DCtx* const dctx = ZSTD_createDCtx();
 169     size_t const loadedCompressedSize = srcSize;
 170     size_t cSize = 0;
 171     double ratio = 0.;
 172     U32 nbBlocks;
 173     UTIL_freq_t ticksPerSecond;
 174
 175     /* checks */
 176     if (!compressedBuffer || !resultBuffer || !blockTable || !ctx || !dctx)
 177         EXM_THROW(31, "allocation error : not enough memory");
 178
 179     /* init */
 180     if (strlen(displayName)>17) displayName += strlen(displayName)-17;   /* display last 17 characters */
 181     UTIL_initTimer(&ticksPerSecond);
 182
 183     if (g_decodeOnly) {  /* benchmark only decompression : source must be already compressed */
 184         const char* srcPtr = (const char*)srcBuffer;
 185         U64 totalDSize64 = 0;
 186         U32 fileNb;
 187         for (fileNb=0; fileNb<nbFiles; fileNb++) {
 188             U64 const fSize64 = ZSTD_findDecompressedSize(srcPtr, fileSizes[fileNb]);
 189             if (fSize64==0) EXM_THROW(32, "Impossible to determine original size ");
 190             totalDSize64 += fSize64;
 191             srcPtr += fileSizes[fileNb];
 192         }
 193         {   size_t const decodedSize = (size_t)totalDSize64;
 194             if (totalDSize64 > decodedSize) EXM_THROW(32, "original size is too large");   /* size_t overflow */
 195             free(resultBuffer);
 196             resultBuffer = malloc(decodedSize);
 197             if (!resultBuffer) EXM_THROW(33, "not enough memory");
 198             cSize = srcSize;
 199             srcSize = decodedSize;
 200             ratio = (double)srcSize / (double)cSize;
 201     }   }
 202
 203     /* Init blockTable data */
 204     {   const char* srcPtr = (const char*)srcBuffer;
 205         char* cPtr = (char*)compressedBuffer;
 206         char* resPtr = (char*)resultBuffer;
 207         U32 fileNb;
 208         for (nbBlocks=0, fileNb=0; fileNb<nbFiles; fileNb++) {
 209             size_t remaining = fileSizes[fileNb];
 210             U32 const nbBlocksforThisFile = g_decodeOnly ? 1 : (U32)((remaining + (blockSize-1)) / blockSize);
 211             U32 const blockEnd = nbBlocks + nbBlocksforThisFile;
 212             for ( ; nbBlocks<blockEnd; nbBlocks++) {
 213                 size_t const thisBlockSize = MIN(remaining, blockSize);
 214                 blockTable[nbBlocks].srcPtr = (const void*)srcPtr;
 215                 blockTable[nbBlocks].srcSize = thisBlockSize;
 216                 blockTable[nbBlocks].cPtr = (void*)cPtr;
 217                 blockTable[nbBlocks].cRoom = g_decodeOnly ? thisBlockSize : ZSTD_compressBound(thisBlockSize);
 218                 blockTable[nbBlocks].cSize = blockTable[nbBlocks].cRoom;
 219                 blockTable[nbBlocks].resPtr = (void*)resPtr;
 220                 blockTable[nbBlocks].resSize = g_decodeOnly ? (size_t) ZSTD_findDecompressedSize(srcPtr, thisBlockSize) : thisBlockSize;
 221                 srcPtr += thisBlockSize;
 222                 cPtr += blockTable[nbBlocks].cRoom;
 223                 resPtr += thisBlockSize;
 224                 remaining -= thisBlockSize;
 225     }   }   }
 226
 227     /* warmimg up memory */
 228     RDG_genBuffer(compressedBuffer, maxCompressedSize, 0.10, 0.50, 1);
 229
 230     /* Bench */
 231     {   U64 fastestC = (U64)(-1LL), fastestD = (U64)(-1LL);
 232         U64 const crcOrig = g_decodeOnly ? 0 : XXH64(srcBuffer, srcSize, 0);
 233         UTIL_time_t coolTime;
 234         U64 const maxTime = (g_nbSeconds * TIMELOOP_MICROSEC) + 1;
 235         U64 totalCTime=0, totalDTime=0;
 236         U32 cCompleted=g_decodeOnly, dCompleted=0;
 237 #       define NB_MARKS 4
 238         const char* const marks[NB_MARKS] = { " |", " /", " =",  "\\" };
 239         U32 markNb = 0;
 240
 241         UTIL_getTime(&coolTime);
 242         DISPLAYLEVEL(2, "\r%79s\r", "");
 243         while (!cCompleted || !dCompleted) {
 244
 245             /* overheat protection */
 246             if (UTIL_clockSpanMicro(coolTime, ticksPerSecond) > ACTIVEPERIOD_MICROSEC) {
 247                 DISPLAYLEVEL(2, "\rcooling down ...    \r");
 248                 UTIL_sleep(COOLPERIOD_SEC);
 249                 UTIL_getTime(&coolTime);
 250             }
 251
 252             if (!g_decodeOnly) {
 253                 UTIL_time_t clockStart;
 254                 /* Compression */
 255                 DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->\r", marks[markNb], displayName, (U32)srcSize);
 256                 if (!cCompleted) memset(compressedBuffer, 0xE5, maxCompressedSize);  /* warm up and erase result buffer */
 257
 258                 UTIL_sleepMilli(1);  /* give processor time to other processes */
 259                 UTIL_waitForNextTick(ticksPerSecond);
 260                 UTIL_getTime(&clockStart);
 261
 262                 if (!cCompleted) {   /* still some time to do compression tests */
 263                     U64 const clockLoop = g_nbSeconds ? TIMELOOP_MICROSEC : 1;
 264                     U32 nbLoops = 0;
 265                     ZSTD_CDict* cdict = NULL;
 266 #ifdef ZSTD_NEWAPI
 267                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_nbThreads, g_nbThreads);
 268                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionLevel, cLevel);
 269                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_windowLog, comprParams->windowLog);
 270                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_chainLog, comprParams->chainLog);
 271                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_searchLog, comprParams->searchLog);
 272                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_minMatch, comprParams->searchLength);
 273                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_targetLength, comprParams->targetLength);
 274                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionStrategy, comprParams->strategy);
 275                     ZSTD_CCtx_loadDictionary(ctx, dictBuffer, dictBufferSize);
 276 #else
 277                     size_t const avgSize = MIN(blockSize, (srcSize / nbFiles));
 278                     ZSTD_parameters zparams = ZSTD_getParams(cLevel, avgSize, dictBufferSize);
 279                     ZSTD_customMem const cmem = { NULL, NULL, NULL };
 280                     if (comprParams->windowLog) zparams.cParams.windowLog = comprParams->windowLog;
 281                     if (comprParams->chainLog) zparams.cParams.chainLog = comprParams->chainLog;
 282                     if (comprParams->hashLog) zparams.cParams.hashLog = comprParams->hashLog;
 283                     if (comprParams->searchLog) zparams.cParams.searchLog = comprParams->searchLog;
 284                     if (comprParams->searchLength) zparams.cParams.searchLength = comprParams->searchLength;
 285                     if (comprParams->targetLength) zparams.cParams.targetLength = comprParams->targetLength;
 286                     if (comprParams->strategy) zparams.cParams.strategy = comprParams->strategy;
 287                     cdict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, 1 /*byRef*/, ZSTD_dm_auto, zparams.cParams, cmem);
 288                     if (cdict==NULL) EXM_THROW(1, "ZSTD_createCDict_advanced() allocation failure");
 289 #endif
 290                     do {
 291                         U32 blockNb;
 292                         for (blockNb=0; blockNb<nbBlocks; blockNb++) {
 293                             size_t rSize;
 294 #ifdef ZSTD_NEWAPI
 295                             ZSTD_outBuffer out = { blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom, 0 };
 296                             ZSTD_inBuffer in = { blockTable[blockNb].srcPtr,  blockTable[blockNb].srcSize, 0 };
 297                             size_t cError = 1;
 298                             while (cError) {
 299                                 cError = ZSTD_compress_generic(ctx,
 300                                                     &out, &in, ZSTD_e_end);
 301                                 if (ZSTD_isError(cError))
 302                                     EXM_THROW(1, "ZSTD_compress_generic() error : %s",
 303                                                 ZSTD_getErrorName(cError));
 304                             }
 305                             rSize = out.pos;
 306 #else  /* ! ZSTD_NEWAPI */
 307                             if (dictBufferSize) {
 308                                 rSize = ZSTD_compress_usingCDict(ctx,
 309                                                 blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
 310                                                 blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
 311                                                 cdict);
 312                             } else {
 313 #  ifdef ZSTD_MULTITHREAD       /* note : limitation : MT single-pass does not support compression with dictionary */
 314                                 rSize = ZSTDMT_compressCCtx(mtctx,
 315                                                 blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
 316                                                 blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
 317                                                 cLevel);
 318 #  else
 319                                 rSize = ZSTD_compress_advanced (ctx,
 320                                                 blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
 321                                                 blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
 322                                                 NULL, 0, zparams);
 323 #  endif
 324                             }
 325                             if (ZSTD_isError(rSize))
 326                                 EXM_THROW(1, "ZSTD_compress_usingCDict() failed : %s",
 327                                             ZSTD_getErrorName(rSize));
 328 #endif  /* ZSTD_NEWAPI */
 329                             blockTable[blockNb].cSize = rSize;
 330                         }
 331                         nbLoops++;
 332                     } while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
 333                     ZSTD_freeCDict(cdict);
 334                     {   U64 const clockSpanMicro = UTIL_clockSpanMicro(clockStart, ticksPerSecond);
 335                         if (clockSpanMicro < fastestC*nbLoops) fastestC = clockSpanMicro / nbLoops;
 336                         totalCTime += clockSpanMicro;
 337                         cCompleted = (totalCTime >= maxTime);
 338                 }   }
 339
 340                 cSize = 0;
 341                 { U32 blockNb; for (blockNb=0; blockNb<nbBlocks; blockNb++) cSize += blockTable[blockNb].cSize; }
 342                 ratio = (double)srcSize / (double)cSize;
 343                 markNb = (markNb+1) % NB_MARKS;
 344                 DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s\r",
 345                         marks[markNb], displayName, (U32)srcSize, (U32)cSize, ratio,
 346                         (double)srcSize / fastestC );
 347             } else {   /* g_decodeOnly */
 348                 memcpy(compressedBuffer, srcBuffer, loadedCompressedSize);
 349             }
 350
 351 #if 0       /* disable decompression test */
 352             dCompleted=1;
 353             (void)totalDTime; (void)fastestD; (void)crcOrig;   /*  unused when decompression disabled */
 354 #else
 355             /* Decompression */
 356             if (!dCompleted) memset(resultBuffer, 0xD6, srcSize);  /* warm result buffer */
 357
 358             UTIL_sleepMilli(1); /* give processor time to other processes */
 359             UTIL_waitForNextTick(ticksPerSecond);
 360
 361             if (!dCompleted) {
 362                 U64 clockLoop = g_nbSeconds ? TIMELOOP_MICROSEC : 1;
 363                 U32 nbLoops = 0;
 364                 UTIL_time_t clockStart;
 365                 ZSTD_DDict* const ddict = ZSTD_createDDict(dictBuffer, dictBufferSize);
 366                 if (!ddict) EXM_THROW(2, "ZSTD_createDDict() allocation failure");
 367                 UTIL_getTime(&clockStart);
 368                 do {
 369                     U32 blockNb;
 370                     for (blockNb=0; blockNb<nbBlocks; blockNb++) {
 371                         size_t const regenSize = ZSTD_decompress_usingDDict(dctx,
 372                             blockTable[blockNb].resPtr, blockTable[blockNb].resSize,
 373                             blockTable[blockNb].cPtr, blockTable[blockNb].cSize,
 374                             ddict);
 375                         if (ZSTD_isError(regenSize)) {
 376                             DISPLAY("ZSTD_decompress_usingDDict() failed on block %u of size %u : %s  \n",
 377                                       blockNb, (U32)blockTable[blockNb].cSize, ZSTD_getErrorName(regenSize));
 378                             clockLoop = 0;   /* force immediate test end */
 379                             break;
 380                         }
 381                         blockTable[blockNb].resSize = regenSize;
 382                     }
 383                     nbLoops++;
 384                 } while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
 385                 ZSTD_freeDDict(ddict);
 386                 {   U64 const clockSpanMicro = UTIL_clockSpanMicro(clockStart, ticksPerSecond);
 387                     if (clockSpanMicro < fastestD*nbLoops) fastestD = clockSpanMicro / nbLoops;
 388                     totalDTime += clockSpanMicro;
 389                     dCompleted = (totalDTime >= maxTime);
 390             }   }
 391
 392             markNb = (markNb+1) % NB_MARKS;
 393             DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s ,%6.1f MB/s\r",
 394                     marks[markNb], displayName, (U32)srcSize, (U32)cSize, ratio,
 395                     (double)srcSize / fastestC,
 396                     (double)srcSize / fastestD );
 397
 398             /* CRC Checking */
 399             {   U64 const crcCheck = XXH64(resultBuffer, srcSize, 0);
 400                 if (!g_decodeOnly && (crcOrig!=crcCheck)) {
 401                     size_t u;
 402                     DISPLAY("!!! WARNING !!! %14s : Invalid Checksum : %x != %x   \n", displayName, (unsigned)crcOrig, (unsigned)crcCheck);
 403                     for (u=0; u<srcSize; u++) {
 404                         if (((const BYTE*)srcBuffer)[u] != ((const BYTE*)resultBuffer)[u]) {
 405                             U32 segNb, bNb, pos;
 406                             size_t bacc = 0;
 407                             DISPLAY("Decoding error at pos %u ", (U32)u);
 408                             for (segNb = 0; segNb < nbBlocks; segNb++) {
 409                                 if (bacc + blockTable[segNb].srcSize > u) break;
 410                                 bacc += blockTable[segNb].srcSize;
 411                             }
 412                             pos = (U32)(u - bacc);
 413                             bNb = pos / (128 KB);
 414                             DISPLAY("(sample %u, block %u, pos %u) \n", segNb, bNb, pos);
 415                             if (u>5) {
 416                                 int n;
 417                                 for (n=-5; n<0; n++) DISPLAY("%02X ", ((const BYTE*)srcBuffer)[u+n]);
 418                                 DISPLAY(" :%02X:  ", ((const BYTE*)srcBuffer)[u]);
 419                                 for (n=1; n<3; n++) DISPLAY("%02X ", ((const BYTE*)srcBuffer)[u+n]);
 420                                 DISPLAY(" \n");
 421                                 for (n=-5; n<0; n++) DISPLAY("%02X ", ((const BYTE*)resultBuffer)[u+n]);
 422                                 DISPLAY(" :%02X:  ", ((const BYTE*)resultBuffer)[u]);
 423                                 for (n=1; n<3; n++) DISPLAY("%02X ", ((const BYTE*)resultBuffer)[u+n]);
 424                                 DISPLAY(" \n");
 425                             }
 426                             break;
 427                         }
 428                         if (u==srcSize-1) {  /* should never happen */
 429                             DISPLAY("no difference detected\n");
 430                     }   }
 431                     break;
 432             }   }   /* CRC Checking */
 433 #endif
 434         }   /* for (testNb = 1; testNb <= (g_nbSeconds + !g_nbSeconds); testNb++) */
 435
 436         if (g_displayLevel == 1) {
 437             double cSpeed = (double)srcSize / fastestC;
 438             double dSpeed = (double)srcSize / fastestD;
 439             if (g_additionalParam)
 440                 DISPLAY("-%-3i%11i (%5.3f) %6.2f MB/s %6.1f MB/s  %s (param=%d)\n", cLevel, (int)cSize, ratio, cSpeed, dSpeed, displayName, g_additionalParam);
 441             else
 442                 DISPLAY("-%-3i%11i (%5.3f) %6.2f MB/s %6.1f MB/s  %s\n", cLevel, (int)cSize, ratio, cSpeed, dSpeed, displayName);
 443         }
 444         DISPLAYLEVEL(2, "%2i#\n", cLevel);
 445     }   /* Bench */
 446
 447     /* clean up */
 448     free(blockTable);
 449     free(compressedBuffer);
 450     free(resultBuffer);
 451     ZSTDMT_freeCCtx(mtctx);
 452     ZSTD_freeCCtx(ctx);
 453     ZSTD_freeDCtx(dctx);
 454     return 0;
 455 }
 456
 457
 458 static size_t BMK_findMaxMem(U64 requiredMem)
 459 {
 460     size_t const step = 64 MB;
 461     BYTE* testmem = NULL;
 462
 463     requiredMem = (((requiredMem >> 26) + 1) << 26);
 464     requiredMem += step;
 465     if (requiredMem > maxMemory) requiredMem = maxMemory;
 466
 467     do {
 468         testmem = (BYTE*)malloc((size_t)requiredMem);
 469         requiredMem -= step;
 470     } while (!testmem);
 471
 472     free(testmem);
 473     return (size_t)(requiredMem);
 474 }
 475
 476 static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
 477                             const char* displayName, int cLevel, int cLevelLast,
 478                             const size_t* fileSizes, unsigned nbFiles,
 479                             const void* dictBuffer, size_t dictBufferSize,
 480                             ZSTD_compressionParameters *compressionParams, int setRealTimePrio)
 481 {
 482     int l;
 483
 484     const char* pch = strrchr(displayName, '\\'); /* Windows */
 485     if (!pch) pch = strrchr(displayName, '/'); /* Linux */
 486     if (pch) displayName = pch+1;
 487
 488     if (setRealTimePrio) {
 489         DISPLAYLEVEL(2, "Note : switching to a real-time priority \n");
 490         SET_REALTIME_PRIORITY;
 491     }
 492
 493     if (g_displayLevel == 1 && !g_additionalParam)
 494         DISPLAY("bench %s %s: input %u bytes, %u seconds, %u KB blocks\n", ZSTD_VERSION_STRING, ZSTD_GIT_COMMIT_STRING, (U32)benchedSize, g_nbSeconds, (U32)(g_blockSize>>10));
 495
 496     if (cLevelLast < cLevel) cLevelLast = cLevel;
 497
 498     for (l=cLevel; l <= cLevelLast; l++) {
 499         BMK_benchMem(srcBuffer, benchedSize,
 500                      displayName, l,
 501                      fileSizes, nbFiles,
 502                      dictBuffer, dictBufferSize, compressionParams);
 503     }
 504 }
 505
 506
 507 /*! BMK_loadFiles() :
 508     Loads `buffer` with content of files listed within `fileNamesTable`.
 509     At most, fills `buffer` entirely */
 510 static void BMK_loadFiles(void* buffer, size_t bufferSize,
 511                           size_t* fileSizes,
 512                           const char** fileNamesTable, unsigned nbFiles)
 513 {
 514     size_t pos = 0, totalSize = 0;
 515     unsigned n;
 516     for (n=0; n<nbFiles; n++) {
 517         FILE* f;
 518         U64 fileSize = UTIL_getFileSize(fileNamesTable[n]);
 519         if (UTIL_isDirectory(fileNamesTable[n])) {
 520             DISPLAYLEVEL(2, "Ignoring %s directory...       \n", fileNamesTable[n]);
 521             fileSizes[n] = 0;
 522             continue;
 523         }
 524         f = fopen(fileNamesTable[n], "rb");
 525         if (f==NULL) EXM_THROW(10, "impossible to open file %s", fileNamesTable[n]);
 526         DISPLAYUPDATE(2, "Loading %s...       \r", fileNamesTable[n]);
 527         if (fileSize > bufferSize-pos) fileSize = bufferSize-pos, nbFiles=n;   /* buffer too small - stop after this file */
 528         { size_t const readSize = fread(((char*)buffer)+pos, 1, (size_t)fileSize, f);
 529           if (readSize != (size_t)fileSize) EXM_THROW(11, "could not read %s", fileNamesTable[n]);
 530           pos += readSize; }
 531         fileSizes[n] = (size_t)fileSize;
 532         totalSize += (size_t)fileSize;
 533         fclose(f);
 534     }
 535
 536     if (totalSize == 0) EXM_THROW(12, "no data to bench");
 537 }
 538
 539 static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName, int cLevel,
 540                                int cLevelLast, ZSTD_compressionParameters *compressionParams, int setRealTimePrio)
 541 {
 542     void* srcBuffer;
 543     size_t benchedSize;
 544     void* dictBuffer = NULL;
 545     size_t dictBufferSize = 0;
 546     size_t* fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
 547     U64 const totalSizeToLoad = UTIL_getTotalFileSize(fileNamesTable, nbFiles);
 548     char mfName[20] = {0};
 549
 550     if (!fileSizes) EXM_THROW(12, "not enough memory for fileSizes");
 551
 552     /* Load dictionary */
 553     if (dictFileName != NULL) {
 554         U64 dictFileSize = UTIL_getFileSize(dictFileName);
 555         if (dictFileSize > 64 MB) EXM_THROW(10, "dictionary file %s too large", dictFileName);
 556         dictBufferSize = (size_t)dictFileSize;
 557         dictBuffer = malloc(dictBufferSize);
 558         if (dictBuffer==NULL) EXM_THROW(11, "not enough memory for dictionary (%u bytes)", (U32)dictBufferSize);
 559         BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1);
 560     }
 561
 562     /* Memory allocation & restrictions */
 563     benchedSize = BMK_findMaxMem(totalSizeToLoad * 3) / 3;
 564     if ((U64)benchedSize > totalSizeToLoad) benchedSize = (size_t)totalSizeToLoad;
 565     if (benchedSize < totalSizeToLoad)
 566         DISPLAY("Not enough memory; testing %u MB only...\n", (U32)(benchedSize >> 20));
 567     srcBuffer = malloc(benchedSize);
 568     if (!srcBuffer) EXM_THROW(12, "not enough memory");
 569
 570     /* Load input buffer */
 571     BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles);
 572
 573     /* Bench */
 574     snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
 575     {   const char* displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
 576         BMK_benchCLevel(srcBuffer, benchedSize,
 577                         displayName, cLevel, cLevelLast,
 578                         fileSizes, nbFiles,
 579                         dictBuffer, dictBufferSize, compressionParams, setRealTimePrio);
 580     }
 581
 582     /* clean up */
 583     free(srcBuffer);
 584     free(dictBuffer);
 585     free(fileSizes);
 586 }
 587
 588
 589 static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility, ZSTD_compressionParameters* compressionParams, int setRealTimePrio)
 590 {
 591     char name[20] = {0};
 592     size_t benchedSize = 10000000;
 593     void* const srcBuffer = malloc(benchedSize);
 594
 595     /* Memory allocation */
 596     if (!srcBuffer) EXM_THROW(21, "not enough memory");
 597
 598     /* Fill input buffer */
 599     RDG_genBuffer(srcBuffer, benchedSize, compressibility, 0.0, 0);
 600
 601     /* Bench */
 602     snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
 603     BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1, NULL, 0, compressionParams, setRealTimePrio);
 604
 605     /* clean up */
 606     free(srcBuffer);
 607 }
 608
 609
 610 int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName,
 611                    int cLevel, int cLevelLast, ZSTD_compressionParameters* compressionParams, int setRealTimePrio)
 612 {
 613     double const compressibility = (double)g_compressibilityDefault / 100;
 614
 615     if (cLevel < 1) cLevel = 1;   /* minimum compression level */
 616     if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel();
 617     if (cLevelLast > ZSTD_maxCLevel()) cLevelLast = ZSTD_maxCLevel();
 618     if (cLevelLast < cLevel) cLevelLast = cLevel;
 619     if (cLevelLast > cLevel) DISPLAYLEVEL(2, "Benchmarking levels from %d to %d\n", cLevel, cLevelLast);
 620
 621     if (nbFiles == 0)
 622         BMK_syntheticTest(cLevel, cLevelLast, compressibility, compressionParams, setRealTimePrio);
 623     else
 624         BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast, compressionParams, setRealTimePrio);
 625     return 0;
 626 }