notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git subrepo pull (merge) --force deps/libchdr
[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.5 / tests / fullbench.c
CommitLineData
648db22b 1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
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#define ZSTD_DISABLE_DEPRECATE_WARNINGS /* No deprecation warnings, we still bench some deprecated functions */
16#include "util.h" /* Compiler options, UTIL_GetFileSize */
17#include <stdlib.h> /* malloc */
18#include <stdio.h> /* fprintf, fopen, ftello64 */
19#include <assert.h>
20
21#include "timefn.h" /* UTIL_clockSpanNano, UTIL_getTime */
22#include "mem.h" /* U32 */
23#ifndef ZSTD_DLL_IMPORT
24 #include "zstd_internal.h" /* ZSTD_decodeSeqHeaders, ZSTD_blockHeaderSize, ZSTD_getcBlockSize, blockType_e, KB, MB */
25 #include "decompress/zstd_decompress_internal.h" /* ZSTD_DCtx struct */
26#else
27 #define KB *(1 <<10)
28 #define MB *(1 <<20)
29 #define GB *(1U<<30)
30 typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;
31#endif
32#define ZSTD_STATIC_LINKING_ONLY /* ZSTD_compressBegin, ZSTD_compressContinue, etc. */
33#include "zstd.h" /* ZSTD_versionString */
34#include "util.h" /* time functions */
35#include "datagen.h"
36#include "benchfn.h" /* CustomBench */
37#include "benchzstd.h" /* MB_UNIT */
38
39
40/*_************************************
41* Constants
42**************************************/
43#define PROGRAM_DESCRIPTION "Zstandard speed analyzer"
44#define AUTHOR "Yann Collet"
45#define WELCOME_MESSAGE "*** %s %s %i-bits, by %s (%s) ***\n", PROGRAM_DESCRIPTION, ZSTD_versionString(), (int)(sizeof(void*)*8), AUTHOR, __DATE__
46
47#define NBLOOPS 6
48#define TIMELOOP_S 2
49
50#define MAX_MEM (1984 MB)
51
52#define DEFAULT_CLEVEL 1
53
54#define COMPRESSIBILITY_DEFAULT 0.50
55static const size_t kSampleSizeDefault = 10000000;
56
57#define TIMELOOP_NANOSEC (1*1000000000ULL) /* 1 second */
58
59
60/*_************************************
61* Macros
62**************************************/
63#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
64
65#define CONTROL(c) { if (!(c)) { abort(); } } /* like assert(), but cannot be disabled */
66
67/*_************************************
68* Benchmark Parameters
69**************************************/
70static unsigned g_nbIterations = NBLOOPS;
71
72
73/*_*******************************************************
74* Private functions
75*********************************************************/
76static size_t BMK_findMaxMem(U64 requiredMem)
77{
78 size_t const step = 64 MB;
79 void* testmem = NULL;
80
81 requiredMem = (((requiredMem >> 26) + 1) << 26);
82 if (requiredMem > MAX_MEM) requiredMem = MAX_MEM;
83
84 requiredMem += step;
85 do {
86 testmem = malloc ((size_t)requiredMem);
87 requiredMem -= step;
88 } while (!testmem);
89
90 free (testmem);
91 return (size_t) requiredMem;
92}
93
94
95/*_*******************************************************
96* Benchmark wrappers
97*********************************************************/
98
99static ZSTD_CCtx* g_zcc = NULL;
100
101static size_t
102local_ZSTD_compress(const void* src, size_t srcSize,
103 void* dst, size_t dstSize,
104 void* payload)
105{
106 ZSTD_parameters p;
107 ZSTD_frameParameters f = { 1 /* contentSizeHeader*/, 0, 0 };
108 p.fParams = f;
109 p.cParams = *(ZSTD_compressionParameters*)payload;
110 return ZSTD_compress_advanced (g_zcc, dst, dstSize, src, srcSize, NULL ,0, p);
111}
112
113static size_t
114local_ZSTD_compress_freshCCtx(const void* src, size_t srcSize,
115 void* dst, size_t dstSize,
116 void* payload)
117{
118 ZSTD_parameters p;
119 ZSTD_frameParameters f = { 1 /* contentSizeHeader*/, 0, 0 };
120 p.fParams = f;
121 p.cParams = *(ZSTD_compressionParameters*)payload;
122 if (g_zcc != NULL) ZSTD_freeCCtx(g_zcc);
123 g_zcc = ZSTD_createCCtx();
124 assert(g_zcc != NULL);
125 { size_t const r = ZSTD_compress_advanced (g_zcc, dst, dstSize, src, srcSize, NULL ,0, p);
126 ZSTD_freeCCtx(g_zcc);
127 g_zcc = NULL;
128 return r;
129 }
130}
131
132static size_t g_cSize = 0;
133static size_t local_ZSTD_decompress(const void* src, size_t srcSize,
134 void* dst, size_t dstSize,
135 void* buff2)
136{
137 (void)src; (void)srcSize;
138 return ZSTD_decompress(dst, dstSize, buff2, g_cSize);
139}
140
141static ZSTD_DCtx* g_zdc = NULL;
142
143#ifndef ZSTD_DLL_IMPORT
144typedef enum {
145 not_streaming = 0,
146 is_streaming = 1
147} streaming_operation;
148extern size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* ctx, const void* src, size_t srcSize, void* dst, size_t dstCapacity, const streaming_operation streaming);
149static size_t local_ZSTD_decodeLiteralsBlock(const void* src, size_t srcSize, void* dst, size_t dstSize, void* buff2)
150{
151 (void)src; (void)srcSize; (void)dst; (void)dstSize;
152 return ZSTD_decodeLiteralsBlock(g_zdc, buff2, g_cSize, dst, dstSize, not_streaming);
153}
154
155static size_t local_ZSTD_decodeSeqHeaders(const void* src, size_t srcSize, void* dst, size_t dstSize, void* buff2)
156{
157 int nbSeq;
158 (void)src; (void)srcSize; (void)dst; (void)dstSize;
159 return ZSTD_decodeSeqHeaders(g_zdc, &nbSeq, buff2, g_cSize);
160}
161
162FORCE_NOINLINE size_t ZSTD_decodeLiteralsHeader(ZSTD_DCtx* dctx, void const* src, size_t srcSize)
163{
164 RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, "");
165 {
166 BYTE const* istart = (BYTE const*)src;
167 symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
168 if (litEncType == set_compressed) {
169 RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3");
170 {
171 size_t lhSize, litSize, litCSize;
172 U32 const lhlCode = (istart[0] >> 2) & 3;
173 U32 const lhc = MEM_readLE32(istart);
174 int const flags = ZSTD_DCtx_get_bmi2(dctx) ? HUF_flags_bmi2 : 0;
175 switch(lhlCode)
176 {
177 case 0: case 1: default: /* note : default is impossible, since lhlCode into [0..3] */
178 /* 2 - 2 - 10 - 10 */
179 lhSize = 3;
180 litSize = (lhc >> 4) & 0x3FF;
181 litCSize = (lhc >> 14) & 0x3FF;
182 break;
183 case 2:
184 /* 2 - 2 - 14 - 14 */
185 lhSize = 4;
186 litSize = (lhc >> 4) & 0x3FFF;
187 litCSize = lhc >> 18;
188 break;
189 case 3:
190 /* 2 - 2 - 18 - 18 */
191 lhSize = 5;
192 litSize = (lhc >> 4) & 0x3FFFF;
193 litCSize = (lhc >> 22) + ((size_t)istart[4] << 10);
194 break;
195 }
196 RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, "");
197 RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, "");
198#ifndef HUF_FORCE_DECOMPRESS_X2
199 return HUF_readDTableX1_wksp(
200 dctx->entropy.hufTable,
201 istart+lhSize, litCSize,
202 dctx->workspace, sizeof(dctx->workspace),
203 flags);
204#else
205 return HUF_readDTableX2_wksp(
206 dctx->entropy.hufTable,
207 istart+lhSize, litCSize,
208 dctx->workspace, sizeof(dctx->workspace), flags);
209#endif
210 }
211 }
212 }
213 return 0;
214}
215
216static size_t local_ZSTD_decodeLiteralsHeader(const void* src, size_t srcSize, void* dst, size_t dstSize, void* buff2)
217{
218 (void)dst, (void)dstSize, (void)src, (void)srcSize;
219 return ZSTD_decodeLiteralsHeader(g_zdc, buff2, g_cSize);
220}
221#endif
222
223static ZSTD_CStream* g_cstream= NULL;
224static size_t
225local_ZSTD_compressStream(const void* src, size_t srcSize,
226 void* dst, size_t dstCapacity,
227 void* payload)
228{
229 ZSTD_outBuffer buffOut;
230 ZSTD_inBuffer buffIn;
231 ZSTD_parameters p;
232 ZSTD_frameParameters f = {1 /* contentSizeHeader*/, 0, 0};
233 p.fParams = f;
234 p.cParams = *(ZSTD_compressionParameters*)payload;
235 ZSTD_initCStream_advanced(g_cstream, NULL, 0, p, ZSTD_CONTENTSIZE_UNKNOWN);
236 buffOut.dst = dst;
237 buffOut.size = dstCapacity;
238 buffOut.pos = 0;
239 buffIn.src = src;
240 buffIn.size = srcSize;
241 buffIn.pos = 0;
242 ZSTD_compressStream(g_cstream, &buffOut, &buffIn);
243 ZSTD_endStream(g_cstream, &buffOut);
244 return buffOut.pos;
245}
246
247static size_t
248local_ZSTD_compressStream_freshCCtx(const void* src, size_t srcSize,
249 void* dst, size_t dstCapacity,
250 void* payload)
251{
252 if (g_cstream != NULL) ZSTD_freeCCtx(g_cstream);
253 g_cstream = ZSTD_createCCtx();
254 assert(g_cstream != NULL);
255
256 { size_t const r = local_ZSTD_compressStream(src, srcSize, dst, dstCapacity, payload);
257 ZSTD_freeCCtx(g_cstream);
258 g_cstream = NULL;
259 return r;
260 }
261}
262
263static size_t
264local_ZSTD_compress2(const void* src, size_t srcSize,
265 void* dst, size_t dstCapacity,
266 void* payload)
267{
268 (void)payload;
269 return ZSTD_compress2(g_cstream, dst, dstCapacity, src, srcSize);
270}
271
272static size_t
273local_ZSTD_compressStream2_end(const void* src, size_t srcSize,
274 void* dst, size_t dstCapacity,
275 void* payload)
276{
277 ZSTD_outBuffer buffOut;
278 ZSTD_inBuffer buffIn;
279 (void)payload;
280 buffOut.dst = dst;
281 buffOut.size = dstCapacity;
282 buffOut.pos = 0;
283 buffIn.src = src;
284 buffIn.size = srcSize;
285 buffIn.pos = 0;
286 ZSTD_compressStream2(g_cstream, &buffOut, &buffIn, ZSTD_e_end);
287 return buffOut.pos;
288}
289
290static size_t
291local_ZSTD_compressStream2_continue(const void* src, size_t srcSize,
292 void* dst, size_t dstCapacity,
293 void* payload)
294{
295 ZSTD_outBuffer buffOut;
296 ZSTD_inBuffer buffIn;
297 (void)payload;
298 buffOut.dst = dst;
299 buffOut.size = dstCapacity;
300 buffOut.pos = 0;
301 buffIn.src = src;
302 buffIn.size = srcSize;
303 buffIn.pos = 0;
304 ZSTD_compressStream2(g_cstream, &buffOut, &buffIn, ZSTD_e_continue);
305 ZSTD_compressStream2(g_cstream, &buffOut, &buffIn, ZSTD_e_end);
306 return buffOut.pos;
307}
308
309static size_t
310local_ZSTD_compress_generic_T2_end(const void* src, size_t srcSize,
311 void* dst, size_t dstCapacity,
312 void* payload)
313{
314 (void)payload;
315 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_nbWorkers, 2);
316 return ZSTD_compress2(g_cstream, dst, dstCapacity, src, srcSize);
317}
318
319static size_t
320local_ZSTD_compress_generic_T2_continue(const void* src, size_t srcSize,
321 void* dst, size_t dstCapacity,
322 void* payload)
323{
324 ZSTD_outBuffer buffOut;
325 ZSTD_inBuffer buffIn;
326 (void)payload;
327 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_nbWorkers, 2);
328 buffOut.dst = dst;
329 buffOut.size = dstCapacity;
330 buffOut.pos = 0;
331 buffIn.src = src;
332 buffIn.size = srcSize;
333 buffIn.pos = 0;
334 ZSTD_compressStream2(g_cstream, &buffOut, &buffIn, ZSTD_e_continue);
335 while(ZSTD_compressStream2(g_cstream, &buffOut, &buffIn, ZSTD_e_end)) {}
336 return buffOut.pos;
337}
338
339static ZSTD_DStream* g_dstream= NULL;
340static size_t
341local_ZSTD_decompressStream(const void* src, size_t srcSize,
342 void* dst, size_t dstCapacity,
343 void* buff2)
344{
345 ZSTD_outBuffer buffOut;
346 ZSTD_inBuffer buffIn;
347 (void)src; (void)srcSize;
348 ZSTD_initDStream(g_dstream);
349 buffOut.dst = dst;
350 buffOut.size = dstCapacity;
351 buffOut.pos = 0;
352 buffIn.src = buff2;
353 buffIn.size = g_cSize;
354 buffIn.pos = 0;
355 ZSTD_decompressStream(g_dstream, &buffOut, &buffIn);
356 return buffOut.pos;
357}
358
359#ifndef ZSTD_DLL_IMPORT
360static size_t local_ZSTD_compressContinue(const void* src, size_t srcSize,
361 void* dst, size_t dstCapacity,
362 void* payload)
363{
364 ZSTD_parameters p;
365 ZSTD_frameParameters f = { 1 /* contentSizeHeader*/, 0, 0 };
366 p.fParams = f;
367 p.cParams = *(ZSTD_compressionParameters*)payload;
368 ZSTD_compressBegin_advanced(g_zcc, NULL, 0, p, srcSize);
369 return ZSTD_compressEnd(g_zcc, dst, dstCapacity, src, srcSize);
370}
371
372#define FIRST_BLOCK_SIZE 8
373static size_t
374local_ZSTD_compressContinue_extDict(const void* src, size_t srcSize,
375 void* dst, size_t dstCapacity,
376 void* payload)
377{
378 BYTE firstBlockBuf[FIRST_BLOCK_SIZE];
379
380 ZSTD_parameters p;
381 ZSTD_frameParameters const f = { 1, 0, 0 };
382 p.fParams = f;
383 p.cParams = *(ZSTD_compressionParameters*)payload;
384 ZSTD_compressBegin_advanced(g_zcc, NULL, 0, p, srcSize);
385 memcpy(firstBlockBuf, src, FIRST_BLOCK_SIZE);
386
387 { size_t const compressResult = ZSTD_compressContinue(g_zcc,
388 dst, dstCapacity,
389 firstBlockBuf, FIRST_BLOCK_SIZE);
390 if (ZSTD_isError(compressResult)) {
391 DISPLAY("local_ZSTD_compressContinue_extDict error : %s\n",
392 ZSTD_getErrorName(compressResult));
393 return compressResult;
394 }
395 dst = (BYTE*)dst + compressResult;
396 dstCapacity -= compressResult;
397 }
398 return ZSTD_compressEnd(g_zcc, dst, dstCapacity,
399 (const BYTE*)src + FIRST_BLOCK_SIZE,
400 srcSize - FIRST_BLOCK_SIZE);
401}
402
403static size_t local_ZSTD_decompressContinue(const void* src, size_t srcSize,
404 void* dst, size_t dstCapacity,
405 void* buff2)
406{
407 size_t regeneratedSize = 0;
408 const BYTE* ip = (const BYTE*)buff2;
409 const BYTE* const iend = ip + g_cSize;
410 BYTE* op = (BYTE*)dst;
411 size_t remainingCapacity = dstCapacity;
412
413 (void)src; (void)srcSize; /* unused */
414 ZSTD_decompressBegin(g_zdc);
415 while (ip < iend) {
416 size_t const iSize = ZSTD_nextSrcSizeToDecompress(g_zdc);
417 size_t const decodedSize = ZSTD_decompressContinue(g_zdc, op, remainingCapacity, ip, iSize);
418 ip += iSize;
419 regeneratedSize += decodedSize;
420 op += decodedSize;
421 remainingCapacity -= decodedSize;
422 }
423
424 return regeneratedSize;
425}
426#endif
427
428
429/*_*******************************************************
430* Bench functions
431*********************************************************/
432static int benchMem(unsigned benchNb,
433 const void* src, size_t srcSize,
434 int cLevel, ZSTD_compressionParameters cparams)
435{
436 size_t dstBuffSize = ZSTD_compressBound(srcSize);
437 BYTE* dstBuff;
438 void* dstBuff2;
439 void* payload;
440 const char* benchName;
441 BMK_benchFn_t benchFunction;
442 int errorcode = 0;
443
444 /* Selection */
445 switch(benchNb)
446 {
447 case 1:
448 benchFunction = local_ZSTD_compress; benchName = "compress";
449 break;
450 case 2:
451 benchFunction = local_ZSTD_decompress; benchName = "decompress";
452 break;
453 case 3:
454 benchFunction = local_ZSTD_compress_freshCCtx; benchName = "compress_freshCCtx";
455 break;
456#ifndef ZSTD_DLL_IMPORT
457 case 11:
458 benchFunction = local_ZSTD_compressContinue; benchName = "compressContinue";
459 break;
460 case 12:
461 benchFunction = local_ZSTD_compressContinue_extDict; benchName = "compressContinue_extDict";
462 break;
463 case 13:
464 benchFunction = local_ZSTD_decompressContinue; benchName = "decompressContinue";
465 break;
466 case 30:
467 benchFunction = local_ZSTD_decodeLiteralsHeader; benchName = "decodeLiteralsHeader";
468 break;
469 case 31:
470 benchFunction = local_ZSTD_decodeLiteralsBlock; benchName = "decodeLiteralsBlock";
471 break;
472 case 32:
473 benchFunction = local_ZSTD_decodeSeqHeaders; benchName = "decodeSeqHeaders";
474 break;
475#endif
476 case 41:
477 benchFunction = local_ZSTD_compressStream; benchName = "compressStream";
478 break;
479 case 42:
480 benchFunction = local_ZSTD_decompressStream; benchName = "decompressStream";
481 break;
482 case 43:
483 benchFunction = local_ZSTD_compressStream_freshCCtx; benchName = "compressStream_freshCCtx";
484 break;
485 case 50:
486 benchFunction = local_ZSTD_compress2; benchName = "compress2";
487 break;
488 case 51:
489 benchFunction = local_ZSTD_compressStream2_end; benchName = "compressStream2, end";
490 break;
491 case 52:
492 benchFunction = local_ZSTD_compressStream2_end; benchName = "compressStream2, end & short";
493 break;
494 case 53:
495 benchFunction = local_ZSTD_compressStream2_continue; benchName = "compressStream2, continue";
496 break;
497 case 61:
498 benchFunction = local_ZSTD_compress_generic_T2_continue; benchName = "compress_generic, -T2, continue";
499 break;
500 case 62:
501 benchFunction = local_ZSTD_compress_generic_T2_end; benchName = "compress_generic, -T2, end";
502 break;
503 default :
504 return 0;
505 }
506
507 /* Allocation */
508 dstBuff = (BYTE*)malloc(dstBuffSize);
509 dstBuff2 = malloc(dstBuffSize);
510 if ((!dstBuff) || (!dstBuff2)) {
511 DISPLAY("\nError: not enough memory!\n");
512 free(dstBuff); free(dstBuff2);
513 return 12;
514 }
515 payload = dstBuff2;
516 if (g_zcc==NULL) g_zcc = ZSTD_createCCtx();
517 if (g_zdc==NULL) g_zdc = ZSTD_createDCtx();
518 if (g_cstream==NULL) g_cstream = ZSTD_createCStream();
519 if (g_dstream==NULL) g_dstream = ZSTD_createDStream();
520
521 /* DISPLAY("params: cLevel %d, wlog %d hlog %d clog %d slog %d mml %d tlen %d strat %d \n",
522 cLevel, cparams->windowLog, cparams->hashLog, cparams->chainLog, cparams->searchLog,
523 cparams->minMatch, cparams->targetLength, cparams->strategy); */
524
525 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_compressionLevel, cLevel);
526 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_windowLog, (int)cparams.windowLog);
527 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_hashLog, (int)cparams.hashLog);
528 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_chainLog, (int)cparams.chainLog);
529 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_searchLog, (int)cparams.searchLog);
530 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_minMatch, (int)cparams.minMatch);
531 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_targetLength, (int)cparams.targetLength);
532 ZSTD_CCtx_setParameter(g_zcc, ZSTD_c_strategy, cparams.strategy);
533
534 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_compressionLevel, cLevel);
535 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_windowLog, (int)cparams.windowLog);
536 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_hashLog, (int)cparams.hashLog);
537 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_chainLog, (int)cparams.chainLog);
538 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_searchLog, (int)cparams.searchLog);
539 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_minMatch, (int)cparams.minMatch);
540 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_targetLength, (int)cparams.targetLength);
541 ZSTD_CCtx_setParameter(g_cstream, ZSTD_c_strategy, cparams.strategy);
542
543 /* Preparation */
544 switch(benchNb)
545 {
546 case 1:
547 payload = &cparams;
548 break;
549 case 2:
550 g_cSize = ZSTD_compress(dstBuff2, dstBuffSize, src, srcSize, cLevel);
551 break;
552 case 3:
553 payload = &cparams;
554 break;
555#ifndef ZSTD_DLL_IMPORT
556 case 11:
557 payload = &cparams;
558 break;
559 case 12:
560 payload = &cparams;
561 break;
562 case 13 :
563 g_cSize = ZSTD_compress(dstBuff2, dstBuffSize, src, srcSize, cLevel);
564 break;
565 case 30: /* ZSTD_decodeLiteralsHeader */
566 /* fall-through */
567 case 31: /* ZSTD_decodeLiteralsBlock : starts literals block in dstBuff2 */
568 { size_t frameHeaderSize;
569 g_cSize = ZSTD_compress(dstBuff, dstBuffSize, src, srcSize, cLevel);
570 frameHeaderSize = ZSTD_frameHeaderSize(dstBuff, ZSTD_FRAMEHEADERSIZE_PREFIX(ZSTD_f_zstd1));
571 CONTROL(!ZSTD_isError(frameHeaderSize));
572 /* check block is compressible, hence contains a literals section */
573 { blockProperties_t bp;
574 ZSTD_getcBlockSize(dstBuff+frameHeaderSize, dstBuffSize, &bp); /* Get 1st block type */
575 if (bp.blockType != bt_compressed) {
576 DISPLAY("ZSTD_decodeLiteralsBlock : impossible to test on this sample (not compressible)\n");
577 goto _cleanOut;
578 } }
579 { size_t const skippedSize = frameHeaderSize + ZSTD_blockHeaderSize;
580 memcpy(dstBuff2, dstBuff+skippedSize, g_cSize-skippedSize);
581 }
582 srcSize = srcSize > 128 KB ? 128 KB : srcSize; /* speed relative to block */
583 ZSTD_decompressBegin(g_zdc);
584 break;
585 }
586 case 32: /* ZSTD_decodeSeqHeaders */
587 { blockProperties_t bp;
588 const BYTE* ip = dstBuff;
589 const BYTE* iend;
590 { size_t const cSize = ZSTD_compress(dstBuff, dstBuffSize, src, srcSize, cLevel);
591 CONTROL(cSize > ZSTD_FRAMEHEADERSIZE_PREFIX(ZSTD_f_zstd1));
592 }
593 /* Skip frame Header */
594 { size_t const frameHeaderSize = ZSTD_frameHeaderSize(dstBuff, ZSTD_FRAMEHEADERSIZE_PREFIX(ZSTD_f_zstd1));
595 CONTROL(!ZSTD_isError(frameHeaderSize));
596 ip += frameHeaderSize;
597 }
598 /* Find end of block */
599 { size_t const cBlockSize = ZSTD_getcBlockSize(ip, dstBuffSize, &bp); /* Get 1st block type */
600 if (bp.blockType != bt_compressed) {
601 DISPLAY("ZSTD_decodeSeqHeaders : impossible to test on this sample (not compressible)\n");
602 goto _cleanOut;
603 }
604 iend = ip + ZSTD_blockHeaderSize + cBlockSize; /* End of first block */
605 }
606 ip += ZSTD_blockHeaderSize; /* skip block header */
607 ZSTD_decompressBegin(g_zdc);
608 CONTROL(iend > ip);
609 ip += ZSTD_decodeLiteralsBlock(g_zdc, ip, (size_t)(iend-ip), dstBuff, dstBuffSize, not_streaming); /* skip literal segment */
610 g_cSize = (size_t)(iend-ip);
611 memcpy(dstBuff2, ip, g_cSize); /* copy rest of block (it starts by SeqHeader) */
612 srcSize = srcSize > 128 KB ? 128 KB : srcSize; /* speed relative to block */
613 break;
614 }
615#else
616 case 31:
617 goto _cleanOut;
618#endif
619 case 41 :
620 payload = &cparams;
621 break;
622 case 42 :
623 g_cSize = ZSTD_compress(payload, dstBuffSize, src, srcSize, cLevel);
624 break;
625 case 43 :
626 payload = &cparams;
627 break;
628
629 case 52 :
630 /* compressStream2, short dstCapacity */
631 dstBuffSize--;
632 break;
633
634 /* test functions */
635 /* convention: test functions have ID > 100 */
636
637 default : ;
638 }
639
640 /* warming up dstBuff */
641 { size_t i; for (i=0; i<dstBuffSize; i++) dstBuff[i]=(BYTE)i; }
642
643 /* benchmark loop */
644 { BMK_timedFnState_t* const tfs = BMK_createTimedFnState(g_nbIterations * 1000, 1000);
645 void* const avoidStrictAliasingPtr = &dstBuff;
646 BMK_benchParams_t bp;
647 BMK_runTime_t bestResult;
648 bestResult.sumOfReturn = 0;
649 bestResult.nanoSecPerRun = (double)TIMELOOP_NANOSEC * 2000000000; /* hopefully large enough : must be larger than any potential measurement */
650 CONTROL(tfs != NULL);
651
652 bp.benchFn = benchFunction;
653 bp.benchPayload = payload;
654 bp.initFn = NULL;
655 bp.initPayload = NULL;
656 bp.errorFn = ZSTD_isError;
657 bp.blockCount = 1;
658 bp.srcBuffers = &src;
659 bp.srcSizes = &srcSize;
660 bp.dstBuffers = (void* const*) avoidStrictAliasingPtr; /* circumvent strict aliasing warning on gcc-8,
661 * because gcc considers that `void* const *` and `void**` are 2 different types */
662 bp.dstCapacities = &dstBuffSize;
663 bp.blockResults = NULL;
664
665 for (;;) {
666 BMK_runOutcome_t const bOutcome = BMK_benchTimedFn(tfs, bp);
667
668 if (!BMK_isSuccessful_runOutcome(bOutcome)) {
669 DISPLAY("ERROR benchmarking function ! ! \n");
670 errorcode = 1;
671 goto _cleanOut;
672 }
673
674 { BMK_runTime_t const newResult = BMK_extract_runTime(bOutcome);
675 if (newResult.nanoSecPerRun < bestResult.nanoSecPerRun )
676 bestResult.nanoSecPerRun = newResult.nanoSecPerRun;
677 DISPLAY("\r%2u#%-29.29s:%8.1f MB/s (%8u) ",
678 benchNb, benchName,
679 (double)srcSize * TIMELOOP_NANOSEC / bestResult.nanoSecPerRun / MB_UNIT,
680 (unsigned)newResult.sumOfReturn );
681 }
682
683 if ( BMK_isCompleted_TimedFn(tfs) ) break;
684 }
685 BMK_freeTimedFnState(tfs);
686 }
687 DISPLAY("\n");
688
689_cleanOut:
690 free(dstBuff);
691 free(dstBuff2);
692 ZSTD_freeCCtx(g_zcc); g_zcc=NULL;
693 ZSTD_freeDCtx(g_zdc); g_zdc=NULL;
694 ZSTD_freeCStream(g_cstream); g_cstream=NULL;
695 ZSTD_freeDStream(g_dstream); g_dstream=NULL;
696 return errorcode;
697}
698
699
700static int benchSample(U32 benchNb,
701 size_t benchedSize, double compressibility,
702 int cLevel, ZSTD_compressionParameters cparams)
703{
704 /* Allocation */
705 void* const origBuff = malloc(benchedSize);
706 if (!origBuff) { DISPLAY("\nError: not enough memory!\n"); return 12; }
707
708 /* Fill buffer */
709 RDG_genBuffer(origBuff, benchedSize, compressibility, 0.0, 0);
710
711 /* bench */
712 DISPLAY("\r%70s\r", "");
713 DISPLAY(" Sample %u bytes : \n", (unsigned)benchedSize);
714 if (benchNb) {
715 benchMem(benchNb, origBuff, benchedSize, cLevel, cparams);
716 } else { /* 0 == run all tests */
717 for (benchNb=0; benchNb<100; benchNb++) {
718 benchMem(benchNb, origBuff, benchedSize, cLevel, cparams);
719 } }
720
721 free(origBuff);
722 return 0;
723}
724
725
726static int benchFiles(U32 benchNb,
727 const char** fileNamesTable, const int nbFiles,
728 int cLevel, ZSTD_compressionParameters cparams)
729{
730 /* Loop for each file */
731 int fileIdx;
732 for (fileIdx=0; fileIdx<nbFiles; fileIdx++) {
733 const char* const inFileName = fileNamesTable[fileIdx];
734 FILE* const inFile = fopen( inFileName, "rb" );
735 size_t benchedSize;
736
737 /* Check file existence */
738 if (inFile==NULL) { DISPLAY( "Pb opening %s\n", inFileName); return 11; }
739
740 /* Memory allocation & restrictions */
741 { U64 const inFileSize = UTIL_getFileSize(inFileName);
742 if (inFileSize == UTIL_FILESIZE_UNKNOWN) {
743 DISPLAY( "Cannot measure size of %s\n", inFileName);
744 fclose(inFile);
745 return 11;
746 }
747 benchedSize = BMK_findMaxMem(inFileSize*3) / 3;
748 if ((U64)benchedSize > inFileSize)
749 benchedSize = (size_t)inFileSize;
750 if ((U64)benchedSize < inFileSize) {
751 DISPLAY("Not enough memory for '%s' full size; testing %u MB only... \n",
752 inFileName, (unsigned)(benchedSize>>20));
753 } }
754
755 /* Alloc */
756 { void* const origBuff = malloc(benchedSize);
757 if (!origBuff) { DISPLAY("\nError: not enough memory!\n"); fclose(inFile); return 12; }
758
759 /* Fill input buffer */
760 DISPLAY("Loading %s... \r", inFileName);
761 { size_t const readSize = fread(origBuff, 1, benchedSize, inFile);
762 fclose(inFile);
763 if (readSize != benchedSize) {
764 DISPLAY("\nError: problem reading file '%s' !! \n", inFileName);
765 free(origBuff);
766 return 13;
767 } }
768
769 /* bench */
770 DISPLAY("\r%70s\r", ""); /* blank line */
771 DISPLAY(" %s : \n", inFileName);
772 if (benchNb) {
773 benchMem(benchNb, origBuff, benchedSize, cLevel, cparams);
774 } else {
775 for (benchNb=0; benchNb<100; benchNb++) {
776 benchMem(benchNb, origBuff, benchedSize, cLevel, cparams);
777 }
778 benchNb = 0;
779 }
780
781 free(origBuff);
782 } }
783
784 return 0;
785}
786
787
788
789/*_*******************************************************
790* Argument Parsing
791*********************************************************/
792
793#define ERROR_OUT(msg) { DISPLAY("%s \n", msg); exit(1); }
794
795static unsigned readU32FromChar(const char** stringPtr)
796{
797 const char errorMsg[] = "error: numeric value too large";
798 unsigned result = 0;
799 while ((**stringPtr >='0') && (**stringPtr <='9')) {
800 unsigned const max = (((unsigned)(-1)) / 10) - 1;
801 if (result > max) ERROR_OUT(errorMsg);
802 result *= 10;
803 result += (unsigned)(**stringPtr - '0');
804 (*stringPtr)++ ;
805 }
806 if ((**stringPtr=='K') || (**stringPtr=='M')) {
807 unsigned const maxK = ((unsigned)(-1)) >> 10;
808 if (result > maxK) ERROR_OUT(errorMsg);
809 result <<= 10;
810 if (**stringPtr=='M') {
811 if (result > maxK) ERROR_OUT(errorMsg);
812 result <<= 10;
813 }
814 (*stringPtr)++; /* skip `K` or `M` */
815 if (**stringPtr=='i') (*stringPtr)++;
816 if (**stringPtr=='B') (*stringPtr)++;
817 }
818 return result;
819}
820
821static int longCommandWArg(const char** stringPtr, const char* longCommand)
822{
823 size_t const comSize = strlen(longCommand);
824 int const result = !strncmp(*stringPtr, longCommand, comSize);
825 if (result) *stringPtr += comSize;
826 return result;
827}
828
829
830/*_*******************************************************
831* Command line
832*********************************************************/
833
834static int usage(const char* exename)
835{
836 DISPLAY( "Usage :\n");
837 DISPLAY( " %s [arg] file1 file2 ... fileX\n", exename);
838 DISPLAY( "Arguments :\n");
839 DISPLAY( " -H/-h : Help (this text + advanced options)\n");
840 return 0;
841}
842
843static int usage_advanced(const char* exename)
844{
845 usage(exename);
846 DISPLAY( "\nAdvanced options :\n");
847 DISPLAY( " -b# : test only function # \n");
848 DISPLAY( " -l# : benchmark functions at that compression level (default : %i)\n", DEFAULT_CLEVEL);
849 DISPLAY( "--zstd= : custom parameter selection. Format same as zstdcli \n");
850 DISPLAY( " -P# : sample compressibility (default : %.1f%%)\n", COMPRESSIBILITY_DEFAULT * 100);
851 DISPLAY( " -B# : sample size (default : %u)\n", (unsigned)kSampleSizeDefault);
852 DISPLAY( " -i# : iteration loops [1-9](default : %i)\n", NBLOOPS);
853 return 0;
854}
855
856static int badusage(const char* exename)
857{
858 DISPLAY("Wrong parameters\n");
859 usage(exename);
860 return 1;
861}
862
863int main(int argc, const char** argv)
864{
865 int argNb, filenamesStart=0, result;
866 const char* const exename = argv[0];
867 const char* input_filename = NULL;
868 U32 benchNb = 0, main_pause = 0;
869 int cLevel = DEFAULT_CLEVEL;
870 ZSTD_compressionParameters cparams = ZSTD_getCParams(cLevel, 0, 0);
871 size_t sampleSize = kSampleSizeDefault;
872 double compressibility = COMPRESSIBILITY_DEFAULT;
873
874 DISPLAY(WELCOME_MESSAGE);
875 if (argc<1) return badusage(exename);
876
877 for (argNb=1; argNb<argc; argNb++) {
878 const char* argument = argv[argNb];
879 CONTROL(argument != NULL);
880
881 if (longCommandWArg(&argument, "--zstd=")) {
882 for ( ; ;) {
883 if (longCommandWArg(&argument, "windowLog=") || longCommandWArg(&argument, "wlog=")) { cparams.windowLog = readU32FromChar(&argument); if (argument[0]==',') { argument++; continue; } else break; }
884 if (longCommandWArg(&argument, "chainLog=") || longCommandWArg(&argument, "clog=")) { cparams.chainLog = readU32FromChar(&argument); if (argument[0]==',') { argument++; continue; } else break; }
885 if (longCommandWArg(&argument, "hashLog=") || longCommandWArg(&argument, "hlog=")) { cparams.hashLog = readU32FromChar(&argument); if (argument[0]==',') { argument++; continue; } else break; }
886 if (longCommandWArg(&argument, "searchLog=") || longCommandWArg(&argument, "slog=")) { cparams.searchLog = readU32FromChar(&argument); if (argument[0]==',') { argument++; continue; } else break; }
887 if (longCommandWArg(&argument, "minMatch=") || longCommandWArg(&argument, "mml=")) { cparams.minMatch = readU32FromChar(&argument); if (argument[0]==',') { argument++; continue; } else break; }
888 if (longCommandWArg(&argument, "targetLength=") || longCommandWArg(&argument, "tlen=")) { cparams.targetLength = readU32FromChar(&argument); if (argument[0]==',') { argument++; continue; } else break; }
889 if (longCommandWArg(&argument, "strategy=") || longCommandWArg(&argument, "strat=")) { cparams.strategy = (ZSTD_strategy)(readU32FromChar(&argument)); if (argument[0]==',') { argument++; continue; } else break; }
890 if (longCommandWArg(&argument, "level=") || longCommandWArg(&argument, "lvl=")) { cLevel = (int)readU32FromChar(&argument); cparams = ZSTD_getCParams(cLevel, 0, 0); if (argument[0]==',') { argument++; continue; } else break; }
891 DISPLAY("invalid compression parameter \n");
892 return 1;
893 }
894
895 /* check end of string */
896 if (argument[0] != 0) {
897 DISPLAY("invalid --zstd= format \n");
898 return 1;
899 } else {
900 continue;
901 }
902
903 } else if (argument[0]=='-') { /* Commands (note : aggregated commands are allowed) */
904 argument++;
905 while (argument[0]!=0) {
906
907 switch(argument[0])
908 {
909 /* Display help on usage */
910 case 'h':
911 case 'H': return usage_advanced(exename);
912
913 /* Pause at the end (hidden option) */
914 case 'p': main_pause = 1; break;
915
916 /* Select specific algorithm to bench */
917 case 'b':
918 argument++;
919 benchNb = readU32FromChar(&argument);
920 break;
921
922 /* Select compression level to use */
923 case 'l':
924 argument++;
925 cLevel = (int)readU32FromChar(&argument);
926 cparams = ZSTD_getCParams(cLevel, 0, 0);
927 break;
928
929 /* Select compressibility of synthetic sample */
930 case 'P':
931 argument++;
932 compressibility = (double)readU32FromChar(&argument) / 100.;
933 break;
934
935 /* Select size of synthetic sample */
936 case 'B':
937 argument++;
938 sampleSize = (size_t)readU32FromChar(&argument);
939 break;
940
941 /* Modify Nb Iterations */
942 case 'i':
943 argument++;
944 g_nbIterations = readU32FromChar(&argument);
945 break;
946
947 /* Unknown command */
948 default : return badusage(exename);
949 }
950 }
951 continue;
952 }
953
954 /* first provided filename is input */
955 if (!input_filename) { input_filename=argument; filenamesStart=argNb; continue; }
956 }
957
958
959
960 if (filenamesStart==0) /* no input file */
961 result = benchSample(benchNb, sampleSize, compressibility, cLevel, cparams);
962 else
963 result = benchFiles(benchNb, argv+filenamesStart, argc-filenamesStart, cLevel, cparams);
964
965 if (main_pause) { int unused; printf("press enter...\n"); unused = getchar(); (void)unused; }
966
967 return result;
968}
ARM optimized PCSX fork