ddidderr/zstd-rs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make paramgrill use bench.c benchmarking

Browse Source
This commit is contained in:
George Lu
2018-06-08 12:01:05 -07:00
parent 8ef75547ef
commit 0e808d608b
5 changed files with 225 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files
programs/bench.c
+132 -52
View File
@@ -41,6 +41,7 @@
#include "zstd.h"
#include "datagen.h" /* RDG_genBuffer */
#include "xxhash.h"
#include "bench.h"
/* *************************************
@@ -71,6 +72,7 @@ static U32 g_compressibilityDefault = 50;
***************************************/
#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
#define DISPLAYLEVELP(l, ...) if (g_displayLevel>=l && printable) { DISPLAY(__VA_ARGS__); }
static int g_displayLevel = 2; /* 0 : no display; 1: errors; 2 : + result + interaction + warnings; 3 : + progression; 4 : + information */
static const U64 g_refreshRate = SEC_TO_MICRO / 6;
@@ -91,9 +93,9 @@ static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
#define DEBUGOUTPUT(...) { if (DEBUG) DISPLAY(__VA_ARGS__); }
#define EXM_THROW(error, ...) { \
DEBUGOUTPUT("%s: %i: \n", __FILE__, __LINE__); \
DISPLAYLEVEL(1, "Error %i : ", error); \
DISPLAYLEVEL(1, __VA_ARGS__); \
DISPLAYLEVEL(1, " \n"); \
DISPLAYLEVELP(1, "Error %i : ", error); \
DISPLAYLEVELP(1, __VA_ARGS__); \
DISPLAYLEVELP(1, " \n"); \
exit(error); \
}
@@ -168,7 +170,6 @@ void BMK_setLdmHashEveryLog(unsigned ldmHashEveryLog) {
g_ldmHashEveryLog = ldmHashEveryLog;
}
/* ********************************************************
* Bench functions
**********************************************************/
@@ -182,18 +183,17 @@ typedef struct {
size_t resSize;
} blockParam_t;
#undef MIN
#undef MAX
#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,
BMK_result_t 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,
const ZSTD_compressionParameters* const comprParams)
const ZSTD_compressionParameters* const comprParams,
ZSTD_CCtx* ctx, ZSTD_DCtx* dctx, int printable)
{
size_t const blockSize = ((g_blockSize>=32 && !g_decodeOnly) ? g_blockSize : srcSize) + (!srcSize) /* avoid div by 0 */ ;
U32 const maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;
@@ -201,13 +201,16 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
size_t const maxCompressedSize = ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024); /* add some room for safety */
void* const compressedBuffer = malloc(maxCompressedSize);
void* resultBuffer = malloc(srcSize);
ZSTD_CCtx* const ctx = ZSTD_createCCtx();
ZSTD_DCtx* const dctx = ZSTD_createDCtx();
BMK_result_t results;
size_t const loadedCompressedSize = srcSize;
size_t cSize = 0;
double ratio = 0.;
U32 nbBlocks;
assert(ctx != NULL);
assert(dctx != NULL);
/* checks */
if (!compressedBuffer || !resultBuffer || !blockTable || !ctx || !dctx)
EXM_THROW(31, "allocation error : not enough memory");
@@ -281,19 +284,19 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
U32 markNb = 0;
coolTime = UTIL_getTime();
DISPLAYLEVEL(2, "\r%79s\r", "");
DISPLAYLEVELP(2, "\r%79s\r", "");
while (!cCompleted || !dCompleted) {
/* overheat protection */
if (UTIL_clockSpanMicro(coolTime) > ACTIVEPERIOD_MICROSEC) {
DISPLAYLEVEL(2, "\rcooling down ... \r");
DISPLAYLEVELP(2, "\rcooling down ... \r");
UTIL_sleep(COOLPERIOD_SEC);
coolTime = UTIL_getTime();
}
if (!g_decodeOnly) {
/* Compression */
DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->\r", marks[markNb], displayName, (U32)srcSize);
DISPLAYLEVELP(2, "%2s-%-17.17s :%10u ->\r", marks[markNb], displayName, (U32)srcSize);
if (!cCompleted) memset(compressedBuffer, 0xE5, maxCompressedSize); /* warm up and erase result buffer */
UTIL_sleepMilli(5); /* give processor time to other processes */
@@ -369,11 +372,13 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
cSize = 0;
{ U32 blockNb; for (blockNb=0; blockNb<nbBlocks; blockNb++) cSize += blockTable[blockNb].cSize; }
ratio = (double)srcSize / (double)cSize;
results.cSize = cSize;
markNb = (markNb+1) % NB_MARKS;
{ int const ratioAccuracy = (ratio < 10.) ? 3 : 2;
double const compressionSpeed = ((double)srcSize / fastestC) * 1000;
int const cSpeedAccuracy = (compressionSpeed < 10.) ? 2 : 1;
DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.*f),%6.*f MB/s\r",
results.cSpeed = compressionSpeed * 1000000;
DISPLAYLEVELP(2, "%2s-%-17.17s :%10u ->%10u (%5.*f),%6.*f MB/s\r",
marks[markNb], displayName, (U32)srcSize, (U32)cSize,
ratioAccuracy, ratio,
cSpeedAccuracy, compressionSpeed );
@@ -428,7 +433,9 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
double const compressionSpeed = ((double)srcSize / fastestC) * 1000;
int const cSpeedAccuracy = (compressionSpeed < 10.) ? 2 : 1;
double const decompressionSpeed = ((double)srcSize / fastestD) * 1000;
DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.*f),%6.*f MB/s ,%6.1f MB/s \r",
results.cSpeed = compressionSpeed * 1000000;
results.dSpeed = decompressionSpeed * 1000000;
DISPLAYLEVELP(2, "%2s-%-17.17s :%10u ->%10u (%5.*f),%6.*f MB/s ,%6.1f MB/s \r",
marks[markNb], displayName, (U32)srcSize, (U32)cSize,
ratioAccuracy, ratio,
cSpeedAccuracy, compressionSpeed,
@@ -483,18 +490,67 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
else
DISPLAY("-%-3i%11i (%5.3f) %6.2f MB/s %6.1f MB/s %s\n", cLevel, (int)cSize, ratio, cSpeed, dSpeed, displayName);
}
DISPLAYLEVEL(2, "%2i#\n", cLevel);
DISPLAYLEVELP(2, "%2i#\n", cLevel);
} /* Bench */
/* clean up */
free(blockTable);
free(compressedBuffer);
free(resultBuffer);
ZSTD_freeCCtx(ctx);
ZSTD_freeDCtx(dctx);
return 0;
return results;
}
/*
* combines multiple results into single
* currently normal averaging
* consider weighing by file size? or maybe by total time?
* size is cumulative though
*/
static BMK_result_t BMK_average(BMK_result_t* results, const int count, const size_t* sampleSizes) {
double cSpeedTotal = 0;
double dSpeedTotal = 0;
size_t cSizeTotal = 0;
BMK_result_t returnval;
int i;
if (sampleSizes == NULL) {
for(i = 0; i < count; i++) {
cSpeedTotal += results[i].cSpeed;
dSpeedTotal += results[i].dSpeed;
cSizeTotal += results[i].cSize;
}
returnval.cSpeed = cSpeedTotal / count;
returnval.dSpeed = dSpeedTotal / count;
returnval.cSize = cSizeTotal;
} else {
size_t sSizeTotal = 0;
/* in this case, SpeedTotal will keep track of total time used */
for(i = 0; i < count; i++) {
cSpeedTotal += sampleSizes[i] / results[i].cSpeed;
dSpeedTotal += sampleSizes[i] / results[i].cSpeed;
cSizeTotal += results[i].cSize;
sSizeTotal += sampleSizes[i];
}
returnval.cSpeed = (double)sSizeTotal / cSpeedTotal;
returnval.dSpeed = (double)sSizeTotal / dSpeedTotal;
returnval.cSize = cSizeTotal;
}
return returnval;
}
static BMK_result_t BMK_benchMemCtxless(const void* srcBuffer, size_t srcSize,
const char* displayName, int cLevel,
const size_t* fileSizes, U32 nbFiles,
const void* dictBuffer, size_t dictBufferSize,
const ZSTD_compressionParameters* const comprParams, int printable)
{
BMK_result_t returnval;
ZSTD_CCtx* ctx = ZSTD_createCCtx();
ZSTD_DCtx* dctx = ZSTD_createDCtx();
returnval = BMK_benchMem(srcBuffer, srcSize, displayName, cLevel, fileSizes, nbFiles, dictBuffer, dictBufferSize, comprParams, ctx, dctx, printable);
ZSTD_freeCCtx(ctx);
ZSTD_freeDCtx(dctx);
return returnval;
}
static size_t BMK_findMaxMem(U64 requiredMem)
{
@@ -514,20 +570,28 @@ static size_t BMK_findMaxMem(U64 requiredMem)
return (size_t)(requiredMem);
}
static void BMK_benchCLevel(const void* srcBuffer, size_t benchedSize,
/* returns average stats over all range [cLevel, cLevelLast] */
static BMK_result_t BMK_benchCLevel(const void* srcBuffer, size_t benchedSize,
const char* displayName, int cLevel, int cLevelLast,
const size_t* fileSizes, unsigned nbFiles,
const void* dictBuffer, size_t dictBufferSize,
const ZSTD_compressionParameters* const compressionParams)
const ZSTD_compressionParameters* const compressionParams,
int printable)
{
int l;
BMK_result_t returnval;
BMK_result_t* resultarray = (BMK_result_t*)malloc(sizeof(BMK_result_t) * (cLevelLast - cLevel + 1));
const char* pch = strrchr(displayName, '\\'); /* Windows */
if (!pch) pch = strrchr(displayName, '/'); /* Linux */
if (pch) displayName = pch+1;
if(resultarray == NULL) EXM_THROW(12, "Not enough memory");
returnval.cSpeed = 0;
returnval.dSpeed = 0;
returnval.cSize = 0;
if (g_realTime) {
DISPLAYLEVEL(2, "Note : switching to real-time priority \n");
DISPLAYLEVELP(2, "Note : switching to real-time priority \n");
SET_REALTIME_PRIORITY;
}
@@ -536,11 +600,13 @@ static void BMK_benchCLevel(const void* srcBuffer, size_t benchedSize,
for (l=cLevel; l <= cLevelLast; l++) {
if (l==0) continue; /* skip level 0 */
BMK_benchMem(srcBuffer, benchedSize,
displayName, l,
fileSizes, nbFiles,
dictBuffer, dictBufferSize, compressionParams);
resultarray[l - cLevel] = BMK_benchMemCtxless(srcBuffer, benchedSize,
displayName, l, fileSizes, nbFiles,
dictBuffer, dictBufferSize, compressionParams, printable);
}
returnval = BMK_average(resultarray, cLevelLast - cLevel + 1, NULL);
free(resultarray);
return returnval;
}
@@ -548,8 +614,8 @@ static void BMK_benchCLevel(const void* srcBuffer, size_t benchedSize,
* 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* const * const fileNamesTable, unsigned nbFiles)
size_t* fileSizes, const char* const * const fileNamesTable,
unsigned nbFiles, int printable)
{
size_t pos = 0, totalSize = 0;
unsigned n;
@@ -557,12 +623,12 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
FILE* f;
U64 fileSize = UTIL_getFileSize(fileNamesTable[n]);
if (UTIL_isDirectory(fileNamesTable[n])) {
DISPLAYLEVEL(2, "Ignoring %s directory... \n", fileNamesTable[n]);
DISPLAYLEVELP(2, "Ignoring %s directory... \n", fileNamesTable[n]);
fileSizes[n] = 0;
continue;
}
if (fileSize == UTIL_FILESIZE_UNKNOWN) {
DISPLAYLEVEL(2, "Cannot evaluate size of %s, ignoring ... \n", fileNamesTable[n]);
DISPLAYLEVELP(2, "Cannot evaluate size of %s, ignoring ... \n", fileNamesTable[n]);
fileSizes[n] = 0;
continue;
}
@@ -581,16 +647,16 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
if (totalSize == 0) EXM_THROW(12, "no data to bench");
}
static void BMK_benchFileTable(const char* const * const fileNamesTable, unsigned const nbFiles,
const char* const dictFileName,
int const cLevel, int const cLevelLast,
const ZSTD_compressionParameters* const compressionParams)
static BMK_result_t BMK_benchFileTable(const char* const * const fileNamesTable, unsigned const nbFiles,
const char* const dictFileName, int const cLevel, int const cLevelLast,
const ZSTD_compressionParameters* const compressionParams, int printable)
{
void* srcBuffer;
size_t benchedSize;
void* dictBuffer = NULL;
size_t dictBufferSize = 0;
size_t* const fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
BMK_result_t returnval;
U64 const totalSizeToLoad = UTIL_getTotalFileSize(fileNamesTable, nbFiles);
if (!fileSizes) EXM_THROW(12, "not enough memory for fileSizes");
@@ -605,7 +671,7 @@ static void BMK_benchFileTable(const char* const * const fileNamesTable, unsigne
if (dictBuffer==NULL)
EXM_THROW(11, "not enough memory for dictionary (%u bytes)",
(U32)dictBufferSize);
BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1);
BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1, printable);
}
/* Memory allocation & restrictions */
@@ -617,43 +683,50 @@ static void BMK_benchFileTable(const char* const * const fileNamesTable, unsigne
if (!srcBuffer) EXM_THROW(12, "not enough memory");
/* Load input buffer */
BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles);
BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles, printable);
/* Bench */
if (g_separateFiles) {
const BYTE* srcPtr = (const BYTE*)srcBuffer;
U32 fileNb;
BMK_result_t* resultarray = (BMK_result_t*)malloc(sizeof(BMK_result_t) * nbFiles);
if(resultarray == NULL) EXM_THROW(12, "not enough memory");
for (fileNb=0; fileNb<nbFiles; fileNb++) {
size_t const fileSize = fileSizes[fileNb];
BMK_benchCLevel(srcPtr, fileSize,
resultarray[fileNb] = BMK_benchCLevel(srcPtr, fileSize,
fileNamesTable[fileNb], cLevel, cLevelLast,
fileSizes+fileNb, 1,
dictBuffer, dictBufferSize, compressionParams);
fileSizes+fileNb, 1, dictBuffer, dictBufferSize,
compressionParams,printable);
srcPtr += fileSize;
}
returnval = BMK_average(resultarray, nbFiles, fileSizes);
free(resultarray);
} else {
char mfName[20] = {0};
snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
{ const char* const displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
BMK_benchCLevel(srcBuffer, benchedSize,
returnval = BMK_benchCLevel(srcBuffer, benchedSize,
displayName, cLevel, cLevelLast,
fileSizes, nbFiles,
dictBuffer, dictBufferSize, compressionParams);
fileSizes, nbFiles, dictBuffer, dictBufferSize,
compressionParams, printable);
} }
/* clean up */
free(srcBuffer);
free(dictBuffer);
free(fileSizes);
return returnval;
}
static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility,
const ZSTD_compressionParameters* compressionParams)
static BMK_result_t BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility,
const ZSTD_compressionParameters* compressionParams,
int printable)
{
char name[20] = {0};
size_t benchedSize = 10000000;
void* const srcBuffer = malloc(benchedSize);
BMK_result_t returnval;
/* Memory allocation */
if (!srcBuffer) EXM_THROW(21, "not enough memory");
@@ -663,17 +736,17 @@ static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility
/* Bench */
snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1, NULL, 0, compressionParams);
returnval = BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1, NULL, 0, compressionParams, printable);
/* clean up */
free(srcBuffer);
return returnval;
}
int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
const char* dictFileName,
int cLevel, int cLevelLast,
const ZSTD_compressionParameters* compressionParams)
BMK_result_t BMK_benchFilesFull(const char** fileNamesTable, unsigned nbFiles,
const char* dictFileName, int cLevel, int cLevelLast,
const ZSTD_compressionParameters* compressionParams, int printable)
{
double const compressibility = (double)g_compressibilityDefault / 100;
@@ -681,11 +754,18 @@ int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
if (cLevelLast > ZSTD_maxCLevel()) cLevelLast = ZSTD_maxCLevel();
if (cLevelLast < cLevel) cLevelLast = cLevel;
if (cLevelLast > cLevel)
DISPLAYLEVEL(2, "Benchmarking levels from %d to %d\n", cLevel, cLevelLast);
DISPLAYLEVELP(2, "Benchmarking levels from %d to %d\n", cLevel, cLevelLast);
if (nbFiles == 0)
BMK_syntheticTest(cLevel, cLevelLast, compressibility, compressionParams);
return BMK_syntheticTest(cLevel, cLevelLast, compressibility, compressionParams, printable);
else
BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast, compressionParams);
return BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast, compressionParams, printable);
}
int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
const char* dictFileName,
int cLevel, int cLevelLast,
const ZSTD_compressionParameters* compressionParams) {
BMK_benchFilesFull(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast, compressionParams, 1);
return 0;
}
programs/bench.h
+19
View File
@@ -16,9 +16,28 @@
#define ZSTD_STATIC_LINKING_ONLY /* ZSTD_compressionParameters */
#include "zstd.h" /* ZSTD_compressionParameters */
typedef struct {
size_t cSize;
double cSpeed; /* bytes / sec */
double dSpeed;
} BMK_result_t;
/* called in cli */
int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName,
int cLevel, int cLevelLast, const ZSTD_compressionParameters* compressionParams);
/* more options */
BMK_result_t BMK_benchFilesFull(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName,
int cLevel, int cLevelLast, const ZSTD_compressionParameters* compressionParams,
int printable);
/* basic benchmarking function, called in paramgrill
* results, cctx, dctx, dictbuffer can be null or passed in */
BMK_result_t BMK_benchMem(const void* srcBuffer, size_t srcSize, const char* displayName, int cLevel,
const size_t* fileSizes, unsigned nbFiles, const void* dictBuffer, size_t dictBufferSize,
const ZSTD_compressionParameters* const comprParams, ZSTD_CCtx* ctx, ZSTD_DCtx* dctx,
int printable);
/* Set Parameters */
void BMK_setNbSeconds(unsigned nbLoops);
void BMK_setBlockSize(size_t blockSize);