1 /* 2 * Copyright (c) 2017-2020, 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 /*=== 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 } 138