FreeBSD/Linux Kernel Cross Reference
sys/contrib/zstd/examples/streaming_memory_usage.c

     /*
      * Copyright (c) Yann Collet, Facebook, Inc.
      * All rights reserved.
      *
      * This source code is licensed under both the BSD-style license (found in the
      * LICENSE file in the root directory of this source tree) and the GPLv2 (found
      * in the COPYING file in the root directory of this source tree).
      * You may select, at your option, one of the above-listed licenses.
      */
    
    
    /*===   Tuning parameter   ===*/
    #ifndef MAX_TESTED_LEVEL
    #define MAX_TESTED_LEVEL 12
    #endif
    
    
    /*===   Dependencies   ===*/
    #include <stdio.h>     // printf
    #define ZSTD_STATIC_LINKING_ONLY
    #include <zstd.h>      // presumes zstd library is installed
    #include "common.h"    // Helper functions, CHECK(), and CHECK_ZSTD()
    
    
    /*===   functions   ===*/
    
    /*! readU32FromChar() :
        @return : unsigned integer value read from input in `char` format
        allows and interprets K, KB, KiB, M, MB and MiB suffix.
        Will also modify `*stringPtr`, advancing it to position where it stopped reading.
        Note : function result can overflow if digit string > MAX_UINT */
    static unsigned readU32FromChar(const char** stringPtr)
    {
        unsigned result = 0;
        while ((**stringPtr >='') && (**stringPtr <='9'))
            result *= 10, result += **stringPtr - '', (*stringPtr)++ ;
        if ((**stringPtr=='K') || (**stringPtr=='M')) {
            result <<= 10;
            if (**stringPtr=='M') result <<= 10;
            (*stringPtr)++ ;
            if (**stringPtr=='i') (*stringPtr)++;
            if (**stringPtr=='B') (*stringPtr)++;
        }
        return result;
    }
    
    
    int main(int argc, char const *argv[]) {
    
        printf("\n Zstandard (v%s) memory usage for streaming : \n\n", ZSTD_versionString());
    
        unsigned wLog = 0;
        if (argc > 1) {
            const char* valStr = argv[1];
            wLog = readU32FromChar(&valStr);
        }
    
        int compressionLevel;
        for (compressionLevel = 1; compressionLevel <= MAX_TESTED_LEVEL; compressionLevel++) {
    #define INPUT_SIZE 5
    #define COMPRESSED_SIZE 128
            char const dataToCompress[INPUT_SIZE] = "abcde";
            char compressedData[COMPRESSED_SIZE];
            char decompressedData[INPUT_SIZE];
            /* the ZSTD_CCtx_params structure is a way to save parameters and use
             * them across multiple contexts. We use them here so we can call the
             * function ZSTD_estimateCStreamSize_usingCCtxParams().
             */
            ZSTD_CCtx_params* const cctxParams = ZSTD_createCCtxParams();
            CHECK(cctxParams != NULL, "ZSTD_createCCtxParams() failed!");
    
            /* Set the compression level. */
            CHECK_ZSTD( ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_compressionLevel, compressionLevel) );
            /* Set the window log.
             * The value 0 means use the default window log, which is equivalent to
             * not setting it.
             */
            CHECK_ZSTD( ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_windowLog, wLog) );
    
            /* Force the compressor to allocate the maximum memory size for a given
             * level by not providing the pledged source size, or calling
             * ZSTD_compressStream2() with ZSTD_e_end.
             */
            ZSTD_CCtx* const cctx = ZSTD_createCCtx();
            CHECK(cctx != NULL, "ZSTD_createCCtx() failed!");
            CHECK_ZSTD( ZSTD_CCtx_setParametersUsingCCtxParams(cctx, cctxParams) );
            size_t compressedSize;
            {
                ZSTD_inBuffer inBuff = { dataToCompress, sizeof(dataToCompress), 0 };
                ZSTD_outBuffer outBuff = { compressedData, sizeof(compressedData), 0 };
                CHECK_ZSTD( ZSTD_compressStream(cctx, &outBuff, &inBuff) );
                size_t const remaining = ZSTD_endStream(cctx, &outBuff);
                CHECK_ZSTD(remaining);
                CHECK(remaining == 0, "Frame not flushed!");
                compressedSize = outBuff.pos;
            }
    
            ZSTD_DCtx* const dctx = ZSTD_createDCtx();
            CHECK(dctx != NULL, "ZSTD_createDCtx() failed!");
           /* Set the maximum allowed window log.
            * The value 0 means use the default window log, which is equivalent to
            * not setting it.
            */
           CHECK_ZSTD( ZSTD_DCtx_setParameter(dctx, ZSTD_d_windowLogMax, wLog) );
           /* forces decompressor to use maximum memory size, since the
            * decompressed size is not stored in the frame header.
            */
           {   ZSTD_inBuffer inBuff = { compressedData, compressedSize, 0 };
               ZSTD_outBuffer outBuff = { decompressedData, sizeof(decompressedData), 0 };
               size_t const remaining = ZSTD_decompressStream(dctx, &outBuff, &inBuff);
               CHECK_ZSTD(remaining);
               CHECK(remaining == 0, "Frame not complete!");
               CHECK(outBuff.pos == sizeof(dataToCompress), "Bad decompression!");
           }
   
           size_t const cstreamSize = ZSTD_sizeof_CStream(cctx);
           size_t const cstreamEstimatedSize = ZSTD_estimateCStreamSize_usingCCtxParams(cctxParams);
           size_t const dstreamSize = ZSTD_sizeof_DStream(dctx);
           size_t const dstreamEstimatedSize = ZSTD_estimateDStreamSize_fromFrame(compressedData, compressedSize);
   
           CHECK(cstreamSize <= cstreamEstimatedSize, "Compression mem (%u) > estimated (%u)",
                   (unsigned)cstreamSize, (unsigned)cstreamEstimatedSize);
           CHECK(dstreamSize <= dstreamEstimatedSize, "Decompression mem (%u) > estimated (%u)",
                   (unsigned)dstreamSize, (unsigned)dstreamEstimatedSize);
   
           printf("Level %2i : Compression Mem = %5u KB (estimated : %5u KB) ; Decompression Mem = %4u KB (estimated : %5u KB)\n",
                   compressionLevel,
                   (unsigned)(cstreamSize>>10), (unsigned)(cstreamEstimatedSize>>10),
                   (unsigned)(dstreamSize>>10), (unsigned)(dstreamEstimatedSize>>10));
   
           ZSTD_freeDCtx(dctx);
           ZSTD_freeCCtx(cctx);
           ZSTD_freeCCtxParams(cctxParams);
           if (wLog) break;  /* single test */
       }
       return 0;
   }

Cache object: d3c1f8f5ab229b03c3446fa352e60631