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 | /*=== Tuning parameter ===*/ |
13 | #ifndef MAX_TESTED_LEVEL |
14 | #define MAX_TESTED_LEVEL 12 |
15 | #endif |
16 | |
17 | |
18 | /*=== Dependencies ===*/ |
19 | #include <stdio.h> // printf |
20 | #define ZSTD_STATIC_LINKING_ONLY |
21 | #include <zstd.h> // presumes zstd library is installed |
22 | #include "common.h" // Helper functions, CHECK(), and CHECK_ZSTD() |
23 | |
24 | |
25 | /*=== functions ===*/ |
26 | |
27 | /*! readU32FromChar() : |
28 | @return : unsigned integer value read from input in `char` format |
29 | allows and interprets K, KB, KiB, M, MB and MiB suffix. |
30 | Will also modify `*stringPtr`, advancing it to position where it stopped reading. |
31 | Note : function result can overflow if digit string > MAX_UINT */ |
32 | static unsigned readU32FromChar(const char** stringPtr) |
33 | { |
34 | unsigned result = 0; |
35 | while ((**stringPtr >='0') && (**stringPtr <='9')) |
36 | result *= 10, result += **stringPtr - '0', (*stringPtr)++ ; |
37 | if ((**stringPtr=='K') || (**stringPtr=='M')) { |
38 | result <<= 10; |
39 | if (**stringPtr=='M') result <<= 10; |
40 | (*stringPtr)++ ; |
41 | if (**stringPtr=='i') (*stringPtr)++; |
42 | if (**stringPtr=='B') (*stringPtr)++; |
43 | } |
44 | return result; |
45 | } |
46 | |
47 | |
48 | int main(int argc, char const *argv[]) { |
49 | |
50 | printf("\n Zstandard (v%s) memory usage for streaming : \n\n", ZSTD_versionString()); |
51 | |
52 | unsigned wLog = 0; |
53 | if (argc > 1) { |
54 | const char* valStr = argv[1]; |
55 | wLog = readU32FromChar(&valStr); |
56 | } |
57 | |
58 | int compressionLevel; |
59 | for (compressionLevel = 1; compressionLevel <= MAX_TESTED_LEVEL; compressionLevel++) { |
60 | #define INPUT_SIZE 5 |
61 | #define COMPRESSED_SIZE 128 |
62 | char const dataToCompress[INPUT_SIZE] = "abcde"; |
63 | char compressedData[COMPRESSED_SIZE]; |
64 | char decompressedData[INPUT_SIZE]; |
65 | /* the ZSTD_CCtx_params structure is a way to save parameters and use |
66 | * them across multiple contexts. We use them here so we can call the |
67 | * function ZSTD_estimateCStreamSize_usingCCtxParams(). |
68 | */ |
69 | ZSTD_CCtx_params* const cctxParams = ZSTD_createCCtxParams(); |
70 | CHECK(cctxParams != NULL, "ZSTD_createCCtxParams() failed!"); |
71 | |
72 | /* Set the compression level. */ |
73 | CHECK_ZSTD( ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_compressionLevel, compressionLevel) ); |
74 | /* Set the window log. |
75 | * The value 0 means use the default window log, which is equivalent to |
76 | * not setting it. |
77 | */ |
78 | CHECK_ZSTD( ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_windowLog, wLog) ); |
79 | |
80 | /* Force the compressor to allocate the maximum memory size for a given |
81 | * level by not providing the pledged source size, or calling |
82 | * ZSTD_compressStream2() with ZSTD_e_end. |
83 | */ |
84 | ZSTD_CCtx* const cctx = ZSTD_createCCtx(); |
85 | CHECK(cctx != NULL, "ZSTD_createCCtx() failed!"); |
86 | CHECK_ZSTD( ZSTD_CCtx_setParametersUsingCCtxParams(cctx, cctxParams) ); |
87 | size_t compressedSize; |
88 | { |
89 | ZSTD_inBuffer inBuff = { dataToCompress, sizeof(dataToCompress), 0 }; |
90 | ZSTD_outBuffer outBuff = { compressedData, sizeof(compressedData), 0 }; |
91 | CHECK_ZSTD( ZSTD_compressStream(cctx, &outBuff, &inBuff) ); |
92 | size_t const remaining = ZSTD_endStream(cctx, &outBuff); |
93 | CHECK_ZSTD(remaining); |
94 | CHECK(remaining == 0, "Frame not flushed!"); |
95 | compressedSize = outBuff.pos; |
96 | } |
97 | |
98 | ZSTD_DCtx* const dctx = ZSTD_createDCtx(); |
99 | CHECK(dctx != NULL, "ZSTD_createDCtx() failed!"); |
100 | /* Set the maximum allowed window log. |
101 | * The value 0 means use the default window log, which is equivalent to |
102 | * not setting it. |
103 | */ |
104 | CHECK_ZSTD( ZSTD_DCtx_setParameter(dctx, ZSTD_d_windowLogMax, wLog) ); |
105 | /* forces decompressor to use maximum memory size, since the |
106 | * decompressed size is not stored in the frame header. |
107 | */ |
108 | { ZSTD_inBuffer inBuff = { compressedData, compressedSize, 0 }; |
109 | ZSTD_outBuffer outBuff = { decompressedData, sizeof(decompressedData), 0 }; |
110 | size_t const remaining = ZSTD_decompressStream(dctx, &outBuff, &inBuff); |
111 | CHECK_ZSTD(remaining); |
112 | CHECK(remaining == 0, "Frame not complete!"); |
113 | CHECK(outBuff.pos == sizeof(dataToCompress), "Bad decompression!"); |
114 | } |
115 | |
116 | size_t const cstreamSize = ZSTD_sizeof_CStream(cctx); |
117 | size_t const cstreamEstimatedSize = ZSTD_estimateCStreamSize_usingCCtxParams(cctxParams); |
118 | size_t const dstreamSize = ZSTD_sizeof_DStream(dctx); |
119 | size_t const dstreamEstimatedSize = ZSTD_estimateDStreamSize_fromFrame(compressedData, compressedSize); |
120 | |
121 | CHECK(cstreamSize <= cstreamEstimatedSize, "Compression mem (%u) > estimated (%u)", |
122 | (unsigned)cstreamSize, (unsigned)cstreamEstimatedSize); |
123 | CHECK(dstreamSize <= dstreamEstimatedSize, "Decompression mem (%u) > estimated (%u)", |
124 | (unsigned)dstreamSize, (unsigned)dstreamEstimatedSize); |
125 | |
126 | printf("Level %2i : Compression Mem = %5u KB (estimated : %5u KB) ; Decompression Mem = %4u KB (estimated : %5u KB)\n", |
127 | compressionLevel, |
128 | (unsigned)(cstreamSize>>10), (unsigned)(cstreamEstimatedSize>>10), |
129 | (unsigned)(dstreamSize>>10), (unsigned)(dstreamEstimatedSize>>10)); |
130 | |
131 | ZSTD_freeDCtx(dctx); |
132 | ZSTD_freeCCtx(cctx); |
133 | ZSTD_freeCCtxParams(cctxParams); |
134 | if (wLog) break; /* single test */ |
135 | } |
136 | return 0; |
137 | } |