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

Commit b3092928 authored by Daniel Zheng's avatar Daniel Zheng
Browse files

Adding block sz to compressors 

Adding block sz to compressor classes to prepare for variable block size
compression

Test: m libsnapshot
Change-Id: I84db20c80c0f95188f79ccc73b5c30678bd75e78
parent f0063939

fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h

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




class ICompressor {

class ICompressor {

  public:

  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() {}

    virtual ~ICompressor() {}

    // Factory methods for compression methods.

    // Factory methods for compression methods.

    static std::unique_ptr<ICompressor> Gz(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);

    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);

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





    static std::unique_ptr<ICompressor> Create(CowCompression compression, 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 GetCompressionLevel() const { return compression_level_; }



    uint32_t GetBlockSize() const { return block_size_; }

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

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

                                                              size_t length) const = 0;

                                                              size_t length) const = 0;





  private:

  private:

    uint32_t compression_level_;

    uint32_t compression_level_;

    uint32_t block_size_;

};

};

}  // namespace snapshot

}  // namespace snapshot

}  // namespace android
 
}  // namespace android
 
 No newline at end of file

fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp

+26 −19
Original line number Original line Diff line number Diff line
@@ -56,16 +56,16 @@ 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) {

                                                 const int32_t block_size) {

    switch (compression.algorithm) {

    switch (compression.algorithm) {

        case kCowCompressLz4:

        case kCowCompressLz4:

            return ICompressor::Lz4(compression.compression_level);

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

        case kCowCompressBrotli:

        case kCowCompressBrotli:

            return ICompressor::Brotli(compression.compression_level);

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

        case kCowCompressGz:

        case kCowCompressGz:

            return ICompressor::Gz(compression.compression_level);

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

        case kCowCompressZstd:

        case kCowCompressZstd:

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

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

        case kCowCompressNone:

        case kCowCompressNone:

            return nullptr;

            return nullptr;

    }

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




class GzCompressor final : public ICompressor {

class GzCompressor final : public ICompressor {

  public:

  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 {

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

        const auto bound = compressBound(length);

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




class Lz4Compressor final : public ICompressor {

class Lz4Compressor final : public ICompressor {

  public:

  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 {

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

        const auto bound = LZ4_compressBound(length);

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




class BrotliCompressor final : public ICompressor {

class BrotliCompressor final : public ICompressor {

  public:

  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 {

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

        const auto bound = BrotliEncoderMaxCompressedSize(length);

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




class ZstdCompressor final : public ICompressor {

class ZstdCompressor final : public ICompressor {

  public:

  public:

    ZstdCompressor(uint32_t compression_level, const uint32_t MAX_BLOCK_SIZE)

    ZstdCompressor(uint32_t compression_level, const uint32_t block_size)

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

        : 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_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 {

    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;

    return true;

}

}





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

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

    return std::make_unique<BrotliCompressor>(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) {

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

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

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

}

}





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

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

    return std::make_unique<Lz4Compressor>(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) {

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

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

                                               const int32_t block_size) {

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

}

}





void CompressWorker::Finalize() {

void CompressWorker::Finalize() {