fullbench.c File Reference

#include "platform.h"
#include "util.h"
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <time.h>
#include "lz4.h"
#include "lz4hc.h"
#include "lz4frame.h"
#include "xxhash.h"

Go to the source code of this file.

Classes
struct	chunkParameters

Macros
#define	LZ4_DISABLE_DEPRECATE_WARNINGS   /* LZ4_decompress_fast */
#define	PROGRAM_DESCRIPTION   "LZ4 speed analyzer"
#define	AUTHOR   "Yann Collet"
#define	WELCOME_MESSAGE   "*** %s v%s %i-bits, by %s ***\n", PROGRAM_DESCRIPTION, LZ4_VERSION_STRING, (int)(sizeof(void*)*8), AUTHOR
#define	NBLOOPS   6
#define	TIMELOOP   (CLOCKS_PER_SEC * 25 / 10)
#define	KB   *(1 <<10)
#define	MB   *(1 <<20)
#define	GB   *(1U<<30)
#define	KNUTH   2654435761U
#define	MAX_MEM   (1920 MB)
#define	DEFAULT_CHUNKSIZE   (4 MB)
#define	ALL_COMPRESSORS   0
#define	ALL_DECOMPRESSORS   0
#define	DISPLAY(...)   fprintf(stderr, __VA_ARGS__)
#define	PROGRESS(...)   g_noPrompt ? 0 : DISPLAY(__VA_ARGS__)
#define	NB_COMPRESSION_ALGORITHMS   100
#define	NB_DECOMPRESSION_ALGORITHMS   100

Functions
static void	BMK_setBlocksize (int bsize)
static void	BMK_setNbIterations (int nbLoops)
static void	BMK_setPause (void)
static clock_t	BMK_GetClockSpan (clock_t clockStart)
static size_t	BMK_findMaxMem (U64 requiredMem)
void *	LZ4_malloc (size_t s)
void *	LZ4_calloc (size_t n, size_t s)
void	LZ4_free (void *p)
static void	local_LZ4_resetDictT (void)
static void	local_LZ4_createStream (void)
static int	local_LZ4_saveDict (const char *in, char *out, int inSize)
static int	local_LZ4_compress_default_large (const char *in, char *out, int inSize)
static int	local_LZ4_compress_default_small (const char *in, char *out, int inSize)
static int	local_LZ4_compress_destSize (const char *in, char *out, int inSize)
static int	local_LZ4_compress_fast0 (const char *in, char *out, int inSize)
static int	local_LZ4_compress_fast1 (const char *in, char *out, int inSize)
static int	local_LZ4_compress_fast2 (const char *in, char *out, int inSize)
static int	local_LZ4_compress_fast17 (const char *in, char *out, int inSize)
static int	local_LZ4_compress_fast_extState0 (const char *in, char *out, int inSize)
static int	local_LZ4_compress_fast_continue0 (const char *in, char *out, int inSize)
int	LZ4_compress_forceExtDict (LZ4_stream_t *LZ4_stream, const char *source, char *dest, int inputSize)
static int	local_LZ4_compress_forceDict (const char *in, char *out, int inSize)
static void	local_LZ4_resetStreamHC (void)
static int	local_LZ4_saveDictHC (const char *in, char *out, int inSize)
static int	local_LZ4_compress_HC (const char *in, char *out, int inSize)
static int	local_LZ4_compress_HC_extStateHC (const char *in, char *out, int inSize)
static int	local_LZ4_compress_HC_continue (const char *in, char *out, int inSize)
static int	local_LZ4_decompress_fast (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4_decompress_fast_usingDict_prefix (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4_decompress_fast_usingExtDict (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4_decompress_safe_withPrefix64k (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4_decompress_safe_usingDict (const char *in, char *out, int inSize, int outSize)
int	LZ4_decompress_safe_forceExtDict (const char *in, char *out, int inSize, int outSize, const void *dict, size_t dictSize)
static int	local_LZ4_decompress_safe_forceExtDict (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4_decompress_safe_partial (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4F_compressFrame (const char *in, char *out, int inSize)
static int	local_LZ4F_decompress (const char *in, char *out, int inSize, int outSize)
static int	local_LZ4F_decompress_followHint (const char *src, char *dst, int srcSize, int dstSize)
static int	local_LZ4F_decompress_noHint (const char *src, char *dst, int srcSize, int dstSize)
int	fullSpeedBench (const char **fileNamesTable, int nbFiles)
static int	usage (const char *exename)
static int	usage_advanced (void)
static int	badusage (const char *exename)
int	main (int argc, const char **argv)

Variables
static int	g_chunkSize = DEFAULT_CHUNKSIZE
static int	g_nbIterations = NBLOOPS
static int	g_pause = 0
static int	g_compressionTest = 1
static int	g_compressionAlgo = ALL_COMPRESSORS
static int	g_decompressionTest = 1
static int	g_decompressionAlgo = ALL_DECOMPRESSORS
static int	g_noPrompt = 0
static LZ4_stream_t	LZ4_stream
LZ4_streamHC_t	LZ4_streamHC
static LZ4F_decompressionContext_t	g_dCtx

Macro Definition Documentation

ALL_COMPRESSORS

#define ALL_COMPRESSORS   0

Definition at line 71 of file fullbench.c.

ALL_DECOMPRESSORS

#define ALL_DECOMPRESSORS   0

Definition at line 72 of file fullbench.c.

AUTHOR

#define AUTHOR   "Yann Collet"

Definition at line 57 of file fullbench.c.

DEFAULT_CHUNKSIZE

#define DEFAULT_CHUNKSIZE   (4 MB)

Definition at line 69 of file fullbench.c.

DISPLAY

#define DISPLAY

(

...

)

fprintf(stderr, __VA_ARGS__)

Definition at line 91 of file fullbench.c.

GB

#define GB   *(1U<<30)

Definition at line 65 of file fullbench.c.

KB

#define KB   *(1 <<10)

Definition at line 63 of file fullbench.c.

KNUTH

#define KNUTH   2654435761U

Definition at line 67 of file fullbench.c.

LZ4_DISABLE_DEPRECATE_WARNINGS

#define LZ4_DISABLE_DEPRECATE_WARNINGS   /* LZ4_decompress_fast */

Definition at line 45 of file fullbench.c.

MAX_MEM

#define MAX_MEM   (1920 MB)

Definition at line 68 of file fullbench.c.

MB

#define MB   *(1 <<20)

Definition at line 64 of file fullbench.c.

NB_COMPRESSION_ALGORITHMS

#define NB_COMPRESSION_ALGORITHMS   100

Definition at line 431 of file fullbench.c.

NB_DECOMPRESSION_ALGORITHMS

#define NB_DECOMPRESSION_ALGORITHMS   100

Definition at line 432 of file fullbench.c.

NBLOOPS

#define NBLOOPS   6

Definition at line 60 of file fullbench.c.

PROGRAM_DESCRIPTION

#define PROGRAM_DESCRIPTION   "LZ4 speed analyzer"

Definition at line 56 of file fullbench.c.

PROGRESS

#define PROGRESS

(

...

)

g_noPrompt ? 0 : DISPLAY(__VA_ARGS__)

Definition at line 92 of file fullbench.c.

TIMELOOP

#define TIMELOOP   (CLOCKS_PER_SEC * 25 / 10)

Definition at line 61 of file fullbench.c.

WELCOME_MESSAGE

#define WELCOME_MESSAGE   "*** %s v%s %i-bits, by %s ***\n", PROGRAM_DESCRIPTION, LZ4_VERSION_STRING, (int)(sizeof(void*)*8), AUTHOR

Definition at line 58 of file fullbench.c.

Function Documentation

badusage()

static int badusage ( const char *  exename )

static

Definition at line 760 of file fullbench.c.

{
    DISPLAY("Wrong parameters\n");
    usage(exename);
    return 0;
}

References DISPLAY, and usage().

Referenced by main().

BMK_findMaxMem()

static size_t BMK_findMaxMem ( U64  requiredMem )

static

Definition at line 134 of file fullbench.c.

{
    size_t step = 64 MB;
    BYTE* testmem = NULL;
 
    requiredMem = (((requiredMem >> 26) + 1) << 26);
    requiredMem += 2*step;
    if (requiredMem > MAX_MEM) requiredMem = MAX_MEM;
 
    while (!testmem) {
        if (requiredMem > step) requiredMem -= step;
        else requiredMem >>= 1;
        testmem = (BYTE*) malloc ((size_t)requiredMem);
    }
    free (testmem);
 
    /* keep some space available */
    if (requiredMem > step) requiredMem -= step;
    else requiredMem >>= 1;
 
    return (size_t)requiredMem;
}

References free(), malloc(), MAX_MEM, MB, NULL, and step().

Referenced by fullSpeedBench().

BMK_GetClockSpan()

static clock_t BMK_GetClockSpan ( clock_t  clockStart )

static

Definition at line 128 of file fullbench.c.

{
    return clock() - clockStart;   /* works even if overflow; max span ~30 mn */
}

Referenced by fullSpeedBench().

BMK_setBlocksize()

static void BMK_setBlocksize ( int  bsize )

static

Definition at line 107 of file fullbench.c.

{
    g_chunkSize = bsize;
    DISPLAY("-Using Block Size of %i KB-\n", g_chunkSize>>10);
}

References DISPLAY, and g_chunkSize.

Referenced by main().

BMK_setNbIterations()

static void BMK_setNbIterations ( int  nbLoops )

static

Definition at line 113 of file fullbench.c.

{
    g_nbIterations = nbLoops;
    DISPLAY("- %i iterations -\n", g_nbIterations);
}

References DISPLAY, and g_nbIterations.

Referenced by main().

BMK_setPause()

static void BMK_setPause ( void  )

static

Definition at line 119 of file fullbench.c.

{
    g_pause = 1;
}

References g_pause.

Referenced by main().

fullSpeedBench()

int fullSpeedBench	(	const char **	fileNamesTable,
		int	nbFiles
	)

Definition at line 433 of file fullbench.c.

{
    int fileIdx=0;
 
    /* Init */
    { size_t const errorCode = LZ4F_createDecompressionContext(&g_dCtx, LZ4F_VERSION);
      if (LZ4F_isError(errorCode)) { DISPLAY("dctx allocation issue \n"); return 10; } }
 
    /* Loop for each fileName */
    while (fileIdx<nbFiles) {
      char* orig_buff = NULL;
      struct chunkParameters* chunkP = NULL;
      char* compressed_buff=NULL;
      const char* const inFileName = fileNamesTable[fileIdx++];
      FILE* const inFile = fopen( inFileName, "rb" );
      U64 const inFileSize = UTIL_getFileSize(inFileName);
      size_t benchedSize = BMK_findMaxMem(inFileSize*2) / 2;   /* because 2 buffers */
      int nbChunks;
      int maxCompressedChunkSize;
      size_t readSize;
      int compressedBuffSize;
      U32 crcOriginal;
 
      /* Check infile pre-requisites */
      if (inFile==NULL) { DISPLAY("Pb opening %s \n", inFileName); return 11; }
      if (inFileSize==0) { DISPLAY("file is empty \n"); fclose(inFile); return 11; }
      if (benchedSize==0) { DISPLAY("not enough memory \n"); fclose(inFile); return 11; }
 
      /* Memory size adjustments */
      if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
      if (benchedSize < inFileSize) {
          DISPLAY("Not enough memory for '%s' full size; testing %i MB only... \n",
                inFileName, (int)(benchedSize>>20));
      }
 
      /* Allocation */
      chunkP = (struct chunkParameters*) malloc(((benchedSize / (size_t)g_chunkSize)+1) * sizeof(struct chunkParameters));
      orig_buff = (char*) malloc(benchedSize);
      nbChunks = (int) ((benchedSize + (size_t)g_chunkSize - 1) / (size_t)g_chunkSize);
      maxCompressedChunkSize = LZ4_compressBound(g_chunkSize);
      compressedBuffSize = nbChunks * maxCompressedChunkSize;
      compressed_buff = (char*)malloc((size_t)compressedBuffSize);
      if(!chunkP || !orig_buff || !compressed_buff) {
          DISPLAY("\nError: not enough memory! \n");
          fclose(inFile);
          free(orig_buff);
          free(compressed_buff);
          free(chunkP);
          return(12);
      }
 
      /* Fill in src buffer */
      DISPLAY("Loading %s...       \r", inFileName);
      readSize = fread(orig_buff, 1, benchedSize, inFile);
      fclose(inFile);
 
      if (readSize != benchedSize) {
        DISPLAY("\nError: problem reading file '%s' !!    \n", inFileName);
        free(orig_buff);
        free(compressed_buff);
        free(chunkP);
        return 13;
      }
 
      /* Calculating input Checksum */
      crcOriginal = XXH32(orig_buff, benchedSize,0);
 
 
      /* Bench */
      { int loopNb, nb_loops, chunkNb, cAlgNb, dAlgNb;
        size_t cSize=0;
        double ratio=0.;
 
        DISPLAY("\r%79s\r", "");
        DISPLAY(" %s : \n", inFileName);
 
        /* Bench Compression Algorithms */
        for (cAlgNb=0; (cAlgNb <= NB_COMPRESSION_ALGORITHMS) && (g_compressionTest); cAlgNb++) {
            const char* compressorName;
            int (*compressionFunction)(const char*, char*, int);
            void (*initFunction)(void) = NULL;
            double bestTime = 100000000.;
 
            /* filter compressionAlgo only */
            if ((g_compressionAlgo != ALL_COMPRESSORS) && (g_compressionAlgo != cAlgNb)) continue;
 
            /* Init data chunks */
            {   int i;
                size_t remaining = benchedSize;
                char* in = orig_buff;
                char* out = compressed_buff;
                assert(nbChunks >= 1);
                for (i=0; i<nbChunks; i++) {
                    chunkP[i].id = (U32)i;
                    chunkP[i].origBuffer = in; in += g_chunkSize;
                    assert(g_chunkSize > 0);
                    if (remaining > (size_t)g_chunkSize) {
                        chunkP[i].origSize = g_chunkSize;
                        remaining -= (size_t)g_chunkSize;
                    } else {
                        chunkP[i].origSize = (int)remaining;
                        remaining = 0;
                    }
                    chunkP[i].compressedBuffer = out; out += maxCompressedChunkSize;
                    chunkP[i].compressedSize = 0;
                }
            }
 
            switch(cAlgNb)
            {
            case 0 : DISPLAY("Compression functions : \n"); continue;
            case 1 : compressionFunction = local_LZ4_compress_default_large; compressorName = "LZ4_compress_default"; break;
            case 2 : compressionFunction = local_LZ4_compress_default_small; compressorName = "LZ4_compress_default(small dst)"; break;
            case 3 : compressionFunction = local_LZ4_compress_destSize; compressorName = "LZ4_compress_destSize"; break;
            case 4 : compressionFunction = local_LZ4_compress_fast0; compressorName = "LZ4_compress_fast(0)"; break;
            case 5 : compressionFunction = local_LZ4_compress_fast1; compressorName = "LZ4_compress_fast(1)"; break;
            case 6 : compressionFunction = local_LZ4_compress_fast2; compressorName = "LZ4_compress_fast(2)"; break;
            case 7 : compressionFunction = local_LZ4_compress_fast17; compressorName = "LZ4_compress_fast(17)"; break;
            case 8 : compressionFunction = local_LZ4_compress_fast_extState0; compressorName = "LZ4_compress_fast_extState(0)"; break;
            case 9 : compressionFunction = local_LZ4_compress_fast_continue0; initFunction = local_LZ4_createStream; compressorName = "LZ4_compress_fast_continue(0)"; break;
 
            case 10: compressionFunction = local_LZ4_compress_HC; compressorName = "LZ4_compress_HC"; break;
            case 12: compressionFunction = local_LZ4_compress_HC_extStateHC; compressorName = "LZ4_compress_HC_extStateHC"; break;
            case 14: compressionFunction = local_LZ4_compress_HC_continue; initFunction = local_LZ4_resetStreamHC; compressorName = "LZ4_compress_HC_continue"; break;
#ifndef LZ4_DLL_IMPORT
            case 20: compressionFunction = local_LZ4_compress_forceDict; initFunction = local_LZ4_resetDictT; compressorName = "LZ4_compress_forceDict"; break;
#endif
            case 30: compressionFunction = local_LZ4F_compressFrame; compressorName = "LZ4F_compressFrame";
                        chunkP[0].origSize = (int)benchedSize; nbChunks=1;
                        break;
            case 40: compressionFunction = local_LZ4_saveDict; compressorName = "LZ4_saveDict";
                        if (chunkP[0].origSize < 8) { DISPLAY(" cannot bench %s with less then 8 bytes \n", compressorName); continue; }
                        LZ4_loadDict(&LZ4_stream, chunkP[0].origBuffer, chunkP[0].origSize);
                        break;
            case 41: compressionFunction = local_LZ4_saveDictHC; compressorName = "LZ4_saveDictHC";
                        if (chunkP[0].origSize < 8) { DISPLAY(" cannot bench %s with less then 8 bytes \n", compressorName); continue; }
                        LZ4_loadDictHC(&LZ4_streamHC, chunkP[0].origBuffer, chunkP[0].origSize);
                        break;
            default :
                continue;   /* unknown ID : just skip */
            }
 
            for (loopNb = 1; loopNb <= g_nbIterations; loopNb++) {
                double averageTime;
                clock_t clockTime;
 
                PROGRESS("%2i-%-34.34s :%10i ->\r", loopNb, compressorName, (int)benchedSize);
                { size_t i; for (i=0; i<benchedSize; i++) compressed_buff[i]=(char)i; }     /* warming up memory */
 
                nb_loops = 0;
                clockTime = clock();
                while(clock() == clockTime);
                clockTime = clock();
                while(BMK_GetClockSpan(clockTime) < TIMELOOP) {
                    if (initFunction!=NULL) initFunction();
                    for (chunkNb=0; chunkNb<nbChunks; chunkNb++) {
                        chunkP[chunkNb].compressedSize = compressionFunction(chunkP[chunkNb].origBuffer, chunkP[chunkNb].compressedBuffer, chunkP[chunkNb].origSize);
                        if (chunkP[chunkNb].compressedSize==0) {
                            DISPLAY("ERROR ! %s() = 0 !! \n", compressorName);
                            exit(1);
                    }   }
                    nb_loops++;
                }
                clockTime = BMK_GetClockSpan(clockTime);
 
                nb_loops += !nb_loops;   /* avoid division by zero */
                averageTime = ((double)clockTime) / nb_loops / CLOCKS_PER_SEC;
                if (averageTime < bestTime) bestTime = averageTime;
                cSize=0; for (chunkNb=0; chunkNb<nbChunks; chunkNb++) cSize += (size_t)chunkP[chunkNb].compressedSize;
                ratio = (double)cSize/(double)benchedSize*100.;
                PROGRESS("%2i-%-34.34s :%10i ->%9i (%5.2f%%),%7.1f MB/s\r", loopNb, compressorName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / bestTime / 1000000);
            }
 
            if (ratio<100.)
                DISPLAY("%2i-%-34.34s :%10i ->%9i (%5.2f%%),%7.1f MB/s\n", cAlgNb, compressorName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / bestTime / 1000000);
            else
                DISPLAY("%2i-%-34.34s :%10i ->%9i (%5.1f%%),%7.1f MB/s\n", cAlgNb, compressorName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / bestTime / 100000);
        }
 
        /* Prepare layout for decompression */
        /* Init data chunks */
        { int i;
          size_t remaining = benchedSize;
          char* in = orig_buff;
          char* out = compressed_buff;
 
          nbChunks = (int) (((int)benchedSize + (g_chunkSize-1))/ g_chunkSize);
          for (i=0; i<nbChunks; i++) {
              chunkP[i].id = (U32)i;
              chunkP[i].origBuffer = in; in += g_chunkSize;
              if ((int)remaining > g_chunkSize) {
                  chunkP[i].origSize = g_chunkSize;
                  remaining -= (size_t)g_chunkSize;
              } else {
                  chunkP[i].origSize = (int)remaining;
                  remaining = 0;
              }
              chunkP[i].compressedBuffer = out; out += maxCompressedChunkSize;
              chunkP[i].compressedSize = 0;
          }
        }
        for (chunkNb=0; chunkNb<nbChunks; chunkNb++) {
            chunkP[chunkNb].compressedSize = LZ4_compress_default(chunkP[chunkNb].origBuffer, chunkP[chunkNb].compressedBuffer, chunkP[chunkNb].origSize, maxCompressedChunkSize);
            if (chunkP[chunkNb].compressedSize==0) {
                DISPLAY("ERROR ! %s() = 0 !! \n", "LZ4_compress");
                exit(1);
        }   }
 
        /* Decompression Algorithms */
        for (dAlgNb=0; (dAlgNb <= NB_DECOMPRESSION_ALGORITHMS) && g_decompressionTest; dAlgNb++) {
            const char* dName = NULL;
            int (*decompressionFunction)(const char*, char*, int, int) = NULL;
            double bestTime = 100000000.;
            int checkResult = 1;
 
            if ((g_decompressionAlgo != ALL_DECOMPRESSORS) && (g_decompressionAlgo != dAlgNb)) continue;
 
            switch(dAlgNb)
            {
            case 0: DISPLAY("Decompression functions : \n"); continue;
            case 1: decompressionFunction = local_LZ4_decompress_fast; dName = "LZ4_decompress_fast"; break;
            case 2: decompressionFunction = local_LZ4_decompress_fast_usingDict_prefix; dName = "LZ4_decompress_fast_usingDict(prefix)"; break;
            case 3: decompressionFunction = local_LZ4_decompress_fast_usingExtDict; dName = "LZ4_decompress_fast_using(Ext)Dict"; break;
            case 4: decompressionFunction = LZ4_decompress_safe; dName = "LZ4_decompress_safe"; break;
            case 5: decompressionFunction = local_LZ4_decompress_safe_withPrefix64k; dName = "LZ4_decompress_safe_withPrefix64k"; break;
            case 6: decompressionFunction = local_LZ4_decompress_safe_usingDict; dName = "LZ4_decompress_safe_usingDict"; break;
            case 7: decompressionFunction = local_LZ4_decompress_safe_partial; dName = "LZ4_decompress_safe_partial"; checkResult = 0; break;
#ifndef LZ4_DLL_IMPORT
            case 8: decompressionFunction = local_LZ4_decompress_safe_forceExtDict; dName = "LZ4_decompress_safe_forceExtDict"; break;
#endif
            case 10:
            case 11:
            case 12:
                if (dAlgNb == 10) { decompressionFunction = local_LZ4F_decompress; dName = "LZ4F_decompress"; }  /* can be skipped */
                if (dAlgNb == 11) { decompressionFunction = local_LZ4F_decompress_followHint; dName = "LZ4F_decompress_followHint"; }  /* can be skipped */
                if (dAlgNb == 12) { decompressionFunction = local_LZ4F_decompress_noHint; dName = "LZ4F_decompress_noHint"; }  /* can be skipped */
                /* prepare compressed data using frame format */
                {   size_t const fcsize = LZ4F_compressFrame(compressed_buff, (size_t)compressedBuffSize, orig_buff, benchedSize, NULL);
                    assert(!LZ4F_isError(fcsize));
                    chunkP[0].origSize = (int)benchedSize;
                    chunkP[0].compressedSize = (int)fcsize;
                    nbChunks = 1;
                    break;
                }
            default :
                continue;   /* skip if unknown ID */
            }
 
            assert(decompressionFunction != NULL);
            assert(dName != NULL);
 
            { size_t i; for (i=0; i<benchedSize; i++) orig_buff[i]=0; }     /* zeroing source area, for CRC checking */
 
            for (loopNb = 1; loopNb <= g_nbIterations; loopNb++) {
                double averageTime;
                clock_t clockTime;
                U32 crcDecoded;
 
                PROGRESS("%2i-%-34.34s :%10i ->\r", loopNb, dName, (int)benchedSize);
 
                nb_loops = 0;
                clockTime = clock();
                while(clock() == clockTime);
                clockTime = clock();
                while(BMK_GetClockSpan(clockTime) < TIMELOOP) {
                    for (chunkNb=0; chunkNb<nbChunks; chunkNb++) {
                        int const decodedSize = decompressionFunction(chunkP[chunkNb].compressedBuffer, chunkP[chunkNb].origBuffer,
                                                                      chunkP[chunkNb].compressedSize, chunkP[chunkNb].origSize);
                        if (chunkP[chunkNb].origSize != decodedSize) {
                            DISPLAY("ERROR ! %s() == %i != %i !! \n",
                                    dName, decodedSize, chunkP[chunkNb].origSize);
                            exit(1);
                    }   }
                    nb_loops++;
                }
                clockTime = BMK_GetClockSpan(clockTime);
 
                nb_loops += !nb_loops;   /* Avoid division by zero */
                averageTime = (double)clockTime / nb_loops / CLOCKS_PER_SEC;
                if (averageTime < bestTime) bestTime = averageTime;
 
                PROGRESS("%2i-%-34.34s :%10i -> %7.1f MB/s\r", loopNb, dName, (int)benchedSize, (double)benchedSize / bestTime / 1000000);
 
                /* CRC Checking */
                crcDecoded = XXH32(orig_buff, benchedSize, 0);
                if (checkResult && (crcOriginal!=crcDecoded)) {
                    DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n",
                            inFileName, (unsigned)crcOriginal, (unsigned)crcDecoded);
                    exit(1);
            }   }
 
            DISPLAY("%2i-%-34.34s :%10i -> %7.1f MB/s\n", dAlgNb, dName, (int)benchedSize, (double)benchedSize / bestTime / 1000000);
        }
      }
      free(orig_buff);
      free(compressed_buff);
      free(chunkP);
    }
 
    LZ4F_freeDecompressionContext(g_dCtx);
    if (g_pause) { printf("press enter...\n"); (void)getchar(); }
 
    return 0;
}

References ALL_COMPRESSORS, ALL_DECOMPRESSORS, assert(), BMK_findMaxMem(), BMK_GetClockSpan(), chunkParameters::compressedBuffer, compressedSize, chunkParameters::compressedSize, test-lz4-speed::default, DISPLAY, test-lz4-list::exit, benchmark::FILE, free(), g_chunkSize, g_compressionAlgo, g_compressionTest, g_dCtx, g_decompressionAlgo, g_decompressionTest, g_nbIterations, g_pause, i, chunkParameters::id, in, int, local_LZ4_compress_default_large(), local_LZ4_compress_default_small(), local_LZ4_compress_destSize(), local_LZ4_compress_fast0(), local_LZ4_compress_fast1(), local_LZ4_compress_fast17(), local_LZ4_compress_fast2(), local_LZ4_compress_fast_continue0(), local_LZ4_compress_fast_extState0(), local_LZ4_compress_forceDict(), local_LZ4_compress_HC(), local_LZ4_compress_HC_continue(), local_LZ4_compress_HC_extStateHC(), local_LZ4_createStream(), local_LZ4_decompress_fast(), local_LZ4_decompress_fast_usingDict_prefix(), local_LZ4_decompress_fast_usingExtDict(), local_LZ4_decompress_safe_forceExtDict(), local_LZ4_decompress_safe_partial(), local_LZ4_decompress_safe_usingDict(), local_LZ4_decompress_safe_withPrefix64k(), local_LZ4_resetDictT(), local_LZ4_resetStreamHC(), local_LZ4_saveDict(), local_LZ4_saveDictHC(), local_LZ4F_compressFrame(), local_LZ4F_decompress(), local_LZ4F_decompress_followHint(), local_LZ4F_decompress_noHint(), LZ4_compress_default(), LZ4_compressBound(), LZ4_decompress_safe(), LZ4_loadDict(), LZ4_loadDictHC(), LZ4_stream, LZ4_streamHC, LZ4F_compressFrame(), LZ4F_createDecompressionContext(), LZ4F_freeDecompressionContext(), LZ4F_isError(), LZ4F_VERSION, malloc(), NB_COMPRESSION_ALGORITHMS, NB_DECOMPRESSION_ALGORITHMS, NULL, chunkParameters::origBuffer, chunkParameters::origSize, out, printf(), PROGRESS, TIMELOOP, U32, UTIL_getFileSize(), and XXH32().

Referenced by main().

local_LZ4_compress_default_large()

static int local_LZ4_compress_default_large ( const char *  in, char *  out, int  inSize  )

static

Definition at line 188 of file fullbench.c.

{
    return LZ4_compress_default(in, out, inSize, LZ4_compressBound(inSize));
}

References in, LZ4_compress_default(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_default_small()

static int local_LZ4_compress_default_small ( const char *  in, char *  out, int  inSize  )

static

Definition at line 193 of file fullbench.c.

{
    return LZ4_compress_default(in, out, inSize, LZ4_compressBound(inSize)-1);
}

References in, LZ4_compress_default(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_destSize()

static int local_LZ4_compress_destSize ( const char *  in, char *  out, int  inSize  )

static

Definition at line 198 of file fullbench.c.

{
    return LZ4_compress_destSize(in, out, &inSize, LZ4_compressBound(inSize)-1);
}

References in, LZ4_compress_destSize(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_fast0()

static int local_LZ4_compress_fast0 ( const char *  in, char *  out, int  inSize  )

static

Definition at line 203 of file fullbench.c.

{
    return LZ4_compress_fast(in, out, inSize, LZ4_compressBound(inSize), 0);
}

References in, LZ4_compress_fast(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_fast1()

static int local_LZ4_compress_fast1 ( const char *  in, char *  out, int  inSize  )

static

Definition at line 208 of file fullbench.c.

{
    return LZ4_compress_fast(in, out, inSize, LZ4_compressBound(inSize), 1);
}

References in, LZ4_compress_fast(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_fast17()

static int local_LZ4_compress_fast17 ( const char *  in, char *  out, int  inSize  )

static

Definition at line 218 of file fullbench.c.

{
    return LZ4_compress_fast(in, out, inSize, LZ4_compressBound(inSize), 17);
}

References in, LZ4_compress_fast(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_fast2()

static int local_LZ4_compress_fast2 ( const char *  in, char *  out, int  inSize  )

static

Definition at line 213 of file fullbench.c.

{
    return LZ4_compress_fast(in, out, inSize, LZ4_compressBound(inSize), 2);
}

References in, LZ4_compress_fast(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_fast_continue0()

static int local_LZ4_compress_fast_continue0 ( const char *  in, char *  out, int  inSize  )

static

Definition at line 228 of file fullbench.c.

{
    return LZ4_compress_fast_continue(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize), 0);
}

References in, LZ4_compress_fast_continue(), LZ4_compressBound(), LZ4_stream, and out.

Referenced by fullSpeedBench().

local_LZ4_compress_fast_extState0()

static int local_LZ4_compress_fast_extState0 ( const char *  in, char *  out, int  inSize  )

static

Definition at line 223 of file fullbench.c.

{
    return LZ4_compress_fast_extState(&LZ4_stream, in, out, inSize, LZ4_compressBound(inSize), 0);
}

References in, LZ4_compress_fast_extState(), LZ4_compressBound(), LZ4_stream, and out.

Referenced by fullSpeedBench().

local_LZ4_compress_forceDict()

static int local_LZ4_compress_forceDict ( const char *  in, char *  out, int  inSize  )

static

Definition at line 245 of file fullbench.c.

{
    return LZ4_compress_forceExtDict(&LZ4_stream, in, out, inSize);
}

References in, LZ4_compress_forceExtDict(), LZ4_stream, and out.

Referenced by fullSpeedBench().

local_LZ4_compress_HC()

static int local_LZ4_compress_HC ( const char *  in, char *  out, int  inSize  )

static

Definition at line 265 of file fullbench.c.

{
    return LZ4_compress_HC(in, out, inSize, LZ4_compressBound(inSize), 9);
}

References in, LZ4_compress_HC(), LZ4_compressBound(), and out.

Referenced by fullSpeedBench().

local_LZ4_compress_HC_continue()

static int local_LZ4_compress_HC_continue ( const char *  in, char *  out, int  inSize  )

static

Definition at line 275 of file fullbench.c.

{
    return LZ4_compress_HC_continue(&LZ4_streamHC, in, out, inSize, LZ4_compressBound(inSize));
}

References in, LZ4_compress_HC_continue(), LZ4_compressBound(), LZ4_streamHC, and out.

Referenced by fullSpeedBench().

local_LZ4_compress_HC_extStateHC()

static int local_LZ4_compress_HC_extStateHC ( const char *  in, char *  out, int  inSize  )

static

Definition at line 270 of file fullbench.c.

{
    return LZ4_compress_HC_extStateHC(&LZ4_streamHC, in, out, inSize, LZ4_compressBound(inSize), 9);
}

References in, LZ4_compress_HC_extStateHC(), LZ4_compressBound(), LZ4_streamHC, and out.

Referenced by fullSpeedBench().

local_LZ4_createStream()

static void local_LZ4_createStream ( void  )

static

Definition at line 176 of file fullbench.c.

{
    void* const r = LZ4_initStream(&LZ4_stream, sizeof(LZ4_stream));
    assert(r != NULL); (void)r;
}

References assert(), LZ4_initStream(), LZ4_stream, NULL, and r.

Referenced by fullSpeedBench().

local_LZ4_decompress_fast()

static int local_LZ4_decompress_fast ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 282 of file fullbench.c.

{
    (void)inSize;
    LZ4_decompress_fast(in, out, outSize);
    return outSize;
}

References in, LZ4_decompress_fast(), and out.

Referenced by fullSpeedBench().

local_LZ4_decompress_fast_usingDict_prefix()

static int local_LZ4_decompress_fast_usingDict_prefix ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 289 of file fullbench.c.

{
    (void)inSize;
    LZ4_decompress_fast_usingDict(in, out, outSize, out - 65536, 65536);
    return outSize;
}

References in, LZ4_decompress_fast_usingDict(), and out.

Referenced by fullSpeedBench().

local_LZ4_decompress_fast_usingExtDict()

static int local_LZ4_decompress_fast_usingExtDict ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 296 of file fullbench.c.

{
    (void)inSize;
    LZ4_decompress_fast_usingDict(in, out, outSize, out - 65536, 65535);
    return outSize;
}

References in, LZ4_decompress_fast_usingDict(), and out.

Referenced by fullSpeedBench().

local_LZ4_decompress_safe_forceExtDict()

static int local_LZ4_decompress_safe_forceExtDict ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 326 of file fullbench.c.

{
    (void)inSize;
    LZ4_decompress_safe_forceExtDict(in, out, inSize, outSize, out - 65536, 65536);
    return outSize;
}

References in, LZ4_decompress_safe_forceExtDict(), and out.

Referenced by fullSpeedBench().

local_LZ4_decompress_safe_partial()

static int local_LZ4_decompress_safe_partial ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 334 of file fullbench.c.

{
    int result = LZ4_decompress_safe_partial(in, out, inSize, outSize - 5, outSize);
    if (result < 0) return result;
    return outSize;
}

References in, LZ4_decompress_safe_partial(), and out.

Referenced by fullSpeedBench().

local_LZ4_decompress_safe_usingDict()

static int local_LZ4_decompress_safe_usingDict ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 309 of file fullbench.c.

{
    LZ4_decompress_safe_usingDict(in, out, inSize, outSize, out - 65536, 65536);
    return outSize;
}

References in, LZ4_decompress_safe_usingDict(), and out.

Referenced by fullSpeedBench().

local_LZ4_decompress_safe_withPrefix64k()

static int local_LZ4_decompress_safe_withPrefix64k ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 303 of file fullbench.c.

{
    LZ4_decompress_safe_withPrefix64k(in, out, inSize, outSize);
    return outSize;
}

References in, LZ4_decompress_safe_withPrefix64k(), and out.

Referenced by fullSpeedBench().

local_LZ4_resetDictT()

static void local_LZ4_resetDictT ( void  )

static

Definition at line 170 of file fullbench.c.

{
    void* const r = LZ4_initStream(&LZ4_stream, sizeof(LZ4_stream));
    assert(r != NULL); (void)r;
}

References assert(), LZ4_initStream(), LZ4_stream, NULL, and r.

Referenced by fullSpeedBench().

local_LZ4_resetStreamHC()

static void local_LZ4_resetStreamHC ( void  )

static

Definition at line 254 of file fullbench.c.

{
    LZ4_initStreamHC(&LZ4_streamHC, sizeof(LZ4_streamHC));
}

References LZ4_initStreamHC(), and LZ4_streamHC.

Referenced by fullSpeedBench().

local_LZ4_saveDict()

static int local_LZ4_saveDict ( const char *  in, char *  out, int  inSize  )

static

Definition at line 182 of file fullbench.c.

{
    (void)in;
    return LZ4_saveDict(&LZ4_stream, out, inSize);
}

References in, LZ4_saveDict(), LZ4_stream, and out.

Referenced by fullSpeedBench().

local_LZ4_saveDictHC()

static int local_LZ4_saveDictHC ( const char *  in, char *  out, int  inSize  )

static

Definition at line 259 of file fullbench.c.

{
    (void)in;
    return LZ4_saveDictHC(&LZ4_streamHC, out, inSize);
}

References in, LZ4_saveDictHC(), LZ4_streamHC, and out.

Referenced by fullSpeedBench().

local_LZ4F_compressFrame()

static int local_LZ4F_compressFrame ( const char *  in, char *  out, int  inSize  )

static

Definition at line 343 of file fullbench.c.

{
    assert(inSize >= 0);
    return (int)LZ4F_compressFrame(out, LZ4F_compressFrameBound((size_t)inSize, NULL), in, (size_t)inSize, NULL);
}

References assert(), in, LZ4F_compressFrame(), LZ4F_compressFrameBound(), NULL, and out.

Referenced by fullSpeedBench().

local_LZ4F_decompress()

static int local_LZ4F_decompress ( const char *  in, char *  out, int  inSize, int  outSize  )

static

Definition at line 351 of file fullbench.c.

{
    size_t srcSize = (size_t)inSize;
    size_t dstSize = (size_t)outSize;
    size_t result;
    assert(inSize >= 0);
    assert(outSize >= 0);
    result = LZ4F_decompress(g_dCtx, out, &dstSize, in, &srcSize, NULL);
    if (result!=0) { DISPLAY("Error decompressing frame : unfinished frame \n"); exit(8); }
    if (srcSize != (size_t)inSize) { DISPLAY("Error decompressing frame : read size incorrect \n"); exit(9); }
    return (int)dstSize;
}

References assert(), DISPLAY, test-lz4-list::exit, g_dCtx, in, LZ4F_decompress(), NULL, out, and srcSize.

Referenced by fullSpeedBench().

local_LZ4F_decompress_followHint()

static int local_LZ4F_decompress_followHint ( const char *  src, char *  dst, int  srcSize, int  dstSize  )

static

Definition at line 364 of file fullbench.c.

{
    size_t totalInSize = (size_t)srcSize;
    size_t maxOutSize = (size_t)dstSize;
 
    size_t inPos = 0;
    size_t inSize = 0;
    size_t outPos = 0;
    size_t outRemaining = maxOutSize - outPos;
 
    for (;;) {
        size_t const sizeHint = LZ4F_decompress(g_dCtx, dst+outPos, &outRemaining, src+inPos, &inSize, NULL);
        assert(!LZ4F_isError(sizeHint));
 
        inPos += inSize;
        inSize = sizeHint;
 
        outPos += outRemaining;
        outRemaining = maxOutSize - outPos;
 
        if (!sizeHint) break;
    }
 
    /* frame completed */
    if (inPos != totalInSize) {
        DISPLAY("Error decompressing frame : must read (%u) full frame (%u) \n",
                (unsigned)inPos, (unsigned)totalInSize);
        exit(10);
    }
    return (int)outPos;
 
}

References assert(), DISPLAY, dst, test-lz4-list::exit, g_dCtx, LZ4F_decompress(), LZ4F_isError(), NULL, src, and srcSize.

Referenced by fullSpeedBench().

local_LZ4F_decompress_noHint()

static int local_LZ4F_decompress_noHint ( const char *  src, char *  dst, int  srcSize, int  dstSize  )

static

Definition at line 398 of file fullbench.c.

{
    size_t totalInSize = (size_t)srcSize;
    size_t maxOutSize = (size_t)dstSize;
 
    size_t inPos = 0;
    size_t inSize = 64 KB;
    size_t outPos = 0;
    size_t outRemaining = maxOutSize - outPos;
 
    for (;;) {
        size_t const sizeHint = LZ4F_decompress(g_dCtx, dst+outPos, &outRemaining, src+inPos, &inSize, NULL);
        assert(!LZ4F_isError(sizeHint));
 
        inPos += inSize;
        inSize = (inPos + 64 KB <= totalInSize) ? 64 KB : totalInSize - inPos;
 
        outPos += outRemaining;
        outRemaining = maxOutSize - outPos;
 
        if (!sizeHint) break;
    }
 
    /* frame completed */
    if (inPos != totalInSize) {
        DISPLAY("Error decompressing frame : must read (%u) full frame (%u) \n",
                (unsigned)inPos, (unsigned)totalInSize);
        exit(10);
    }
    return (int)outPos;
 
}

References assert(), DISPLAY, dst, test-lz4-list::exit, g_dCtx, KB, LZ4F_decompress(), LZ4F_isError(), NULL, src, and srcSize.

Referenced by fullSpeedBench().

LZ4_calloc()

void* LZ4_calloc	(	size_t	n,
		size_t	s
	)

Definition at line 162 of file fullbench.c.

{ return calloc(n,s); }

References calloc(), n, and s.

LZ4_compress_forceExtDict()

int LZ4_compress_forceExtDict	(	LZ4_stream_t *	LZ4_stream,
		const char *	source,
		char *	dest,
		int	inputSize
	)

Definition at line 1641 of file lz4.c.

{
    LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
    int result;
 
    LZ4_renormDictT(streamPtr, srcSize);
 
    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
    } else {
        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
    }
 
    streamPtr->dictionary = (const BYTE*)source;
    streamPtr->dictSize = (U32)srcSize;
 
    return result;
}

References byU32, LZ4_stream_t_internal::currentOffset, dest, LZ4_stream_t_internal::dictionary, LZ4_stream_t_internal::dictSize, dictSmall, LZ4_stream_u::internal_donotuse, KB, LZ4_compress_generic(), LZ4_renormDictT(), noDictIssue, notLimited, NULL, source, srcSize, and usingExtDict.

Referenced by local_LZ4_compress_forceDict().

LZ4_decompress_safe_forceExtDict()

int LZ4_decompress_safe_forceExtDict	(	const char *	in,
		char *	out,
		int	inSize,
		int	outSize,
		const void *	dict,
		size_t	dictSize
	)

Definition at line 2223 of file lz4.c.

{
    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
                                  endOnInputSize, decode_full_block, usingExtDict,
                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
}

References compressedSize, decode_full_block, dest, endOnInputSize, LZ4_decompress_generic(), maxOutputSize, source, and usingExtDict.

Referenced by local_LZ4_decompress_safe_forceExtDict(), LZ4_decompress_safe_continue(), and LZ4_decompress_safe_usingDict().

LZ4_free()

void LZ4_free

(

void *

p

)

Definition at line 163 of file fullbench.c.

{ free(p); }

References free(), and p.

LZ4_malloc()

void* LZ4_malloc

(

size_t

s

)

Definition at line 161 of file fullbench.c.

{ return malloc(s); }

References malloc(), and s.

main()

int main	(	int	argc,
		const char **	argv
	)

Definition at line 767 of file fullbench.c.

{
    int i,
        filenamesStart=2;
    const char* exename = argv[0];
    const char* input_filename=0;
 
    // Welcome message
    DISPLAY(WELCOME_MESSAGE);
 
    if (argc<2) { badusage(exename); return 1; }
 
    for(i=1; i<argc; i++) {
        const char* argument = argv[i];
 
        if(!argument) continue;   // Protection if argument empty
        if (!strcmp(argument, "--no-prompt")) {
            g_noPrompt = 1;
            continue;
        }
 
        // Decode command (note : aggregated commands are allowed)
        if (argument[0]=='-') {
            while (argument[1]!=0) {
                argument ++;
 
                switch(argument[0])
                {
                    // Select compression algorithm only
                case 'c':
                    g_decompressionTest = 0;
                    while ((argument[1]>= '0') && (argument[1]<= '9')) {
                        g_compressionAlgo *= 10;
                        g_compressionAlgo += argument[1] - '0';
                        argument++;
                    }
                    break;
 
                    // Select decompression algorithm only
                case 'd':
                    g_compressionTest = 0;
                    while ((argument[1]>= '0') && (argument[1]<= '9')) {
                        g_decompressionAlgo *= 10;
                        g_decompressionAlgo += argument[1] - '0';
                        argument++;
                    }
                    break;
 
                    // Display help on usage
                case 'h' :
                case 'H': usage(exename); usage_advanced(); return 0;
 
                    // Modify Block Properties
                case 'B':
                    while (argument[1]!=0)
                    switch(argument[1])
                    {
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    {   int B = argument[1] - '0';
                        int S = 1 << (8 + 2*B);
                        BMK_setBlocksize(S);
                        argument++;
                        break;
                    }
                    case 'D': argument++; break;
                    default : goto _exit_blockProperties;
                    }
_exit_blockProperties:
                    break;
 
                    // Modify Nb Iterations
                case 'i':
                    if ((argument[1] >='0') && (argument[1] <='9')) {
                        int iters = argument[1] - '0';
                        BMK_setNbIterations(iters);
                        argument++;
                    }
                    break;
 
                    // Pause at the end (hidden option)
                case 'p': BMK_setPause(); break;
 
                    // Unknown command
                default : badusage(exename); return 1;
                }
            }
            continue;
        }
 
        // first provided filename is input
        if (!input_filename) { input_filename=argument; filenamesStart=i; continue; }
 
    }
 
    // No input filename ==> Error
    if(!input_filename) { badusage(exename); return 1; }
 
    return fullSpeedBench(argv+filenamesStart, argc-filenamesStart);
 
}

References argv, B, badusage(), BMK_setBlocksize(), BMK_setNbIterations(), BMK_setPause(), test-lz4-speed::default, DISPLAY, fullSpeedBench(), g_compressionAlgo, g_compressionTest, g_decompressionAlgo, g_decompressionTest, g_noPrompt, i, S, usage(), usage_advanced(), and WELCOME_MESSAGE.

usage()

static int usage ( const char *  exename )

static

Definition at line 739 of file fullbench.c.

{
    DISPLAY( "Usage :\n");
    DISPLAY( "      %s [arg] file1 file2 ... fileX\n", exename);
    DISPLAY( "Arguments :\n");
    DISPLAY( " -c     : compression tests only\n");
    DISPLAY( " -d     : decompression tests only\n");
    DISPLAY( " -H/-h  : Help (this text + advanced options)\n");
    return 0;
}

References DISPLAY.

Referenced by badusage(), and main().

usage_advanced()

static int usage_advanced ( void  )

static

Definition at line 750 of file fullbench.c.

{
    DISPLAY( "\nAdvanced options :\n");
    DISPLAY( " -c#    : test only compression function # [1-%i]\n", NB_COMPRESSION_ALGORITHMS);
    DISPLAY( " -d#    : test only decompression function # [1-%i]\n", NB_DECOMPRESSION_ALGORITHMS);
    DISPLAY( " -i#    : iteration loops [1-9](default : %i)\n", NBLOOPS);
    DISPLAY( " -B#    : Block size [4-7](default : 7)\n");
    return 0;
}

References DISPLAY, NB_COMPRESSION_ALGORITHMS, NB_DECOMPRESSION_ALGORITHMS, and NBLOOPS.

Referenced by main().

Variable Documentation

g_chunkSize

int g_chunkSize = DEFAULT_CHUNKSIZE

static

Definition at line 98 of file fullbench.c.

Referenced by BMK_setBlocksize(), and fullSpeedBench().

g_compressionAlgo

int g_compressionAlgo = ALL_COMPRESSORS

static

Definition at line 102 of file fullbench.c.

Referenced by fullSpeedBench(), and main().

g_compressionTest

int g_compressionTest = 1

static

Definition at line 101 of file fullbench.c.

Referenced by fullSpeedBench(), and main().

g_dCtx

LZ4F_decompressionContext_t g_dCtx

static

Definition at line 349 of file fullbench.c.

Referenced by fullSpeedBench(), local_LZ4F_decompress(), local_LZ4F_decompress_followHint(), and local_LZ4F_decompress_noHint().

g_decompressionAlgo

int g_decompressionAlgo = ALL_DECOMPRESSORS

static

Definition at line 104 of file fullbench.c.

Referenced by fullSpeedBench(), and main().

g_decompressionTest

int g_decompressionTest = 1

static

Definition at line 103 of file fullbench.c.

Referenced by fullSpeedBench(), and main().

g_nbIterations

int g_nbIterations = NBLOOPS

static

Definition at line 99 of file fullbench.c.

Referenced by BMK_setNbIterations(), and fullSpeedBench().

g_noPrompt

int g_noPrompt = 0

static

Definition at line 105 of file fullbench.c.

Referenced by main().

g_pause

int g_pause = 0

static

Definition at line 100 of file fullbench.c.

Referenced by BMK_setPause(), and fullSpeedBench().

LZ4_stream

LZ4_stream_t LZ4_stream

static

Definition at line 169 of file fullbench.c.

Referenced by fullSpeedBench(), FUZ_test(), local_LZ4_compress_fast_continue0(), local_LZ4_compress_fast_extState0(), local_LZ4_compress_forceDict(), local_LZ4_createStream(), local_LZ4_resetDictT(), local_LZ4_saveDict(), LZ4_compress_continue(), LZ4_compress_fast_continue(), LZ4_compress_limitedOutput_continue(), LZ4_freeStream(), LZ4_freeStreamDecode(), and LZ4_resetStream().

LZ4_streamHC

LZ4_streamHC_t LZ4_streamHC

Definition at line 253 of file fullbench.c.

Referenced by fullSpeedBench(), FUZ_test(), local_LZ4_compress_HC_continue(), local_LZ4_compress_HC_extStateHC(), local_LZ4_resetStreamHC(), and local_LZ4_saveDictHC().