/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
* All rights reserved.
*
* This source code is licensed under both the BSD-style license (found in the
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
* in the COPYING file in the root directory of this source tree).
* You may select, at your option, one of the above-listed licenses.
*/

/* largeNbDicts
* This is a benchmark test tool
* dedicated to the specific case of dictionary decompression
* using a very large nb of dictionaries
* thus suffering latency from lots of cache misses.
* It's created in a bid to investigate performance and find optimizations. */


/*---  Dependencies  ---*/

#include <stddef.h>   /* size_t */
#include <stdlib.h>   /* malloc, free, abort, qsort*/
#include <stdio.h>    /* fprintf */
#include <limits.h>   /* UINT_MAX */
#include <assert.h>   /* assert */

#include "util.h"
#include "benchfn.h"
#define ZSTD_STATIC_LINKING_ONLY
#include "zstd.h"
#include "zdict.h"


/*---  Constants  --- */

#define KB  *(1<<10)
#define MB  *(1<<20)

#define BLOCKSIZE_DEFAULT 0  /* no slicing into blocks */
#define DICTSIZE  (4 KB)
#define CLEVEL_DEFAULT 3
#define DICT_LOAD_METHOD ZSTD_dlm_byCopy

#define BENCH_TIME_DEFAULT_S   6
#define RUN_TIME_DEFAULT_MS    1000
#define BENCH_TIME_DEFAULT_MS (BENCH_TIME_DEFAULT_S * RUN_TIME_DEFAULT_MS)

#define DISPLAY_LEVEL_DEFAULT 3

#define BENCH_SIZE_MAX (1200 MB)


/*---  Macros  ---*/

#define CONTROL(c)   { if (!(c)) abort(); }
#undef MIN
#define MIN(a,b)     ((a) < (b) ? (a) : (b))


/*---  Display Macros  ---*/

#define DISPLAY(...)         fprintf(stdout, __VA_ARGS__)
#define DISPLAYLEVEL(l, ...) { if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); } }
static int g_displayLevel = DISPLAY_LEVEL_DEFAULT;   /* 0 : no display,  1: errors,  2 : + result + interaction + warnings,  3 : + progression,  4 : + information */


/*---  buffer_t  ---*/

typedef struct {
   void* ptr;
   size_t size;
   size_t capacity;
} buffer_t;

static const buffer_t kBuffNull = { NULL, 0, 0 };

/* @return : kBuffNull if any error */
static buffer_t createBuffer(size_t capacity)
{
   assert(capacity > 0);
   void* const ptr = malloc(capacity);
   if (ptr==NULL) return kBuffNull;

   buffer_t buffer;
   buffer.ptr = ptr;
   buffer.capacity = capacity;
   buffer.size = 0;
   return buffer;
}

static void freeBuffer(buffer_t buff)
{
   free(buff.ptr);
}


static void fillBuffer_fromHandle(buffer_t* buff, FILE* f)
{
   size_t const readSize = fread(buff->ptr, 1, buff->capacity, f);
   buff->size = readSize;
}


/* @return : kBuffNull if any error */
static buffer_t createBuffer_fromFile(const char* fileName)
{
   U64 const fileSize = UTIL_getFileSize(fileName);
   size_t const bufferSize = (size_t) fileSize;

   if (fileSize == UTIL_FILESIZE_UNKNOWN) return kBuffNull;
   assert((U64)bufferSize == fileSize);   /* check overflow */

   {   FILE* const f = fopen(fileName, "rb");
       if (f == NULL) return kBuffNull;

       buffer_t buff = createBuffer(bufferSize);
       CONTROL(buff.ptr != NULL);

       fillBuffer_fromHandle(&buff, f);
       CONTROL(buff.size == buff.capacity);

       fclose(f);   /* do nothing specific if fclose() fails */
       return buff;
   }
}


/* @return : kBuffNull if any error */
static buffer_t
createDictionaryBuffer(const char* dictionaryName,
                      const void* srcBuffer,
                      const size_t* srcBlockSizes, size_t nbBlocks,
                      size_t requestedDictSize)
{
   if (dictionaryName) {
       DISPLAYLEVEL(3, "loading dictionary %s \n", dictionaryName);
       return createBuffer_fromFile(dictionaryName);  /* note : result might be kBuffNull */

   } else {

       DISPLAYLEVEL(3, "creating dictionary, of target size %u bytes \n",
                       (unsigned)requestedDictSize);
       void* const dictBuffer = malloc(requestedDictSize);
       CONTROL(dictBuffer != NULL);

       assert(nbBlocks <= UINT_MAX);
       size_t const dictSize = ZDICT_trainFromBuffer(dictBuffer, requestedDictSize,
                                                     srcBuffer,
                                                     srcBlockSizes, (unsigned)nbBlocks);
       CONTROL(!ZSTD_isError(dictSize));

       buffer_t result;
       result.ptr = dictBuffer;
       result.capacity = requestedDictSize;
       result.size = dictSize;
       return result;
   }
}

/*! BMK_loadFiles() :
*  Loads `buffer`, with content from files listed within `fileNamesTable`.
*  Fills `buffer` entirely.
* @return : 0 on success, !=0 on error */
static int loadFiles(void* buffer, size_t bufferSize,
                    size_t* fileSizes,
                    const char* const * fileNamesTable, unsigned nbFiles)
{
   size_t pos = 0, totalSize = 0;

   for (unsigned n=0; n<nbFiles; n++) {
       U64 fileSize = UTIL_getFileSize(fileNamesTable[n]);
       if (UTIL_isDirectory(fileNamesTable[n])) {
           fileSizes[n] = 0;
           continue;
       }
       if (fileSize == UTIL_FILESIZE_UNKNOWN) {
           fileSizes[n] = 0;
           continue;
       }

       FILE* const f = fopen(fileNamesTable[n], "rb");
       assert(f!=NULL);

       assert(pos <= bufferSize);
       assert(fileSize <= bufferSize - pos);

       {   size_t const readSize = fread(((char*)buffer)+pos, 1, (size_t)fileSize, f);
           assert(readSize == fileSize);
           pos += readSize;
       }
       fileSizes[n] = (size_t)fileSize;
       totalSize += (size_t)fileSize;
       fclose(f);
   }

   assert(totalSize == bufferSize);
   return 0;
}



/*---  slice_collection_t  ---*/

typedef struct {
   void** slicePtrs;
   size_t* capacities;
   size_t nbSlices;
} slice_collection_t;

static const slice_collection_t kNullCollection = { NULL, NULL, 0 };

static void freeSliceCollection(slice_collection_t collection)
{
   free(collection.slicePtrs);
   free(collection.capacities);
}

/* shrinkSizes() :
* downsizes sizes of slices within collection, according to `newSizes`.
* every `newSizes` entry must be <= than its corresponding collection size */
void shrinkSizes(slice_collection_t collection,
                const size_t* newSizes)  /* presumed same size as collection */
{
   size_t const nbSlices = collection.nbSlices;
   for (size_t blockNb = 0; blockNb < nbSlices; blockNb++) {
       assert(newSizes[blockNb] <= collection.capacities[blockNb]);
       collection.capacities[blockNb] = newSizes[blockNb];
   }
}


/* splitSlices() :
* nbSlices : if == 0, nbSlices is automatically determined from srcSlices and blockSize.
*            otherwise, creates exactly nbSlices slices,
*            by either truncating input (when smaller)
*            or repeating input from beginning */
static slice_collection_t
splitSlices(slice_collection_t srcSlices, size_t blockSize, size_t nbSlices)
{
   if (blockSize==0) blockSize = (size_t)(-1);   /* means "do not cut" */
   size_t nbSrcBlocks = 0;
   for (size_t ssnb=0; ssnb < srcSlices.nbSlices; ssnb++) {
       size_t pos = 0;
       while (pos <= srcSlices.capacities[ssnb]) {
           nbSrcBlocks++;
           pos += blockSize;
       }
   }

   if (nbSlices == 0) nbSlices = nbSrcBlocks;

   void** const sliceTable = (void**)malloc(nbSlices * sizeof(*sliceTable));
   size_t* const capacities = (size_t*)malloc(nbSlices * sizeof(*capacities));
   if (sliceTable == NULL || capacities == NULL) {
       free(sliceTable);
       free(capacities);
       return kNullCollection;
   }

   size_t ssnb = 0;
   for (size_t sliceNb=0; sliceNb < nbSlices; ) {
       ssnb = (ssnb + 1) % srcSlices.nbSlices;
       size_t pos = 0;
       char* const ptr = (char*)srcSlices.slicePtrs[ssnb];
       while (pos < srcSlices.capacities[ssnb] && sliceNb < nbSlices) {
           size_t const size = MIN(blockSize, srcSlices.capacities[ssnb] - pos);
           sliceTable[sliceNb] = ptr + pos;
           capacities[sliceNb] = size;
           sliceNb++;
           pos += blockSize;
       }
   }

   slice_collection_t result;
   result.nbSlices = nbSlices;
   result.slicePtrs = sliceTable;
   result.capacities = capacities;
   return result;
}


static size_t sliceCollection_totalCapacity(slice_collection_t sc)
{
   size_t totalSize = 0;
   for (size_t n=0; n<sc.nbSlices; n++)
       totalSize += sc.capacities[n];
   return totalSize;
}


/* ---  buffer collection  --- */

typedef struct {
   buffer_t buffer;
   slice_collection_t slices;
} buffer_collection_t;


static void freeBufferCollection(buffer_collection_t bc)
{
   freeBuffer(bc.buffer);
   freeSliceCollection(bc.slices);
}


static buffer_collection_t
createBufferCollection_fromSliceCollectionSizes(slice_collection_t sc)
{
   size_t const bufferSize = sliceCollection_totalCapacity(sc);

   buffer_t buffer = createBuffer(bufferSize);
   CONTROL(buffer.ptr != NULL);

   size_t const nbSlices = sc.nbSlices;
   void** const slices = (void**)malloc(nbSlices * sizeof(*slices));
   CONTROL(slices != NULL);

   size_t* const capacities = (size_t*)malloc(nbSlices * sizeof(*capacities));
   CONTROL(capacities != NULL);

   char* const ptr = (char*)buffer.ptr;
   size_t pos = 0;
   for (size_t n=0; n < nbSlices; n++) {
       capacities[n] = sc.capacities[n];
       slices[n] = ptr + pos;
       pos += capacities[n];
   }

   buffer_collection_t result;
   result.buffer = buffer;
   result.slices.nbSlices = nbSlices;
   result.slices.capacities = capacities;
   result.slices.slicePtrs = slices;
   return result;
}

static buffer_collection_t
createBufferCollection_fromSliceCollection(slice_collection_t sc)
{
   size_t const bufferSize = sliceCollection_totalCapacity(sc);

   buffer_t buffer = createBuffer(bufferSize);
   CONTROL(buffer.ptr != NULL);

   size_t const nbSlices = sc.nbSlices;
   void** const slices = (void**)malloc(nbSlices * sizeof(*slices));
   CONTROL(slices != NULL);

   size_t* const capacities = (size_t*)malloc(nbSlices * sizeof(*capacities));
   CONTROL(capacities != NULL);

   char* const ptr = (char*)buffer.ptr;
   size_t pos = 0;
   for (size_t n=0; n < nbSlices; n++) {
       capacities[n] = sc.capacities[n];
       slices[n] = ptr + pos;
       pos += capacities[n];
   }

   for (size_t i = 0; i < nbSlices; i++) {
       memcpy(slices[i], sc.slicePtrs[i], sc.capacities[i]);
       capacities[i] = sc.capacities[i];
   }

   buffer_collection_t result;
   result.buffer = buffer;
   result.slices.nbSlices = nbSlices;
   result.slices.capacities = capacities;
   result.slices.slicePtrs = slices;

   return result;
}

/* @return : kBuffNull if any error */
static buffer_collection_t
createBufferCollection_fromFiles(const char* const * fileNamesTable, unsigned nbFiles)
{
   U64 const totalSizeToLoad = UTIL_getTotalFileSize(fileNamesTable, nbFiles);
   assert(totalSizeToLoad != UTIL_FILESIZE_UNKNOWN);
   assert(totalSizeToLoad <= BENCH_SIZE_MAX);
   size_t const loadedSize = (size_t)totalSizeToLoad;
   assert(loadedSize > 0);
   void* const srcBuffer = malloc(loadedSize);
   assert(srcBuffer != NULL);

   assert(nbFiles > 0);
   size_t* const fileSizes = (size_t*)calloc(nbFiles, sizeof(*fileSizes));
   assert(fileSizes != NULL);

   /* Load input buffer */
   int const errorCode = loadFiles(srcBuffer, loadedSize,
                                   fileSizes,
                                   fileNamesTable, nbFiles);
   assert(errorCode == 0);

   void** sliceTable = (void**)malloc(nbFiles * sizeof(*sliceTable));
   assert(sliceTable != NULL);

   char* const ptr = (char*)srcBuffer;
   size_t pos = 0;
   unsigned fileNb = 0;
   for ( ; (pos < loadedSize) && (fileNb < nbFiles); fileNb++) {
       sliceTable[fileNb] = ptr + pos;
       pos += fileSizes[fileNb];
   }
   assert(pos == loadedSize);
   assert(fileNb == nbFiles);


   buffer_t buffer;
   buffer.ptr = srcBuffer;
   buffer.capacity = loadedSize;
   buffer.size = loadedSize;

   slice_collection_t slices;
   slices.slicePtrs = sliceTable;
   slices.capacities = fileSizes;
   slices.nbSlices = nbFiles;

   buffer_collection_t bc;
   bc.buffer = buffer;
   bc.slices = slices;
   return bc;
}




/*---  ddict_collection_t  ---*/

typedef struct {
   ZSTD_DDict** ddicts;
   size_t nbDDict;
} ddict_collection_t;

typedef struct {
   ZSTD_CDict** cdicts;
   size_t nbCDict;
} cdict_collection_t;

static const cdict_collection_t kNullCDictCollection = { NULL, 0 };

static void freeCDictCollection(cdict_collection_t cdictc)
{
   for (size_t dictNb=0; dictNb < cdictc.nbCDict; dictNb++) {
       ZSTD_freeCDict(cdictc.cdicts[dictNb]);
   }
   free(cdictc.cdicts);
}

/* returns .buffers=NULL if operation fails */
static cdict_collection_t createCDictCollection(const void* dictBuffer, size_t dictSize, size_t nbCDict, ZSTD_dictContentType_e dictContentType, ZSTD_CCtx_params* cctxParams)
{
   ZSTD_CDict** const cdicts = malloc(nbCDict * sizeof(ZSTD_CDict*));
   if (cdicts==NULL) return kNullCDictCollection;
   for (size_t dictNb=0; dictNb < nbCDict; dictNb++) {
       cdicts[dictNb] = ZSTD_createCDict_advanced2(dictBuffer, dictSize, DICT_LOAD_METHOD, dictContentType, cctxParams, ZSTD_defaultCMem);
       CONTROL(cdicts[dictNb] != NULL);
   }
   cdict_collection_t cdictc;
   cdictc.cdicts = cdicts;
   cdictc.nbCDict = nbCDict;
   return cdictc;
}

static const ddict_collection_t kNullDDictCollection = { NULL, 0 };

static void freeDDictCollection(ddict_collection_t ddictc)
{
   for (size_t dictNb=0; dictNb < ddictc.nbDDict; dictNb++) {
       ZSTD_freeDDict(ddictc.ddicts[dictNb]);
   }
   free(ddictc.ddicts);
}

/* returns .buffers=NULL if operation fails */
static ddict_collection_t createDDictCollection(const void* dictBuffer, size_t dictSize, size_t nbDDict)
{
   ZSTD_DDict** const ddicts = malloc(nbDDict * sizeof(ZSTD_DDict*));
   assert(ddicts != NULL);
   if (ddicts==NULL) return kNullDDictCollection;
   for (size_t dictNb=0; dictNb < nbDDict; dictNb++) {
       ddicts[dictNb] = ZSTD_createDDict(dictBuffer, dictSize);
       assert(ddicts[dictNb] != NULL);
   }
   ddict_collection_t ddictc;
   ddictc.ddicts = ddicts;
   ddictc.nbDDict = nbDDict;
   return ddictc;
}


/* mess with addresses, so that linear scanning dictionaries != linear address scanning */
void shuffleCDictionaries(cdict_collection_t dicts)
{
   size_t const nbDicts = dicts.nbCDict;
   for (size_t r=0; r<nbDicts; r++) {
       size_t const d = (size_t)rand() % nbDicts;
       ZSTD_CDict* tmpd = dicts.cdicts[d];
       dicts.cdicts[d] = dicts.cdicts[r];
       dicts.cdicts[r] = tmpd;
   }
   for (size_t r=0; r<nbDicts; r++) {
       size_t const d1 = (size_t)rand() % nbDicts;
       size_t const d2 = (size_t)rand() % nbDicts;
       ZSTD_CDict* tmpd = dicts.cdicts[d1];
       dicts.cdicts[d1] = dicts.cdicts[d2];
       dicts.cdicts[d2] = tmpd;
   }
}

/* mess with addresses, so that linear scanning dictionaries != linear address scanning */
void shuffleDDictionaries(ddict_collection_t dicts)
{
   size_t const nbDicts = dicts.nbDDict;
   for (size_t r=0; r<nbDicts; r++) {
       size_t const d = (size_t)rand() % nbDicts;
       ZSTD_DDict* tmpd = dicts.ddicts[d];
       dicts.ddicts[d] = dicts.ddicts[r];
       dicts.ddicts[r] = tmpd;
   }
   for (size_t r=0; r<nbDicts; r++) {
       size_t const d1 = (size_t)rand() % nbDicts;
       size_t const d2 = (size_t)rand() % nbDicts;
       ZSTD_DDict* tmpd = dicts.ddicts[d1];
       dicts.ddicts[d1] = dicts.ddicts[d2];
       dicts.ddicts[d2] = tmpd;
   }
}


/* ---   Compression  --- */

/* compressBlocks() :
* @return : total compressed size of all blocks,
*        or 0 if error.
*/
static size_t compressBlocks(size_t* cSizes,   /* optional (can be NULL). If present, must contain at least nbBlocks fields */
                            slice_collection_t dstBlockBuffers,
                            slice_collection_t srcBlockBuffers,
                            ZSTD_CDict* cdict, int cLevel)
{
   size_t const nbBlocks = srcBlockBuffers.nbSlices;
   assert(dstBlockBuffers.nbSlices == srcBlockBuffers.nbSlices);

   ZSTD_CCtx* const cctx = ZSTD_createCCtx();
   assert(cctx != NULL);

   size_t totalCSize = 0;
   for (size_t blockNb=0; blockNb < nbBlocks; blockNb++) {
       size_t cBlockSize;
       if (cdict == NULL) {
           cBlockSize = ZSTD_compressCCtx(cctx,
                           dstBlockBuffers.slicePtrs[blockNb], dstBlockBuffers.capacities[blockNb],
                           srcBlockBuffers.slicePtrs[blockNb], srcBlockBuffers.capacities[blockNb],
                           cLevel);
       } else {
           cBlockSize = ZSTD_compress_usingCDict(cctx,
                           dstBlockBuffers.slicePtrs[blockNb], dstBlockBuffers.capacities[blockNb],
                           srcBlockBuffers.slicePtrs[blockNb], srcBlockBuffers.capacities[blockNb],
                           cdict);
       }
       CONTROL(!ZSTD_isError(cBlockSize));
       if (cSizes) cSizes[blockNb] = cBlockSize;
       totalCSize += cBlockSize;
   }
   return totalCSize;
}


/* ---  Benchmark  --- */

typedef struct {
   ZSTD_CCtx* cctx;
   size_t nbDicts;
   size_t dictNb;
   cdict_collection_t dictionaries;
} compressInstructions;

compressInstructions createCompressInstructions(cdict_collection_t dictionaries, ZSTD_CCtx_params* cctxParams)
{
   compressInstructions ci;
   ci.cctx = ZSTD_createCCtx();
   CONTROL(ci.cctx != NULL);
   if (cctxParams)
     ZSTD_CCtx_setParametersUsingCCtxParams(ci.cctx, cctxParams);
   ci.nbDicts = dictionaries.nbCDict;
   ci.dictNb = 0;
   ci.dictionaries = dictionaries;
   return ci;
}

void freeCompressInstructions(compressInstructions ci)
{
   ZSTD_freeCCtx(ci.cctx);
}

typedef struct {
   ZSTD_DCtx* dctx;
   size_t nbDicts;
   size_t dictNb;
   ddict_collection_t dictionaries;
} decompressInstructions;

decompressInstructions createDecompressInstructions(ddict_collection_t dictionaries)
{
   decompressInstructions di;
   di.dctx = ZSTD_createDCtx();
   assert(di.dctx != NULL);
   di.nbDicts = dictionaries.nbDDict;
   di.dictNb = 0;
   di.dictionaries = dictionaries;
   return di;
}

void freeDecompressInstructions(decompressInstructions di)
{
   ZSTD_freeDCtx(di.dctx);
}

/* benched function */
size_t compress(const void* src, size_t srcSize, void* dst, size_t dstCapacity, void* payload)
{
   compressInstructions* const ci = (compressInstructions*) payload;
   (void)dstCapacity;

   ZSTD_CCtx_refCDict(ci->cctx, ci->dictionaries.cdicts[ci->dictNb]);
   ZSTD_compress2(ci->cctx,
           dst, srcSize,
           src, srcSize);

   ci->dictNb = ci->dictNb + 1;
   if (ci->dictNb >= ci->nbDicts) ci->dictNb = 0;

   return srcSize;
}

/* benched function */
size_t decompress(const void* src, size_t srcSize, void* dst, size_t dstCapacity, void* payload)
{
   decompressInstructions* const di = (decompressInstructions*) payload;

   size_t const result = ZSTD_decompress_usingDDict(di->dctx,
                                       dst, dstCapacity,
                                       src, srcSize,
                                       di->dictionaries.ddicts[di->dictNb]);

   di->dictNb = di->dictNb + 1;
   if (di->dictNb >= di->nbDicts) di->dictNb = 0;

   return result;
}

typedef enum {
 fastest = 0,
 median = 1,
} metricAggregatePref_e;

/* compareFunction() :
* Sort input in decreasing order when used with qsort() */
int compareFunction(const void *a, const void *b)
{
 double x = *(const double *)a;
 double y = *(const double *)b;
 if (x < y)
   return 1;
 else if (x > y)
   return -1;
 return 0;
}

double aggregateData(double *data, size_t size,
                    metricAggregatePref_e metricAggregatePref)
{
 qsort(data, size, sizeof(*data), compareFunction);
 if (metricAggregatePref == fastest)
   return data[0];
 else /* median */
   return (data[(size - 1) / 2] + data[size / 2]) / 2;
}

static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
                   ddict_collection_t ddictionaries,
                   cdict_collection_t cdictionaries, unsigned nbRounds,
                   int benchCompression, const char *exeName,
                   ZSTD_CCtx_params *cctxParams,
                   metricAggregatePref_e metricAggregatePref)
{
   assert(dstBlocks.nbSlices == srcBlocks.nbSlices);
   if (benchCompression) assert(cctxParams);

   unsigned const ms_per_round = RUN_TIME_DEFAULT_MS;
   unsigned const total_time_ms = nbRounds * ms_per_round;

   double *const speedPerRound = (double *)malloc(nbRounds * sizeof(double));

   BMK_timedFnState_t* const benchState =
           BMK_createTimedFnState(total_time_ms, ms_per_round);

   decompressInstructions di = createDecompressInstructions(ddictionaries);
   compressInstructions ci =
       createCompressInstructions(cdictionaries, cctxParams);
   void* payload = benchCompression ? (void*)&ci : (void*)&di;
   BMK_benchParams_t const bp = {
       .benchFn = benchCompression ? compress : decompress,
       .benchPayload = payload,
       .initFn = NULL,
       .initPayload = NULL,
       .errorFn = ZSTD_isError,
       .blockCount = dstBlocks.nbSlices,
       .srcBuffers = (const void* const*) srcBlocks.slicePtrs,
       .srcSizes = srcBlocks.capacities,
       .dstBuffers = dstBlocks.slicePtrs,
       .dstCapacities = dstBlocks.capacities,
       .blockResults = NULL
   };

   size_t roundNb = 0;
   for (;;) {
       BMK_runOutcome_t const outcome = BMK_benchTimedFn(benchState, bp);
       CONTROL(BMK_isSuccessful_runOutcome(outcome));

       BMK_runTime_t const result = BMK_extract_runTime(outcome);
       double const dTime_ns = result.nanoSecPerRun;
       double const dTime_sec = (double)dTime_ns / 1000000000;
       size_t const srcSize = result.sumOfReturn;
       double const speed_MBps = (double)srcSize / dTime_sec / (1 MB);
       speedPerRound[roundNb] = speed_MBps;
       if (benchCompression)
           DISPLAY("Compression Speed : %.1f MB/s \r", speed_MBps);
       else
           DISPLAY("Decompression Speed : %.1f MB/s \r", speed_MBps);

       fflush(stdout);
       if (BMK_isCompleted_TimedFn(benchState)) break;
       roundNb++;
   }
   DISPLAY("\n");
   /* BMK_benchTimedFn may not run exactly nbRounds iterations */
   double speedAggregated =
       aggregateData(speedPerRound, roundNb + 1, metricAggregatePref);
   if (metricAggregatePref == fastest)
     DISPLAY("Fastest Speed : %.1f MB/s \n", speedAggregated);
   else
     DISPLAY("Median Speed : %.1f MB/s \n", speedAggregated);

   char* csvFileName = malloc(strlen(exeName) + 5);
   strcpy(csvFileName, exeName);
   strcat(csvFileName, ".csv");
   FILE* csvFile = fopen(csvFileName, "r");
   if (!csvFile) {
       csvFile = fopen(csvFileName, "wt");
       assert(csvFile);
       fprintf(csvFile, "%s\n", exeName);
       /* Print table headers */
       fprintf(
           csvFile,
           "Compression/Decompression,Level,nbDicts,dictAttachPref,metricAggregatePref,Speed\n");
   } else {
       fclose(csvFile);
       csvFile = fopen(csvFileName, "at");
       assert(csvFile);
   }

   int cLevel = -1;
   int dictAttachPref = -1;
   if (benchCompression) {
     ZSTD_CCtxParams_getParameter(cctxParams, ZSTD_c_compressionLevel,
                                  &cLevel);
     ZSTD_CCtxParams_getParameter(cctxParams, ZSTD_c_forceAttachDict,
                                  &dictAttachPref);
   }
   fprintf(csvFile, "%s,%d,%ld,%d,%d,%.1f\n",
           benchCompression ? "Compression" : "Decompression", cLevel,
           benchCompression ? ci.nbDicts : di.nbDicts, dictAttachPref,
           metricAggregatePref, speedAggregated);
   fclose(csvFile);
   free(csvFileName);

   freeDecompressInstructions(di);
   freeCompressInstructions(ci);
   BMK_freeTimedFnState(benchState);

   return 0;   /* success */
}


/*! bench() :
*  fileName : file to load for benchmarking purpose
*  dictionary : optional (can be NULL), file to load as dictionary,
*              if none provided : will be calculated on the fly by the program.
* @return : 0 is success, 1+ otherwise */
int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
         size_t blockSize, int clevel, unsigned nbDictMax, unsigned nbBlocks,
         unsigned nbRounds, int benchCompression,
         ZSTD_dictContentType_e dictContentType, ZSTD_CCtx_params *cctxParams,
         const char *exeName, metricAggregatePref_e metricAggregatePref)
{
   int result = 0;

   DISPLAYLEVEL(3, "loading %u files... \n", nbFiles);
   buffer_collection_t const srcs = createBufferCollection_fromFiles(fileNameTable, nbFiles);
   CONTROL(srcs.buffer.ptr != NULL);
   buffer_t srcBuffer = srcs.buffer;
   size_t const srcSize = srcBuffer.size;
   DISPLAYLEVEL(3, "created src buffer of size %.1f MB \n",
                   (double)srcSize / (1 MB));

   slice_collection_t const srcSlices = splitSlices(srcs.slices, blockSize, nbBlocks);
   nbBlocks = (unsigned)(srcSlices.nbSlices);
   DISPLAYLEVEL(3, "split input into %u blocks ", nbBlocks);
   if (blockSize)
       DISPLAYLEVEL(3, "of max size %u bytes ", (unsigned)blockSize);
   DISPLAYLEVEL(3, "\n");
   size_t const totalSrcSlicesSize = sliceCollection_totalCapacity(srcSlices);


   size_t* const dstCapacities = malloc(nbBlocks * sizeof(*dstCapacities));
   CONTROL(dstCapacities != NULL);
   size_t dstBufferCapacity = 0;
   for (size_t bnb=0; bnb<nbBlocks; bnb++) {
       dstCapacities[bnb] = ZSTD_compressBound(srcSlices.capacities[bnb]);
       dstBufferCapacity += dstCapacities[bnb];
   }

   buffer_t dstBuffer = createBuffer(dstBufferCapacity);
   CONTROL(dstBuffer.ptr != NULL);

   void** const sliceTable = malloc(nbBlocks * sizeof(*sliceTable));
   CONTROL(sliceTable != NULL);

   {   char* const ptr = dstBuffer.ptr;
       size_t pos = 0;
       for (size_t snb=0; snb < nbBlocks; snb++) {
           sliceTable[snb] = ptr + pos;
           pos += dstCapacities[snb];
   }   }

   slice_collection_t dstSlices;
   dstSlices.capacities = dstCapacities;
   dstSlices.slicePtrs = sliceTable;
   dstSlices.nbSlices = nbBlocks;


   /* dictionary determination */
   buffer_t const dictBuffer = createDictionaryBuffer(dictionary,
                               srcs.buffer.ptr,
                               srcSlices.capacities, srcSlices.nbSlices,
                               DICTSIZE);
   CONTROL(dictBuffer.ptr != NULL);

   ZSTD_CDict* const cdict = ZSTD_createCDict_advanced2(dictBuffer.ptr, dictBuffer.size, DICT_LOAD_METHOD, dictContentType, cctxParams, ZSTD_defaultCMem);
   CONTROL(cdict != NULL);

   size_t const cTotalSizeNoDict = compressBlocks(NULL, dstSlices, srcSlices, NULL, clevel);
   CONTROL(cTotalSizeNoDict != 0);
   DISPLAYLEVEL(3, "compressing at level %u without dictionary : Ratio=%.2f  (%u bytes) \n",
                   clevel,
                   (double)totalSrcSlicesSize / (double)cTotalSizeNoDict, (unsigned)cTotalSizeNoDict);

   size_t* const cSizes = malloc(nbBlocks * sizeof(size_t));
   CONTROL(cSizes != NULL);

   size_t const cTotalSize = compressBlocks(cSizes, dstSlices, srcSlices, cdict, clevel);
   CONTROL(cTotalSize != 0);
   DISPLAYLEVEL(3, "compressed using a %u bytes dictionary : Ratio=%.2f  (%u bytes) \n",
                   (unsigned)dictBuffer.size,
                   (double)totalSrcSlicesSize / (double)cTotalSize, (unsigned)cTotalSize);

   /* now dstSlices contain the real compressed size of each block, instead of the maximum capacity */
   shrinkSizes(dstSlices, cSizes);

   unsigned const nbDicts = nbDictMax ? nbDictMax : nbBlocks;

   cdict_collection_t const cdictionaries = createCDictCollection(dictBuffer.ptr, dictBuffer.size, nbDicts, dictContentType, cctxParams);
   CONTROL(cdictionaries.cdicts != NULL);

   ddict_collection_t const ddictionaries = createDDictCollection(dictBuffer.ptr, dictBuffer.size, nbDicts);
   CONTROL(ddictionaries.ddicts != NULL);

   if (benchCompression) {
       size_t const dictMem = ZSTD_sizeof_CDict(cdictionaries.cdicts[0]);
       size_t const allDictMem = dictMem * nbDicts;
       DISPLAYLEVEL(3, "generating %u dictionaries, using %.1f MB of memory \n",
                       nbDicts, (double)allDictMem / (1 MB));

       shuffleCDictionaries(cdictionaries);

       buffer_collection_t resultCollection = createBufferCollection_fromSliceCollection(srcSlices);
       CONTROL(resultCollection.buffer.ptr != NULL);

       result = benchMem(dstSlices, resultCollection.slices, ddictionaries,
                         cdictionaries, nbRounds, benchCompression, exeName,
                         cctxParams, metricAggregatePref);

       freeBufferCollection(resultCollection);
   } else {
       size_t const dictMem = ZSTD_estimateDDictSize(dictBuffer.size, DICT_LOAD_METHOD);
       size_t const allDictMem = dictMem * nbDicts;
       DISPLAYLEVEL(3, "generating %u dictionaries, using %.1f MB of memory \n",
                       nbDicts, (double)allDictMem / (1 MB));

       shuffleDDictionaries(ddictionaries);

       buffer_collection_t resultCollection = createBufferCollection_fromSliceCollectionSizes(srcSlices);
       CONTROL(resultCollection.buffer.ptr != NULL);

       result = benchMem(resultCollection.slices, dstSlices, ddictionaries,
                         cdictionaries, nbRounds, benchCompression, exeName,
                         NULL, metricAggregatePref);

       freeBufferCollection(resultCollection);
   }

   /* free all heap objects in reverse order */
   freeCDictCollection(cdictionaries);
   freeDDictCollection(ddictionaries);
   free(cSizes);
   ZSTD_freeCDict(cdict);
   freeBuffer(dictBuffer);
   freeSliceCollection(dstSlices);
   freeBuffer(dstBuffer);
   freeSliceCollection(srcSlices);
   freeBufferCollection(srcs);

   return result;
}



/* ---  Command Line  --- */

/*! readU32FromChar() :
* @return : unsigned integer value read from input in `char` format.
*  allows and interprets K, KB, KiB, M, MB and MiB suffix.
*  Will also modify `*stringPtr`, advancing it to position where it stopped reading.
*  Note : function will exit() program if digit sequence overflows */
static unsigned readU32FromChar(const char** stringPtr)
{
   unsigned result = 0;
   while ((**stringPtr >='0') && (**stringPtr <='9')) {
       unsigned const max = (((unsigned)(-1)) / 10) - 1;
       assert(result <= max);   /* check overflow */
       result *= 10, result += (unsigned)**stringPtr - '0', (*stringPtr)++ ;
   }
   if ((**stringPtr=='K') || (**stringPtr=='M')) {
       unsigned const maxK = ((unsigned)(-1)) >> 10;
       assert(result <= maxK);   /* check overflow */
       result <<= 10;
       if (**stringPtr=='M') {
           assert(result <= maxK);   /* check overflow */
           result <<= 10;
       }
       (*stringPtr)++;  /* skip `K` or `M` */
       if (**stringPtr=='i') (*stringPtr)++;
       if (**stringPtr=='B') (*stringPtr)++;
   }
   return result;
}

/** longCommandWArg() :
*  check if *stringPtr is the same as longCommand.
*  If yes, @return 1 and advances *stringPtr to the position which immediately follows longCommand.
* @return 0 and doesn't modify *stringPtr otherwise.
*/
static int longCommandWArg(const char** stringPtr, const char* longCommand)
{
   size_t const comSize = strlen(longCommand);
   int const result = !strncmp(*stringPtr, longCommand, comSize);
   if (result) *stringPtr += comSize;
   return result;
}


int usage(const char* exeName)
{
   DISPLAY (" \n");
   DISPLAY (" %s [Options] filename(s) \n", exeName);
   DISPLAY (" \n");
   DISPLAY ("Options : \n");
   DISPLAY ("-z          : benchmark compression (default) \n");
   DISPLAY ("-d          : benchmark decompression \n");
   DISPLAY ("-r          : recursively load all files in subdirectories (default: off) \n");
   DISPLAY ("-B#         : split input into blocks of size # (default: no split) \n");
   DISPLAY ("-#          : use compression level # (default: %u) \n", CLEVEL_DEFAULT);
   DISPLAY ("-D #        : use # as a dictionary (default: create one) \n");
   DISPLAY ("-i#         : nb benchmark rounds (default: %u) \n", BENCH_TIME_DEFAULT_S);
   DISPLAY ("-p#         : print speed for all rounds 0=fastest 1=median (default: 0) \n");
   DISPLAY ("--nbBlocks=#: use # blocks for bench (default: one per file) \n");
   DISPLAY ("--nbDicts=# : create # dictionaries for bench (default: one per block) \n");
   DISPLAY ("-h          : help (this text) \n");
   DISPLAY (" \n");
   DISPLAY ("Advanced Options (see zstd.h for documentation) : \n");
   DISPLAY ("--dedicated-dict-search\n");
   DISPLAY ("--dict-content-type=#\n");
   DISPLAY ("--dict-attach-pref=#\n");
   return 0;
}

int bad_usage(const char* exeName)
{
   DISPLAY (" bad usage : \n");
   usage(exeName);
   return 1;
}

int main (int argc, const char** argv)
{
   int recursiveMode = 0;
   int benchCompression = 1;
   int dedicatedDictSearch = 0;
   unsigned nbRounds = BENCH_TIME_DEFAULT_S;
   const char* const exeName = argv[0];

   if (argc < 2) return bad_usage(exeName);

   const char** nameTable = (const char**)malloc((size_t)argc * sizeof(const char*));
   assert(nameTable != NULL);
   unsigned nameIdx = 0;

   const char* dictionary = NULL;
   int cLevel = CLEVEL_DEFAULT;
   size_t blockSize = BLOCKSIZE_DEFAULT;
   unsigned nbDicts = 0;  /* determine nbDicts automatically: 1 dictionary per block */
   unsigned nbBlocks = 0; /* determine nbBlocks automatically, from source and blockSize */
   ZSTD_dictContentType_e dictContentType = ZSTD_dct_auto;
   ZSTD_dictAttachPref_e dictAttachPref = ZSTD_dictDefaultAttach;
   ZSTD_paramSwitch_e prefetchCDictTables = ZSTD_ps_auto;
   metricAggregatePref_e metricAggregatePref = fastest;

   for (int argNb = 1; argNb < argc ; argNb++) {
       const char* argument = argv[argNb];
       if (!strcmp(argument, "-h")) { free(nameTable); return usage(exeName); }
       if (!strcmp(argument, "-d")) { benchCompression = 0; continue; }
       if (!strcmp(argument, "-z")) { benchCompression = 1; continue; }
       if (!strcmp(argument, "-r")) { recursiveMode = 1; continue; }
       if (!strcmp(argument, "-D")) { argNb++; assert(argNb < argc); dictionary = argv[argNb]; continue; }
       if (longCommandWArg(&argument, "-i")) { nbRounds = readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "-p")) { metricAggregatePref = (int)readU32FromChar(&argument); continue;}
       if (longCommandWArg(&argument, "--dictionary=")) { dictionary = argument; continue; }
       if (longCommandWArg(&argument, "-B")) { blockSize = readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--blockSize=")) { blockSize = readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--nbDicts=")) { nbDicts = readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--nbBlocks=")) { nbBlocks = readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--clevel=")) { cLevel = (int)readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--dedicated-dict-search")) { dedicatedDictSearch = 1; continue; }
       if (longCommandWArg(&argument, "--dict-content-type=")) { dictContentType = (int)readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--dict-attach-pref=")) { dictAttachPref = (int)readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "--prefetch-cdict-tables=")) { prefetchCDictTables = (int)readU32FromChar(&argument); continue; }
       if (longCommandWArg(&argument, "-")) { cLevel = (int)readU32FromChar(&argument); continue; }
       /* anything that's not a command is a filename */
       nameTable[nameIdx++] = argument;
   }

   FileNamesTable* filenameTable;

   if (recursiveMode) {
#ifndef UTIL_HAS_CREATEFILELIST
       assert(0);   /* missing capability, do not run */
#endif
       filenameTable = UTIL_createExpandedFNT(nameTable, nameIdx, 1 /* follow_links */);
   } else {
       filenameTable = UTIL_assembleFileNamesTable(nameTable, nameIdx, NULL);
       nameTable = NULL;  /* UTIL_createFileNamesTable() takes ownership of nameTable */
   }

   ZSTD_CCtx_params* cctxParams = ZSTD_createCCtxParams();
   ZSTD_CCtxParams_init(cctxParams, cLevel);
   ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_enableDedicatedDictSearch, dedicatedDictSearch);
   ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_nbWorkers, 0);
   ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_forceAttachDict, dictAttachPref);
   ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_prefetchCDictTables, prefetchCDictTables);

   int result =
       bench(filenameTable->fileNames, (unsigned)filenameTable->tableSize,
             dictionary, blockSize, cLevel, nbDicts, nbBlocks, nbRounds,
             benchCompression, dictContentType, cctxParams, exeName,
             metricAggregatePref);

   UTIL_freeFileNamesTable(filenameTable);
   free(nameTable);
   ZSTD_freeCCtxParams(cctxParams);

   return result;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.