lib/zstd
1
0
Fork 0
mirror of https://github.com/facebook/zstd.git synced 2025-07-30 22:23:13 +03:00
Code Activity

zwrapbench tests zlib

Browse Source
This commit is contained in:
inikep
2016-09-22 11:52:53 +02:00
parent d755717941
commit 54320ce905
1 changed files with 108 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
zlibWrapper/examples/zwrapbench.c
View File

@ -23,6 +23,8 @@
#include "datagen.h" /* RDG_genBuffer */ #include "datagen.h" /* RDG_genBuffer */
#include "xxhash.h" #include "xxhash.h"
#include "zlib.h"
/*-************************************ /*-************************************
@ -37,7 +39,7 @@
/*-************************************ /*-************************************
* Constants * Constants
**************************************/ **************************************/
#define COMPRESSOR_NAME "zlibWrapper for zstd command line interface" #define COMPRESSOR_NAME "Zstandard wrapper for zlib command line interface"
#ifndef ZSTD_VERSION #ifndef ZSTD_VERSION
# define ZSTD_VERSION "v" ZSTD_VERSION_STRING # define ZSTD_VERSION "v" ZSTD_VERSION_STRING
#endif #endif
@ -136,6 +138,8 @@ typedef struct
size_t resSize; size_t resSize;
} blockParam_t; } blockParam_t;
typedef enum { BMK_ZSTD, BMK_ZLIB } BMK_compressor;
#define MIN(a,b) ((a)<(b) ? (a) : (b)) #define MIN(a,b) ((a)<(b) ? (a) : (b))
#define MAX(a,b) ((a)>(b) ? (a) : (b)) #define MAX(a,b) ((a)>(b) ? (a) : (b))
@ -143,7 +147,7 @@ typedef struct
static int BMK_benchMem(const void* srcBuffer, size_t srcSize, static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
const char* displayName, int cLevel, const char* displayName, int cLevel,
const size_t* fileSizes, U32 nbFiles, const size_t* fileSizes, U32 nbFiles,
const void* dictBuffer, size_t dictBufferSize) const void* dictBuffer, size_t dictBufferSize, BMK_compressor compressor)
{ {
size_t const blockSize = (g_blockSize>=32 ? g_blockSize : srcSize) + (!srcSize) /* avoid div by 0 */ ; size_t const blockSize = (g_blockSize>=32 ? g_blockSize : srcSize) + (!srcSize) /* avoid div by 0 */ ;
size_t const avgSize = MIN(g_blockSize, (srcSize / nbFiles)); size_t const avgSize = MIN(g_blockSize, (srcSize / nbFiles));
@ -225,24 +229,53 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
UTIL_getTime(&clockStart); UTIL_getTime(&clockStart);
if (!cCompleted) { /* still some time to do compression tests */ if (!cCompleted) { /* still some time to do compression tests */
ZSTD_parameters const zparams = ZSTD_getParams(cLevel, avgSize, dictBufferSize);
ZSTD_customMem const cmem = { NULL, NULL, NULL };
U32 nbLoops = 0; U32 nbLoops = 0;
ZSTD_CDict* cdict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, zparams, cmem); if (compressor == BMK_ZSTD) {
if (cdict==NULL) EXM_THROW(1, "ZSTD_createCDict_advanced() allocation failure"); ZSTD_parameters const zparams = ZSTD_getParams(cLevel, avgSize, dictBufferSize);
do { ZSTD_customMem const cmem = { NULL, NULL, NULL };
U32 blockNb; ZSTD_CDict* cdict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, zparams, cmem);
for (blockNb=0; blockNb<nbBlocks; blockNb++) { if (cdict==NULL) EXM_THROW(1, "ZSTD_createCDict_advanced() allocation failure");
size_t const rSize = ZSTD_compress_usingCDict(ctx, do {
blockTable[blockNb].cPtr, blockTable[blockNb].cRoom, U32 blockNb;
blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize, for (blockNb=0; blockNb<nbBlocks; blockNb++) {
cdict); size_t const rSize = ZSTD_compress_usingCDict(ctx,
if (ZSTD_isError(rSize)) EXM_THROW(1, "ZSTD_compress_usingCDict() failed : %s", ZSTD_getErrorName(rSize)); blockTable[blockNb].cPtr, blockTable[blockNb].cRoom,
blockTable[blockNb].cSize = rSize; blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
} cdict);
nbLoops++; if (ZSTD_isError(rSize)) EXM_THROW(1, "ZSTD_compress_usingCDict() failed : %s", ZSTD_getErrorName(rSize));
} while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop); blockTable[blockNb].cSize = rSize;
ZSTD_freeCDict(cdict); }
nbLoops++;
} while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
ZSTD_freeCDict(cdict);
} else {
do {
U32 blockNb;
for (blockNb=0; blockNb<nbBlocks; blockNb++) {
z_stream def;
int ret;
def.zalloc = Z_NULL;
def.zfree = Z_NULL;
def.opaque = Z_NULL;
ret = deflateInit(&def, cLevel);
if (ret != Z_OK) EXM_THROW(1, "deflateInit failure");
// ret = ZSTD_setPledgedSrcSize(&def, 0);
// if (ret != Z_OK) EXM_THROW(1, "ZSTD_setPledgedSrcSize failure");
def.next_in = (const void*) blockTable[blockNb].srcPtr;
def.avail_in = blockTable[blockNb].srcSize;
def.total_in = 0;
def.next_out = (void*) blockTable[blockNb].cPtr;
def.avail_out = blockTable[blockNb].cRoom;
def.total_out = 0;
ret = deflate(&def, Z_FINISH);
if (ret != Z_STREAM_END) EXM_THROW(1, "deflate failure");
ret = deflateEnd(&def);
if (ret != Z_OK) EXM_THROW(1, "deflateEnd failure");
blockTable[blockNb].cSize = def.total_out;
}
nbLoops++;
} while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
}
{ U64 const clockSpan = UTIL_clockSpanMicro(clockStart, ticksPerSecond); { U64 const clockSpan = UTIL_clockSpanMicro(clockStart, ticksPerSecond);
if (clockSpan < fastestC*nbLoops) fastestC = clockSpan / nbLoops; if (clockSpan < fastestC*nbLoops) fastestC = clockSpan / nbLoops;
totalCTime += clockSpan; totalCTime += clockSpan;
@ -268,26 +301,53 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
if (!dCompleted) { if (!dCompleted) {
U32 nbLoops = 0; U32 nbLoops = 0;
ZSTD_DDict* ddict = ZSTD_createDDict(dictBuffer, dictBufferSize); if (compressor == BMK_ZSTD) {
if (!ddict) EXM_THROW(2, "ZSTD_createDDict() allocation failure"); ZSTD_DDict* ddict = ZSTD_createDDict(dictBuffer, dictBufferSize);
do { if (!ddict) EXM_THROW(2, "ZSTD_createDDict() allocation failure");
U32 blockNb; do {
for (blockNb=0; blockNb<nbBlocks; blockNb++) { U32 blockNb;
size_t const regenSize = ZSTD_decompress_usingDDict(dctx, for (blockNb=0; blockNb<nbBlocks; blockNb++) {
blockTable[blockNb].resPtr, blockTable[blockNb].srcSize, size_t const regenSize = ZSTD_decompress_usingDDict(dctx,
blockTable[blockNb].cPtr, blockTable[blockNb].cSize, blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
ddict); blockTable[blockNb].cPtr, blockTable[blockNb].cSize,
if (ZSTD_isError(regenSize)) { ddict);
DISPLAY("ZSTD_decompress_usingDDict() failed on block %u : %s \n", if (ZSTD_isError(regenSize)) {
blockNb, ZSTD_getErrorName(regenSize)); DISPLAY("ZSTD_decompress_usingDDict() failed on block %u : %s \n",
clockLoop = 0; /* force immediate test end */ blockNb, ZSTD_getErrorName(regenSize));
break; clockLoop = 0; /* force immediate test end */
break;
}
blockTable[blockNb].resSize = regenSize;
} }
blockTable[blockNb].resSize = regenSize; nbLoops++;
} } while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
nbLoops++; ZSTD_freeDDict(ddict);
} while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop); } else {
ZSTD_freeDDict(ddict); do {
U32 blockNb;
for (blockNb=0; blockNb<nbBlocks; blockNb++) {
z_stream inf;
int ret;
inf.zalloc = Z_NULL;
inf.zfree = Z_NULL;
inf.opaque = Z_NULL;
ret = inflateInit(&inf);
if (ret != Z_OK) EXM_THROW(1, "inflateInit failure");
inf.next_in = (const void*) blockTable[blockNb].cPtr;
inf.avail_in = blockTable[blockNb].cSize;
inf.total_in = 0;
inf.next_out = (void*) blockTable[blockNb].resPtr;
inf.avail_out = blockTable[blockNb].srcSize;
inf.total_out = 0;
ret = inflate(&inf, Z_FINISH);
if (ret != Z_STREAM_END) EXM_THROW(1, "inflate failure");
ret = inflateEnd(&inf);
if (ret != Z_OK) EXM_THROW(1, "inflateEnd failure");
blockTable[blockNb].resSize = inf.total_out;
}
nbLoops++;
} while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
}
{ U64 const clockSpan = UTIL_clockSpanMicro(clockStart, ticksPerSecond); { U64 const clockSpan = UTIL_clockSpanMicro(clockStart, ticksPerSecond);
if (clockSpan < fastestD*nbLoops) fastestD = clockSpan / nbLoops; if (clockSpan < fastestD*nbLoops) fastestD = clockSpan / nbLoops;
totalDTime += clockSpan; totalDTime += clockSpan;
@ -384,11 +444,20 @@ static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
if (cLevelLast < cLevel) cLevelLast = cLevel; if (cLevelLast < cLevel) cLevelLast = cLevel;
DISPLAY("benchmarking zlib %s\n", ZLIB_VERSION);
for (l=cLevel; l <= cLevelLast; l++) { for (l=cLevel; l <= cLevelLast; l++) {
BMK_benchMem(srcBuffer, benchedSize, BMK_benchMem(srcBuffer, benchedSize,
displayName, l, displayName, l,
fileSizes, nbFiles, fileSizes, nbFiles,
dictBuffer, dictBufferSize); dictBuffer, dictBufferSize, BMK_ZLIB);
}
DISPLAY("benchmarking zstd %s\n", ZSTD_VERSION_STRING);
for (l=cLevel; l <= cLevelLast; l++) {
BMK_benchMem(srcBuffer, benchedSize,
displayName, l,
fileSizes, nbFiles,
dictBuffer, dictBufferSize, BMK_ZSTD);
} }
} }