1 /*
2 * Copyright (c) 2015-present, Yann Collet, Facebook, Inc.
3 * All rights reserved.
4 *
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 * You may select, at your option, one of the above-listed licenses.
9 */
10
11
12 /*_************************************
13 * Includes
14 **************************************/
15 #include "util.h" /* Compiler options, UTIL_GetFileSize */
16 #include <stdlib.h> /* malloc */
17 #include <stdio.h> /* fprintf, fopen, ftello64 */
18 #include <assert.h> /* assert */
19
20 #include "mem.h" /* U32 */
21 #ifndef ZSTD_DLL_IMPORT
22 #include "zstd_internal.h" /* ZSTD_blockHeaderSize, blockType_e, KB, MB */
23 #else
24 #define KB *(1 <<10)
25 #define MB *(1 <<20)
26 #define GB *(1U<<30)
27 typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;
28 #endif
29 #define ZSTD_STATIC_LINKING_ONLY /* ZSTD_compressBegin, ZSTD_compressContinue, etc. */
30 #include "zstd.h" /* ZSTD_versionString */
31 #include "util.h" /* time functions */
32 #include "datagen.h"
33
34
35 /*_************************************
36 * Constants
37 **************************************/
38 #define PROGRAM_DESCRIPTION "Zstandard speed analyzer"
39 #define AUTHOR "Yann Collet"
40 #define WELCOME_MESSAGE "*** %s %s %i-bits, by %s (%s) ***\n", PROGRAM_DESCRIPTION, ZSTD_versionString(), (int)(sizeof(void*)*8), AUTHOR, __DATE__
41
42 #define NBLOOPS 6
43 #define TIMELOOP_S 2
44
45 #define KNUTH 2654435761U
46 #define MAX_MEM (1984 MB)
47
48 #define COMPRESSIBILITY_DEFAULT 0.50
49 static const size_t g_sampleSize = 10000000;
50
51
52 /*_************************************
53 * Macros
54 **************************************/
55 #define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
56
57
58 /*_************************************
59 * Benchmark Parameters
60 **************************************/
61 static U32 g_nbIterations = NBLOOPS;
62 static double g_compressibility = COMPRESSIBILITY_DEFAULT;
63
BMK_SetNbIterations(U32 nbLoops)64 static void BMK_SetNbIterations(U32 nbLoops)
65 {
66 g_nbIterations = nbLoops;
67 DISPLAY("- %i iterations -\n", g_nbIterations);
68 }
69
70
71 /*_*******************************************************
72 * Private functions
73 *********************************************************/
BMK_findMaxMem(U64 requiredMem)74 static size_t BMK_findMaxMem(U64 requiredMem)
75 {
76 size_t const step = 64 MB;
77 void* testmem = NULL;
78
79 requiredMem = (((requiredMem >> 26) + 1) << 26);
80 if (requiredMem > MAX_MEM) requiredMem = MAX_MEM;
81
82 requiredMem += step;
83 do {
84 testmem = malloc ((size_t)requiredMem);
85 requiredMem -= step;
86 } while (!testmem);
87
88 free (testmem);
89 return (size_t) requiredMem;
90 }
91
92
93 /*_*******************************************************
94 * Benchmark wrappers
95 *********************************************************/
local_ZSTD_compress(void * dst,size_t dstSize,void * buff2,const void * src,size_t srcSize)96 size_t local_ZSTD_compress(void* dst, size_t dstSize, void* buff2, const void* src, size_t srcSize)
97 {
98 (void)buff2;
99 return ZSTD_compress(dst, dstSize, src, srcSize, 1);
100 }
101
102 static size_t g_cSize = 0;
local_ZSTD_decompress(void * dst,size_t dstSize,void * buff2,const void * src,size_t srcSize)103 size_t local_ZSTD_decompress(void* dst, size_t dstSize, void* buff2, const void* src, size_t srcSize)
104 {
105 (void)src; (void)srcSize;
106 return ZSTD_decompress(dst, dstSize, buff2, g_cSize);
107 }
108
109 static ZSTD_DCtx* g_zdc = NULL;
110
111 #ifndef ZSTD_DLL_IMPORT
112 extern size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* ctx, const void* src, size_t srcSize);
local_ZSTD_decodeLiteralsBlock(void * dst,size_t dstSize,void * buff2,const void * src,size_t srcSize)113 size_t local_ZSTD_decodeLiteralsBlock(void* dst, size_t dstSize, void* buff2, const void* src, size_t srcSize)
114 {
115 (void)src; (void)srcSize; (void)dst; (void)dstSize;
116 return ZSTD_decodeLiteralsBlock((ZSTD_DCtx*)g_zdc, buff2, g_cSize);
117 }
118
119 extern size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeq, const void* src, size_t srcSize);
local_ZSTD_decodeSeqHeaders(void * dst,size_t dstSize,void * buff2,const void * src,size_t srcSize)120 size_t local_ZSTD_decodeSeqHeaders(void* dst, size_t dstSize, void* buff2, const void* src, size_t srcSize)
121 {
122 int nbSeq;
123 (void)src; (void)srcSize; (void)dst; (void)dstSize;
124 return ZSTD_decodeSeqHeaders(g_zdc, &nbSeq, buff2, g_cSize);
125 }
126 #endif
127
128 static ZSTD_CStream* g_cstream= NULL;
local_ZSTD_compressStream(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)129 size_t local_ZSTD_compressStream(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
130 {
131 ZSTD_outBuffer buffOut;
132 ZSTD_inBuffer buffIn;
133 (void)buff2;
134 ZSTD_initCStream(g_cstream, 1);
135 buffOut.dst = dst;
136 buffOut.size = dstCapacity;
137 buffOut.pos = 0;
138 buffIn.src = src;
139 buffIn.size = srcSize;
140 buffIn.pos = 0;
141 ZSTD_compressStream(g_cstream, &buffOut, &buffIn);
142 ZSTD_endStream(g_cstream, &buffOut);
143 return buffOut.pos;
144 }
145
local_ZSTD_compress_generic_end(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)146 static size_t local_ZSTD_compress_generic_end(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
147 {
148 ZSTD_outBuffer buffOut;
149 ZSTD_inBuffer buffIn;
150 (void)buff2;
151 ZSTD_CCtx_setParameter(g_cstream, ZSTD_p_compressionLevel, 1);
152 buffOut.dst = dst;
153 buffOut.size = dstCapacity;
154 buffOut.pos = 0;
155 buffIn.src = src;
156 buffIn.size = srcSize;
157 buffIn.pos = 0;
158 ZSTD_compress_generic(g_cstream, &buffOut, &buffIn, ZSTD_e_end);
159 return buffOut.pos;
160 }
161
local_ZSTD_compress_generic_continue(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)162 static size_t local_ZSTD_compress_generic_continue(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
163 {
164 ZSTD_outBuffer buffOut;
165 ZSTD_inBuffer buffIn;
166 (void)buff2;
167 ZSTD_CCtx_setParameter(g_cstream, ZSTD_p_compressionLevel, 1);
168 buffOut.dst = dst;
169 buffOut.size = dstCapacity;
170 buffOut.pos = 0;
171 buffIn.src = src;
172 buffIn.size = srcSize;
173 buffIn.pos = 0;
174 ZSTD_compress_generic(g_cstream, &buffOut, &buffIn, ZSTD_e_continue);
175 ZSTD_compress_generic(g_cstream, &buffOut, &buffIn, ZSTD_e_end);
176 return buffOut.pos;
177 }
178
local_ZSTD_compress_generic_T2_end(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)179 static size_t local_ZSTD_compress_generic_T2_end(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
180 {
181 ZSTD_outBuffer buffOut;
182 ZSTD_inBuffer buffIn;
183 (void)buff2;
184 ZSTD_CCtx_setParameter(g_cstream, ZSTD_p_compressionLevel, 1);
185 ZSTD_CCtx_setParameter(g_cstream, ZSTD_p_nbWorkers, 2);
186 buffOut.dst = dst;
187 buffOut.size = dstCapacity;
188 buffOut.pos = 0;
189 buffIn.src = src;
190 buffIn.size = srcSize;
191 buffIn.pos = 0;
192 while (ZSTD_compress_generic(g_cstream, &buffOut, &buffIn, ZSTD_e_end)) {}
193 return buffOut.pos;
194 }
195
local_ZSTD_compress_generic_T2_continue(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)196 static size_t local_ZSTD_compress_generic_T2_continue(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
197 {
198 ZSTD_outBuffer buffOut;
199 ZSTD_inBuffer buffIn;
200 (void)buff2;
201 ZSTD_CCtx_setParameter(g_cstream, ZSTD_p_compressionLevel, 1);
202 ZSTD_CCtx_setParameter(g_cstream, ZSTD_p_nbWorkers, 2);
203 buffOut.dst = dst;
204 buffOut.size = dstCapacity;
205 buffOut.pos = 0;
206 buffIn.src = src;
207 buffIn.size = srcSize;
208 buffIn.pos = 0;
209 ZSTD_compress_generic(g_cstream, &buffOut, &buffIn, ZSTD_e_continue);
210 while(ZSTD_compress_generic(g_cstream, &buffOut, &buffIn, ZSTD_e_end)) {}
211 return buffOut.pos;
212 }
213
214 static ZSTD_DStream* g_dstream= NULL;
local_ZSTD_decompressStream(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)215 static size_t local_ZSTD_decompressStream(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
216 {
217 ZSTD_outBuffer buffOut;
218 ZSTD_inBuffer buffIn;
219 (void)src; (void)srcSize;
220 ZSTD_initDStream(g_dstream);
221 buffOut.dst = dst;
222 buffOut.size = dstCapacity;
223 buffOut.pos = 0;
224 buffIn.src = buff2;
225 buffIn.size = g_cSize;
226 buffIn.pos = 0;
227 ZSTD_decompressStream(g_dstream, &buffOut, &buffIn);
228 return buffOut.pos;
229 }
230
231 static ZSTD_CCtx* g_zcc = NULL;
232
233 #ifndef ZSTD_DLL_IMPORT
local_ZSTD_compressContinue(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)234 size_t local_ZSTD_compressContinue(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
235 {
236 (void)buff2;
237 ZSTD_compressBegin(g_zcc, 1 /* compressionLevel */);
238 return ZSTD_compressEnd(g_zcc, dst, dstCapacity, src, srcSize);
239 }
240
241 #define FIRST_BLOCK_SIZE 8
local_ZSTD_compressContinue_extDict(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)242 size_t local_ZSTD_compressContinue_extDict(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
243 {
244 BYTE firstBlockBuf[FIRST_BLOCK_SIZE];
245
246 (void)buff2;
247 memcpy(firstBlockBuf, src, FIRST_BLOCK_SIZE);
248 ZSTD_compressBegin(g_zcc, 1);
249
250 { size_t const compressResult = ZSTD_compressContinue(g_zcc, dst, dstCapacity, firstBlockBuf, FIRST_BLOCK_SIZE);
251 if (ZSTD_isError(compressResult)) { DISPLAY("local_ZSTD_compressContinue_extDict error : %s\n", ZSTD_getErrorName(compressResult)); return compressResult; }
252 dst = (BYTE*)dst + compressResult;
253 dstCapacity -= compressResult;
254 }
255 return ZSTD_compressEnd(g_zcc, dst, dstCapacity, (const BYTE*)src + FIRST_BLOCK_SIZE, srcSize - FIRST_BLOCK_SIZE);
256 }
257
local_ZSTD_decompressContinue(void * dst,size_t dstCapacity,void * buff2,const void * src,size_t srcSize)258 size_t local_ZSTD_decompressContinue(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
259 {
260 size_t regeneratedSize = 0;
261 const BYTE* ip = (const BYTE*)buff2;
262 const BYTE* const iend = ip + g_cSize;
263 BYTE* op = (BYTE*)dst;
264 size_t remainingCapacity = dstCapacity;
265
266 (void)src; (void)srcSize;
267 ZSTD_decompressBegin(g_zdc);
268 while (ip < iend) {
269 size_t const iSize = ZSTD_nextSrcSizeToDecompress(g_zdc);
270 size_t const decodedSize = ZSTD_decompressContinue(g_zdc, op, remainingCapacity, ip, iSize);
271 ip += iSize;
272 regeneratedSize += decodedSize;
273 op += decodedSize;
274 remainingCapacity -= decodedSize;
275 }
276
277 return regeneratedSize;
278 }
279 #endif
280
281
282 /*_*******************************************************
283 * Bench functions
284 *********************************************************/
benchMem(const void * src,size_t srcSize,U32 benchNb)285 static size_t benchMem(const void* src, size_t srcSize, U32 benchNb)
286 {
287 BYTE* dstBuff;
288 size_t const dstBuffSize = ZSTD_compressBound(srcSize);
289 void* buff2;
290 const char* benchName;
291 size_t (*benchFunction)(void* dst, size_t dstSize, void* verifBuff, const void* src, size_t srcSize);
292 double bestTime = 100000000.;
293
294 /* Selection */
295 switch(benchNb)
296 {
297 case 1:
298 benchFunction = local_ZSTD_compress; benchName = "compress(1)";
299 break;
300 case 2:
301 benchFunction = local_ZSTD_decompress; benchName = "decompress";
302 break;
303 #ifndef ZSTD_DLL_IMPORT
304 case 11:
305 benchFunction = local_ZSTD_compressContinue; benchName = "compressContinue(1)";
306 break;
307 case 12:
308 benchFunction = local_ZSTD_compressContinue_extDict; benchName = "compressContinue_extDict";
309 break;
310 case 13:
311 benchFunction = local_ZSTD_decompressContinue; benchName = "decompressContinue";
312 break;
313 case 31:
314 benchFunction = local_ZSTD_decodeLiteralsBlock; benchName = "decodeLiteralsBlock";
315 break;
316 case 32:
317 benchFunction = local_ZSTD_decodeSeqHeaders; benchName = "decodeSeqHeaders";
318 break;
319 #endif
320 case 41:
321 benchFunction = local_ZSTD_compressStream; benchName = "compressStream(1)";
322 break;
323 case 42:
324 benchFunction = local_ZSTD_decompressStream; benchName = "decompressStream";
325 break;
326 case 51:
327 benchFunction = local_ZSTD_compress_generic_continue; benchName = "compress_generic, continue";
328 break;
329 case 52:
330 benchFunction = local_ZSTD_compress_generic_end; benchName = "compress_generic, end";
331 break;
332 case 61:
333 benchFunction = local_ZSTD_compress_generic_T2_continue; benchName = "compress_generic, -T2, continue";
334 break;
335 case 62:
336 benchFunction = local_ZSTD_compress_generic_T2_end; benchName = "compress_generic, -T2, end";
337 break;
338 default :
339 return 0;
340 }
341
342 /* Allocation */
343 dstBuff = (BYTE*)malloc(dstBuffSize);
344 buff2 = malloc(dstBuffSize);
345 if ((!dstBuff) || (!buff2)) {
346 DISPLAY("\nError: not enough memory!\n");
347 free(dstBuff); free(buff2);
348 return 12;
349 }
350 if (g_zcc==NULL) g_zcc = ZSTD_createCCtx();
351 if (g_zdc==NULL) g_zdc = ZSTD_createDCtx();
352 if (g_cstream==NULL) g_cstream = ZSTD_createCStream();
353 if (g_dstream==NULL) g_dstream = ZSTD_createDStream();
354
355 /* Preparation */
356 switch(benchNb)
357 {
358 case 2:
359 g_cSize = ZSTD_compress(buff2, dstBuffSize, src, srcSize, 1);
360 break;
361 #ifndef ZSTD_DLL_IMPORT
362 case 13 :
363 g_cSize = ZSTD_compress(buff2, dstBuffSize, src, srcSize, 1);
364 break;
365 case 31: /* ZSTD_decodeLiteralsBlock */
366 { blockProperties_t bp;
367 ZSTD_frameHeader zfp;
368 size_t frameHeaderSize, skippedSize;
369 g_cSize = ZSTD_compress(dstBuff, dstBuffSize, src, srcSize, 1);
370 frameHeaderSize = ZSTD_getFrameHeader(&zfp, dstBuff, ZSTD_frameHeaderSize_min);
371 if (frameHeaderSize==0) frameHeaderSize = ZSTD_frameHeaderSize_min;
372 ZSTD_getcBlockSize(dstBuff+frameHeaderSize, dstBuffSize, &bp); /* Get 1st block type */
373 if (bp.blockType != bt_compressed) {
374 DISPLAY("ZSTD_decodeLiteralsBlock : impossible to test on this sample (not compressible)\n");
375 goto _cleanOut;
376 }
377 skippedSize = frameHeaderSize + ZSTD_blockHeaderSize;
378 memcpy(buff2, dstBuff+skippedSize, g_cSize-skippedSize);
379 srcSize = srcSize > 128 KB ? 128 KB : srcSize; /* speed relative to block */
380 ZSTD_decompressBegin(g_zdc);
381 break;
382 }
383 case 32: /* ZSTD_decodeSeqHeaders */
384 { blockProperties_t bp;
385 ZSTD_frameHeader zfp;
386 const BYTE* ip = dstBuff;
387 const BYTE* iend;
388 size_t frameHeaderSize, cBlockSize;
389 ZSTD_compress(dstBuff, dstBuffSize, src, srcSize, 1); /* it would be better to use direct block compression here */
390 g_cSize = ZSTD_compress(dstBuff, dstBuffSize, src, srcSize, 1);
391 frameHeaderSize = ZSTD_getFrameHeader(&zfp, dstBuff, ZSTD_frameHeaderSize_min);
392 if (frameHeaderSize==0) frameHeaderSize = ZSTD_frameHeaderSize_min;
393 ip += frameHeaderSize; /* Skip frame Header */
394 cBlockSize = ZSTD_getcBlockSize(ip, dstBuffSize, &bp); /* Get 1st block type */
395 if (bp.blockType != bt_compressed) {
396 DISPLAY("ZSTD_decodeSeqHeaders : impossible to test on this sample (not compressible)\n");
397 goto _cleanOut;
398 }
399 iend = ip + ZSTD_blockHeaderSize + cBlockSize; /* End of first block */
400 ip += ZSTD_blockHeaderSize; /* skip block header */
401 ZSTD_decompressBegin(g_zdc);
402 ip += ZSTD_decodeLiteralsBlock(g_zdc, ip, iend-ip); /* skip literal segment */
403 g_cSize = iend-ip;
404 memcpy(buff2, ip, g_cSize); /* copy rest of block (it starts by SeqHeader) */
405 srcSize = srcSize > 128 KB ? 128 KB : srcSize; /* speed relative to block */
406 break;
407 }
408 #else
409 case 31:
410 goto _cleanOut;
411 #endif
412 case 42 :
413 g_cSize = ZSTD_compress(buff2, dstBuffSize, src, srcSize, 1);
414 break;
415
416 /* test functions */
417 /* convention: test functions have ID > 100 */
418
419 default : ;
420 }
421
422 /* warming up memory */
423 { size_t i; for (i=0; i<dstBuffSize; i++) dstBuff[i]=(BYTE)i; }
424
425 /* benchmark loop */
426 { U32 loopNb;
427 U32 nbRounds = (U32)((50 MB) / (srcSize+1)) + 1; /* initial conservative speed estimate */
428 # define TIME_SEC_MICROSEC (1*1000000ULL) /* 1 second */
429 # define TIME_SEC_NANOSEC (1*1000000000ULL) /* 1 second */
430 DISPLAY("%2i- %-30.30s : \r", benchNb, benchName);
431 for (loopNb = 1; loopNb <= g_nbIterations; loopNb++) {
432 UTIL_time_t clockStart;
433 size_t benchResult=0;
434 U32 roundNb;
435
436 UTIL_sleepMilli(5); /* give processor time to other processes */
437 UTIL_waitForNextTick();
438 clockStart = UTIL_getTime();
439 for (roundNb=0; roundNb < nbRounds; roundNb++) {
440 benchResult = benchFunction(dstBuff, dstBuffSize, buff2, src, srcSize);
441 if (ZSTD_isError(benchResult)) {
442 DISPLAY("ERROR ! %s() => %s !! \n", benchName, ZSTD_getErrorName(benchResult));
443 exit(1);
444 } }
445 { U64 const clockSpanNano = UTIL_clockSpanNano(clockStart);
446 double const averageTime = (double)clockSpanNano / TIME_SEC_NANOSEC / nbRounds;
447 if (clockSpanNano > 0) {
448 if (averageTime < bestTime) bestTime = averageTime;
449 assert(bestTime > (1./2000000000));
450 nbRounds = (U32)(1. / bestTime); /* aim for 1 sec */
451 DISPLAY("%2i- %-30.30s : %7.1f MB/s (%9u)\r",
452 loopNb, benchName,
453 (double)srcSize / (1 MB) / bestTime,
454 (U32)benchResult);
455 } else {
456 assert(nbRounds < 40000000); /* avoid overflow */
457 nbRounds *= 100;
458 }
459 } } }
460 DISPLAY("%2u\n", benchNb);
461
462 _cleanOut:
463 free(dstBuff);
464 free(buff2);
465 ZSTD_freeCCtx(g_zcc); g_zcc=NULL;
466 ZSTD_freeDCtx(g_zdc); g_zdc=NULL;
467 ZSTD_freeCStream(g_cstream); g_cstream=NULL;
468 ZSTD_freeDStream(g_dstream); g_dstream=NULL;
469 return 0;
470 }
471
472
benchSample(U32 benchNb)473 static int benchSample(U32 benchNb)
474 {
475 size_t const benchedSize = g_sampleSize;
476 const char* name = "Sample 10MiB";
477
478 /* Allocation */
479 void* origBuff = malloc(benchedSize);
480 if (!origBuff) { DISPLAY("\nError: not enough memory!\n"); return 12; }
481
482 /* Fill buffer */
483 RDG_genBuffer(origBuff, benchedSize, g_compressibility, 0.0, 0);
484
485 /* bench */
486 DISPLAY("\r%79s\r", "");
487 DISPLAY(" %s : \n", name);
488 if (benchNb)
489 benchMem(origBuff, benchedSize, benchNb);
490 else
491 for (benchNb=0; benchNb<100; benchNb++) benchMem(origBuff, benchedSize, benchNb);
492
493 free(origBuff);
494 return 0;
495 }
496
497
benchFiles(const char ** fileNamesTable,const int nbFiles,U32 benchNb)498 static int benchFiles(const char** fileNamesTable, const int nbFiles, U32 benchNb)
499 {
500 /* Loop for each file */
501 int fileIdx;
502 for (fileIdx=0; fileIdx<nbFiles; fileIdx++) {
503 const char* const inFileName = fileNamesTable[fileIdx];
504 FILE* const inFile = fopen( inFileName, "rb" );
505 U64 inFileSize;
506 size_t benchedSize;
507 void* origBuff;
508
509 /* Check file existence */
510 if (inFile==NULL) { DISPLAY( "Pb opening %s\n", inFileName); return 11; }
511
512 /* Memory allocation & restrictions */
513 inFileSize = UTIL_getFileSize(inFileName);
514 if (inFileSize == UTIL_FILESIZE_UNKNOWN) {
515 DISPLAY( "Cannot measure size of %s\n", inFileName);
516 fclose(inFile);
517 return 11;
518 }
519 benchedSize = BMK_findMaxMem(inFileSize*3) / 3;
520 if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
521 if (benchedSize < inFileSize)
522 DISPLAY("Not enough memory for '%s' full size; testing %u MB only...\n", inFileName, (U32)(benchedSize>>20));
523
524 /* Alloc */
525 origBuff = malloc(benchedSize);
526 if (!origBuff) { DISPLAY("\nError: not enough memory!\n"); fclose(inFile); return 12; }
527
528 /* Fill input buffer */
529 DISPLAY("Loading %s... \r", inFileName);
530 {
531 size_t readSize = fread(origBuff, 1, benchedSize, inFile);
532 fclose(inFile);
533 if (readSize != benchedSize) {
534 DISPLAY("\nError: problem reading file '%s' !! \n", inFileName);
535 free(origBuff);
536 return 13;
537 } }
538
539 /* bench */
540 DISPLAY("\r%79s\r", "");
541 DISPLAY(" %s : \n", inFileName);
542 if (benchNb)
543 benchMem(origBuff, benchedSize, benchNb);
544 else
545 for (benchNb=0; benchNb<100; benchNb++) benchMem(origBuff, benchedSize, benchNb);
546
547 free(origBuff);
548 }
549
550 return 0;
551 }
552
553
usage(const char * exename)554 static int usage(const char* exename)
555 {
556 DISPLAY( "Usage :\n");
557 DISPLAY( " %s [arg] file1 file2 ... fileX\n", exename);
558 DISPLAY( "Arguments :\n");
559 DISPLAY( " -H/-h : Help (this text + advanced options)\n");
560 return 0;
561 }
562
usage_advanced(const char * exename)563 static int usage_advanced(const char* exename)
564 {
565 usage(exename);
566 DISPLAY( "\nAdvanced options :\n");
567 DISPLAY( " -b# : test only function # \n");
568 DISPLAY( " -i# : iteration loops [1-9](default : %i)\n", NBLOOPS);
569 DISPLAY( " -P# : sample compressibility (default : %.1f%%)\n", COMPRESSIBILITY_DEFAULT * 100);
570 return 0;
571 }
572
badusage(const char * exename)573 static int badusage(const char* exename)
574 {
575 DISPLAY("Wrong parameters\n");
576 usage(exename);
577 return 1;
578 }
579
main(int argc,const char ** argv)580 int main(int argc, const char** argv)
581 {
582 int i, filenamesStart=0, result;
583 const char* exename = argv[0];
584 const char* input_filename = NULL;
585 U32 benchNb = 0, main_pause = 0;
586
587 DISPLAY(WELCOME_MESSAGE);
588 if (argc<1) return badusage(exename);
589
590 for(i=1; i<argc; i++) {
591 const char* argument = argv[i];
592 assert(argument != NULL);
593
594 /* Commands (note : aggregated commands are allowed) */
595 if (argument[0]=='-') {
596
597 while (argument[1]!=0) {
598 argument++;
599
600 switch(argument[0])
601 {
602 /* Display help on usage */
603 case 'h':
604 case 'H': return usage_advanced(exename);
605
606 /* Pause at the end (hidden option) */
607 case 'p': main_pause = 1; break;
608
609 /* Select specific algorithm to bench */
610 case 'b':
611 benchNb = 0;
612 while ((argument[1]>= '0') && (argument[1]<= '9')) {
613 benchNb *= 10;
614 benchNb += argument[1] - '0';
615 argument++;
616 }
617 break;
618
619 /* Modify Nb Iterations */
620 case 'i':
621 if ((argument[1] >='0') && (argument[1] <='9')) {
622 int iters = argument[1] - '0';
623 BMK_SetNbIterations(iters);
624 argument++;
625 }
626 break;
627
628 /* Select compressibility of synthetic sample */
629 case 'P':
630 { U32 proba32 = 0;
631 while ((argument[1]>= '0') && (argument[1]<= '9')) {
632 proba32 *= 10;
633 proba32 += argument[1] - '0';
634 argument++;
635 }
636 g_compressibility = (double)proba32 / 100.;
637 }
638 break;
639
640 /* Unknown command */
641 default : return badusage(exename);
642 }
643 }
644 continue;
645 }
646
647 /* first provided filename is input */
648 if (!input_filename) { input_filename=argument; filenamesStart=i; continue; }
649 }
650
651 if (filenamesStart==0) /* no input file */
652 result = benchSample(benchNb);
653 else
654 result = benchFiles(argv+filenamesStart, argc-filenamesStart, benchNb);
655
656 if (main_pause) { int unused; printf("press enter...\n"); unused = getchar(); (void)unused; }
657
658 return result;
659 }
660