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

Commit f5a280a0 authored by Daniel Zheng's avatar Daniel Zheng Committed by Automerger Merge Worker
Browse files

Merge "Adding block sz to compressors" into main am: 7f13bc4f 

Original change: https://android-review.googlesource.com/c/platform/system/core/+/2748856



Change-Id: I4ca4ee725b58a77aeb59144196ad98d0ac6ed0c5
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fd742433 7f13bc4f

fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h

+7 −5
Original line number Diff line number Diff line
@@ -24,24 +24,26 @@ namespace snapshot { 


class ICompressor {

  public:

    explicit ICompressor(uint32_t compression_level) : compression_level_(compression_level) {}

    explicit ICompressor(uint32_t compression_level, uint32_t block_size)

        : compression_level_(compression_level), block_size_(block_size) {}



    virtual ~ICompressor() {}

    // Factory methods for compression methods.

    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> Gz(uint32_t compression_level, const int32_t BLOCK_SZ);

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

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

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



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



    uint32_t GetCompressionLevel() const { return compression_level_; }



    uint32_t GetBlockSize() const { return block_size_; }

    [[nodiscard]] virtual std::basic_string<uint8_t> Compress(const void* data,

                                                              size_t length) const = 0;



  private:

    uint32_t compression_level_;

    uint32_t block_size_;

};

}  // namespace snapshot

}  // namespace android
 
 No newline at end of file

fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp

+26 −19
Original line number Diff line number Diff line
@@ -56,16 +56,16 @@ std::optional<CowCompressionAlgorithm> CompressionAlgorithmFromString(std::strin 
}



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

                                                 const int32_t BLOCK_SZ) {

                                                 const int32_t block_size) {

    switch (compression.algorithm) {

        case kCowCompressLz4:

            return ICompressor::Lz4(compression.compression_level);

            return ICompressor::Lz4(compression.compression_level, block_size);

        case kCowCompressBrotli:

            return ICompressor::Brotli(compression.compression_level);

            return ICompressor::Brotli(compression.compression_level, block_size);

        case kCowCompressGz:

            return ICompressor::Gz(compression.compression_level);

            return ICompressor::Gz(compression.compression_level, block_size);

        case kCowCompressZstd:

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

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

        case kCowCompressNone:

            return nullptr;

    }
@@ -100,7 +100,8 @@ uint32_t CompressWorker::GetDefaultCompressionLevel(CowCompressionAlgorithm comp 


class GzCompressor final : public ICompressor {

  public:

    GzCompressor(uint32_t compression_level) : ICompressor(compression_level){};

    GzCompressor(uint32_t compression_level, const uint32_t block_size)

        : ICompressor(compression_level, block_size){};



    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {

        const auto bound = compressBound(length);
@@ -120,7 +121,8 @@ class GzCompressor final : public ICompressor { 


class Lz4Compressor final : public ICompressor {

  public:

    Lz4Compressor(uint32_t compression_level) : ICompressor(compression_level){};

    Lz4Compressor(uint32_t compression_level, const uint32_t block_size)

        : ICompressor(compression_level, block_size){};



    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {

        const auto bound = LZ4_compressBound(length);
@@ -151,7 +153,8 @@ class Lz4Compressor final : public ICompressor { 


class BrotliCompressor final : public ICompressor {

  public:

    BrotliCompressor(uint32_t compression_level) : ICompressor(compression_level){};

    BrotliCompressor(uint32_t compression_level, const uint32_t block_size)

        : ICompressor(compression_level, block_size){};



    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {

        const auto bound = BrotliEncoderMaxCompressedSize(length);
@@ -176,10 +179,11 @@ class BrotliCompressor final : public ICompressor { 


class ZstdCompressor final : public ICompressor {

  public:

    ZstdCompressor(uint32_t compression_level, const uint32_t MAX_BLOCK_SIZE)

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

    ZstdCompressor(uint32_t compression_level, const uint32_t block_size)

        : ICompressor(compression_level, block_size),

          zstd_context_(ZSTD_createCCtx(), ZSTD_freeCCtx) {

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

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

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

    };



    std::basic_string<uint8_t> Compress(const void* data, size_t length) const override {
@@ -313,20 +317,23 @@ bool CompressWorker::GetCompressedBuffers(std::vector<std::basic_string<uint8_t> 
    return true;

}



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

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

std::unique_ptr<ICompressor> ICompressor::Brotli(uint32_t compression_level,

                                                 const int32_t block_size) {

    return std::make_unique<BrotliCompressor>(compression_level, block_size);

}



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

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

std::unique_ptr<ICompressor> ICompressor::Gz(uint32_t compression_level, const int32_t block_size) {

    return std::make_unique<GzCompressor>(compression_level, block_size);

}



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

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

std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level,

                                              const int32_t block_size) {

    return std::make_unique<Lz4Compressor>(compression_level, block_size);

}



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

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

std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level,

                                               const int32_t block_size) {

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

}



void CompressWorker::Finalize() {