ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge changes I5032300e,Idec3e051,I09be447b into main am: 4215f1a9fc am: 22e446746e

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

Change-Id: I87e8af53582bdac271ef4526f75cfb10900ca824
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Daniel Zheng 2023-08-17 23:17:37 +00:00 • committed by Automerger Merge Worker
commit 0ce656e198
6 changed files with 16 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
fs_mgr/libsnapshot/include/libsnapshot/cow_compress.h
View file

@ -32,9 +32,9 @@ class ICompressor {
static std::unique_ptr<ICompressor> Gz(uint32_t compression_level); 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> Brotli(uint32_t compression_level);
static std::unique_ptr<ICompressor> Lz4(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_; } uint32_t GetCompressionLevel() const { return compression_level_; }

15
fs_mgr/libsnapshot/libsnapshot_cow/cow_compress.cpp
View file

@ -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) { switch (compression.algorithm) {
case kCowCompressLz4: case kCowCompressLz4:
return ICompressor::Lz4(compression.compression_level); return ICompressor::Lz4(compression.compression_level);
@ -64,7 +65,7 @@ std::unique_ptr<ICompressor> ICompressor::Create(CowCompression compression) {
case kCowCompressGz: case kCowCompressGz:
return ICompressor::Gz(compression.compression_level); return ICompressor::Gz(compression.compression_level);
case kCowCompressZstd: case kCowCompressZstd:
return ICompressor::Zstd(compression.compression_level); return ICompressor::Zstd(compression.compression_level, BLOCK_SZ);
case kCowCompressNone: case kCowCompressNone:
return nullptr; return nullptr;
} }
@ -175,12 +176,10 @@ class BrotliCompressor final : public ICompressor {
class ZstdCompressor final : public ICompressor { class ZstdCompressor final : public ICompressor {
public: 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) { : ICompressor(compression_level), 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);
// FIXME: hardcoding a value of 12 here for 4k blocks, should change to be either set by ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, log2(MAX_BLOCK_SIZE));
// user, or optimized depending on block size
ZSTD_CCtx_setParameter(zstd_context_.get(), ZSTD_c_windowLog, 12);
}; };
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 {
@ -326,8 +325,8 @@ std::unique_ptr<ICompressor> ICompressor::Lz4(uint32_t compression_level) {
return std::make_unique<Lz4Compressor>(compression_level); return std::make_unique<Lz4Compressor>(compression_level);
} }
std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level) { std::unique_ptr<ICompressor> ICompressor::Zstd(uint32_t compression_level, const int32_t BLOCK_SZ) {
return std::make_unique<ZstdCompressor>(compression_level); return std::make_unique<ZstdCompressor>(compression_level, BLOCK_SZ);
} }
void CompressWorker::Finalize() { void CompressWorker::Finalize() {

2
fs_mgr/libsnapshot/libsnapshot_cow/cow_decompress.cpp
View file

@ -351,7 +351,7 @@ class ZstdDecompressor final : public IDecompressor {
return decompressed_size; return decompressed_size;
} }
std::vector<unsigned char> ignore_buf(decompressed_size); std::vector<unsigned char> ignore_buf(decompressed_size);
if (!Decompress(buffer, decompressed_size)) { if (!Decompress(ignore_buf.data(), decompressed_size)) {
return -1; return -1;
} }
memcpy(buffer, ignore_buf.data() + ignore_bytes, buffer_size); memcpy(buffer, ignore_buf.data() + ignore_bytes, buffer_size);

4
fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp
View file

@ -17,9 +17,7 @@
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <limits>
#include <optional> #include <optional>
#include <set>
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
#include <vector> #include <vector>
@ -103,7 +101,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab
footer_ = parser.footer(); footer_ = parser.footer();
fd_size_ = parser.fd_size(); fd_size_ = parser.fd_size();
last_label_ = parser.last_label(); last_label_ = parser.last_label();
ops_ = std::move(parser.ops()); ops_ = parser.ops();
data_loc_ = parser.data_loc(); data_loc_ = parser.data_loc();
// If we're resuming a write, we're not ready to merge // If we're resuming a write, we're not ready to merge

2
fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp
View file

@ -480,7 +480,7 @@ TEST_P(CompressionTest, HorribleStream) {
std::string expected = "The quick brown fox jumps over the lazy dog."; std::string expected = "The quick brown fox jumps over the lazy dog.";
expected.resize(4096, '\0'); 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()); auto result = compressor->Compress(expected.data(), expected.size());
ASSERT_FALSE(result.empty()); ASSERT_FALSE(result.empty());

7
fs_mgr/libsnapshot/libsnapshot_cow/writer_v2.cpp
View file

@ -183,7 +183,8 @@ void CowWriterV2::InitWorkers() {
return; return;
} }
for (int i = 0; i < num_compress_threads_; i++) { 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); auto wt = std::make_unique<CompressWorker>(std::move(compressor), header_.block_size);
threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get())); threads_.emplace_back(std::async(std::launch::async, &CompressWorker::RunThread, wt.get()));
compress_threads_.push_back(std::move(wt)); compress_threads_.push_back(std::move(wt));
@ -340,7 +341,7 @@ bool CowWriterV2::CompressBlocks(size_t num_blocks, const void* data) {
compressed_buf_.clear(); compressed_buf_.clear();
if (num_threads <= 1) { if (num_threads <= 1) {
if (!compressor_) { if (!compressor_) {
compressor_ = ICompressor::Create(compression_); compressor_ = ICompressor::Create(compression_, header_.block_size);
} }
return CompressWorker::CompressBlocks(compressor_.get(), options_.block_size, data, return CompressWorker::CompressBlocks(compressor_.get(), options_.block_size, data,
num_blocks, &compressed_buf_); num_blocks, &compressed_buf_);
@ -415,7 +416,7 @@ bool CowWriterV2::EmitBlocks(uint64_t new_block_start, const void* data, size_t
return data; return data;
} else { } else {
if (!compressor_) { if (!compressor_) {
compressor_ = ICompressor::Create(compression_); compressor_ = ICompressor::Create(compression_, header_.block_size);
} }
auto data = compressor_->Compress(iter, header_.block_size); auto data = compressor_->Compress(iter, header_.block_size);