Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 96b78fee authored by Daniel Zheng's avatar Daniel Zheng
Browse files

Fix zstd optimization api usage 

ZSTD_c_windowLog should be set as log base 2 of max block size. Changing
hardcoded value to be determined by this variable.

Test: m libsnapshot
Change-Id: I09be447b7f1e95cb72a6a42eddb4035f61a43aad
parent 74295d4f

fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h

+2 −2
Original line number Diff line number Diff line
@@ -32,9 +32,9 @@ class ICompressor { 
    static std::unique_ptr<ICompressor> Gz(uint32_t compression_level);

    static std::unique_ptr<ICompressor> Brotli(uint32_t compression_level);

    static std::unique_ptr<ICompressor> Lz4(uint32_t compression_level);

    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level);

    static std::unique_ptr<ICompressor> Zstd(uint32_t compression_level, const int32_t BLOCK_SZ);



    static std::unique_ptr<ICompressor> Create(CowCompression compression);

    static std::unique_ptr<ICompressor> Create(CowCompression compression, const int32_t BLOCK_SZ);



    uint32_t GetCompressionLevel() const { return compression_level_; }

fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp

+7 −8
Original line number Diff line number Diff line
@@ -55,7 +55,8 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin 
    }

}



std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression) {

std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression,

                                                 const int32_t BLOCK_SZ) {

    switch (compression.algorithm) {

        case kCowCompressLz4:

            return ICompressor::Lz4(compression.compression_level);
@@ -64,7 +65,7 @@ std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression) { 
        case kCowCompressGz:

            return ICompressor::Gz(compression.compression_level);

        case kCowCompressZstd:

            return ICompressor::Zstd(compression.compression_level);

            return ICompressor::Zstd(compression.compression_level, BLOCK_SZ);

        case kCowCompressNone:

            return nullptr;

    }
@@ -175,12 +176,10 @@ class BrotliCompressor final : public ICompressor { 


class ZstdCompressor final : public ICompressor {

  public:

    ZstdCompressor(uint32_t compression_level)

    ZstdCompressor(uint32_t compression_level, const uint32_t MAX_BLOCK_SIZE)

        : ICompressor(compression_level), zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {

        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_compressionLevel, compression_level);

        // FIXME: hardcoding a value of 12 here for 4k blocks, should change to be either set by

        // user, or optimized depending on block size

        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, 12);

        ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(MAX_BLOCK_SIZE));

    };



    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
@@ -326,8 +325,8 @@ std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level) { 
    return std::make_unique<Lz4Compressor>(compression_level);

}



std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level) {

    return std::make_unique<ZstdCompressor>(compression_level);

std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level, const int32_t BLOCK_SZ) {

    return std::make_unique<ZstdCompressor>(compression_level, BLOCK_SZ);

}



void CompressWorker::Finalize() {

fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp

+1 −1
Original line number Diff line number Diff line
@@ -480,7 +480,7 @@ TEST_P(CompressionTest, HorribleStream) { 
    std::string expected = "The quick brown fox jumps over the lazy dog.";

    expected.resize(4096, '\0');



    std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression);

    std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression, 4096);

    auto result = compressor->Compress(expected.data(), expected.size());

    ASSERT_FALSE(result.empty());

fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp

+4 −3
Original line number Diff line number Diff line
@@ -184,7 +184,8 @@ void CowWriterV2::InitWorkers() { 
        return;

    }

    for (int i = 0; i < num_compress_threads_; i++) {

        std::unique_ptr<ICompressor> compressor = ICompressor::Create(compression_);

        std::unique_ptr<ICompressor> compressor =

                ICompressor::Create(compression_, header_.block_size);

        auto wt = std::make_unique<CompressWorker>(std::move(compressor), header_.block_size);

        threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));

        compress_threads_.push_back(std::move(wt));
@@ -341,7 +342,7 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) { 
    compressed_buf_.clear();

    if (num_threads <= 1) {

        if (!compressor_) {

            compressor_ = ICompressor::Create(compression_);

            compressor_ = ICompressor::Create(compression_, header_.block_size);

        }

        return CompressWorker::CompressBlocks(compressor_.get(), options_.block_size, data,

                                              num_blocks, &compressed_buf_);
@@ -416,7 +417,7 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t 
                        return data;

                    } else {

                        if (!compressor_) {

                            compressor_ = ICompressor::Create(compression_);

                            compressor_ = ICompressor::Create(compression_, header_.block_size);

                        }



                        auto data = compressor_->Compress(iter, header_.block_size);