Skip to content

Commit e0c7900

Browse files
authored
[enhancement][betarowset]optimize lz4 compress and decompress speed by reusing context (apache#9566)
1 parent cfe22f8 commit e0c7900

11 files changed

Lines changed: 77 additions & 58 deletions

‎be/src/olap/rowset/segment_v2/column_reader.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -104,7 +104,7 @@ Status ColumnReader::init() {
104104
strings::Substitute("unsupported typeinfo, type=$0", _meta.type()));
105105
}
106106
RETURN_IF_ERROR(EncodingInfo::get(_type_info.get(), _meta.encoding(), &_encoding_info));
107-
RETURN_IF_ERROR(get_block_compression_codec(_meta.compression(), &_compress_codec));
107+
RETURN_IF_ERROR(get_block_compression_codec(_meta.compression(), _compress_codec));
108108

109109
for (int i = 0; i < _meta.indexes_size(); i++) {
110110
auto& index_meta = _meta.indexes(i);
@@ -149,7 +149,7 @@ Status ColumnReader::read_page(const ColumnIteratorOptions& iter_opts, const Pag
149149
PageReadOptions opts;
150150
opts.rblock = iter_opts.rblock;
151151
opts.page_pointer = pp;
152-
opts.codec = _compress_codec;
152+
opts.codec = _compress_codec.get();
153153
opts.stats = iter_opts.stats;
154154
opts.verify_checksum = _opts.verify_checksum;
155155
opts.use_page_cache = iter_opts.use_page_cache;

‎be/src/olap/rowset/segment_v2/column_reader.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -175,7 +175,7 @@ class ColumnReader {
175175
TypeInfoPtr(nullptr, nullptr); // initialized in init(), may changed by subclasses.
176176
const EncodingInfo* _encoding_info =
177177
nullptr; // initialized in init(), used for create PageDecoder
178-
const BlockCompressionCodec* _compress_codec = nullptr; // initialized in init()
178+
std::unique_ptr<BlockCompressionCodec> _compress_codec; // initialized in init()
179179

180180
// meta for various column indexes (null if the index is absent)
181181
const ZoneMapIndexPB* _zone_map_index_meta = nullptr;

‎be/src/olap/rowset/segment_v2/column_writer.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,7 @@ ScalarColumnWriter::~ScalarColumnWriter() {
264264
}
265265

266266
Status ScalarColumnWriter::init() {
267-
RETURN_IF_ERROR(get_block_compression_codec(_opts.meta->compression(), &_compress_codec));
267+
RETURN_IF_ERROR(get_block_compression_codec(_opts.meta->compression(), _compress_codec));
268268

269269
PageBuilder* page_builder = nullptr;
270270

@@ -420,7 +420,7 @@ Status ScalarColumnWriter::write_data() {
420420
footer.mutable_dict_page_footer()->set_encoding(PLAIN_ENCODING);
421421

422422
PagePointer dict_pp;
423-
RETURN_IF_ERROR(PageIO::compress_and_write_page(_compress_codec,
423+
RETURN_IF_ERROR(PageIO::compress_and_write_page(_compress_codec.get(),
424424
_opts.compression_min_space_saving, _wblock,
425425
{dict_body.slice()}, footer, &dict_pp));
426426
dict_pp.to_proto(_opts.meta->mutable_dict_page());
@@ -508,8 +508,8 @@ Status ScalarColumnWriter::finish_current_page() {
508508
}
509509
// trying to compress page body
510510
OwnedSlice compressed_body;
511-
RETURN_IF_ERROR(PageIO::compress_page_body(_compress_codec, _opts.compression_min_space_saving,
512-
body, &compressed_body));
511+
RETURN_IF_ERROR(PageIO::compress_page_body(
512+
_compress_codec.get(), _opts.compression_min_space_saving, body, &compressed_body));
513513
if (compressed_body.slice().empty()) {
514514
// page body is uncompressed
515515
page->data.emplace_back(std::move(encoded_values));

‎be/src/olap/rowset/segment_v2/column_writer.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -249,7 +249,7 @@ class ScalarColumnWriter final : public ColumnWriter {
249249
PageHead _pages;
250250
ordinal_t _first_rowid = 0;
251251

252-
const BlockCompressionCodec* _compress_codec = nullptr;
252+
std::unique_ptr<BlockCompressionCodec> _compress_codec;
253253

254254
std::unique_ptr<OrdinalIndexWriter> _ordinal_index_builder;
255255
std::unique_ptr<ZoneMapIndexWriter> _zone_map_index_builder;

‎be/src/olap/rowset/segment_v2/indexed_column_reader.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ Status IndexedColumnReader::load(bool use_page_cache, bool kept_in_memory) {
3737
strings::Substitute("unsupported typeinfo, type=$0", _meta.data_type()));
3838
}
3939
RETURN_IF_ERROR(EncodingInfo::get(_type_info, _meta.encoding(), &_encoding_info));
40-
RETURN_IF_ERROR(get_block_compression_codec(_meta.compression(), &_compress_codec));
40+
RETURN_IF_ERROR(get_block_compression_codec(_meta.compression(), _compress_codec));
4141
_value_key_coder = get_key_coder(_type_info->type());
4242

4343
std::unique_ptr<fs::ReadableBlock> rblock;
@@ -83,7 +83,7 @@ Status IndexedColumnReader::read_page(fs::ReadableBlock* rblock, const PagePoint
8383
PageReadOptions opts;
8484
opts.rblock = rblock;
8585
opts.page_pointer = pp;
86-
opts.codec = _compress_codec;
86+
opts.codec = _compress_codec.get();
8787
OlapReaderStatistics tmp_stats;
8888
opts.stats = &tmp_stats;
8989
opts.use_page_cache = _use_page_cache;

‎be/src/olap/rowset/segment_v2/indexed_column_reader.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,7 @@ class IndexedColumnReader {
8484

8585
const TypeInfo* _type_info = nullptr;
8686
const EncodingInfo* _encoding_info = nullptr;
87-
const BlockCompressionCodec* _compress_codec = nullptr;
87+
std::unique_ptr<BlockCompressionCodec> _compress_codec;
8888
const KeyCoder* _value_key_coder = nullptr;
8989
};
9090

‎be/src/olap/rowset/segment_v2/indexed_column_writer.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ Status IndexedColumnWriter::init() {
7272
}
7373

7474
if (_options.compression != NO_COMPRESSION) {
75-
RETURN_IF_ERROR(get_block_compression_codec(_options.compression, &_compress_codec));
75+
RETURN_IF_ERROR(get_block_compression_codec(_options.compression, _compress_codec));
7676
}
7777
return Status::OK();
7878
}
@@ -110,7 +110,7 @@ Status IndexedColumnWriter::_finish_current_data_page() {
110110
footer.mutable_data_page_footer()->set_num_values(num_values_in_page);
111111
footer.mutable_data_page_footer()->set_nullmap_size(0);
112112

113-
RETURN_IF_ERROR(PageIO::compress_and_write_page(_compress_codec,
113+
RETURN_IF_ERROR(PageIO::compress_and_write_page(_compress_codec.get(),
114114
_options.compression_min_space_saving, _wblock,
115115
{page_body.slice()}, footer, &_last_data_page));
116116
_num_data_pages++;
@@ -159,7 +159,7 @@ Status IndexedColumnWriter::_flush_index(IndexPageBuilder* index_builder, BTreeM
159159

160160
PagePointer pp;
161161
RETURN_IF_ERROR(PageIO::compress_and_write_page(
162-
_compress_codec, _options.compression_min_space_saving, _wblock,
162+
_compress_codec.get(), _options.compression_min_space_saving, _wblock,
163163
{page_body.slice()}, page_footer, &pp));
164164

165165
meta->set_is_root_data_page(false);

‎be/src/olap/rowset/segment_v2/indexed_column_writer.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -108,7 +108,7 @@ class IndexedColumnWriter {
108108
std::unique_ptr<IndexPageBuilder> _value_index_builder;
109109
// encoder for value index's key
110110
const KeyCoder* _value_key_coder;
111-
const BlockCompressionCodec* _compress_codec;
111+
std::unique_ptr<BlockCompressionCodec> _compress_codec;
112112

113113
DISALLOW_COPY_AND_ASSIGN(IndexedColumnWriter);
114114
};

‎be/src/util/block_compression.cpp‎

Lines changed: 55 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -88,46 +88,46 @@ class Lz4BlockCompression : public BlockCompressionCodec {
8888
// Used for LZ4 frame format, decompress speed is two times faster than LZ4.
8989
class Lz4fBlockCompression : public BlockCompressionCodec {
9090
public:
91-
static const Lz4fBlockCompression* instance() {
92-
static Lz4fBlockCompression s_instance;
93-
return &s_instance;
94-
}
95-
96-
~Lz4fBlockCompression() override {}
91+
Status init() override {
92+
auto ret1 = LZ4F_createCompressionContext(&ctx_c, LZ4F_VERSION);
93+
if (LZ4F_isError(ret1)) {
94+
return Status::InvalidArgument(strings::Substitute(
95+
"Fail to LZ4F_createCompressionContext, msg=$0", LZ4F_getErrorName(ret1)));
96+
}
97+
ctx_c_inited = true;
9798

98-
Status compress(const Slice& input, Slice* output) const override {
99-
auto compressed_len = LZ4F_compressFrame(output->data, output->size, input.data, input.size,
100-
&_s_preferences);
101-
if (LZ4F_isError(compressed_len)) {
99+
auto ret2 = LZ4F_createDecompressionContext(&ctx_d, LZ4F_VERSION);
100+
if (LZ4F_isError(ret2)) {
102101
return Status::InvalidArgument(strings::Substitute(
103-
"Fail to do LZ4F compress frame, msg=$0", LZ4F_getErrorName(compressed_len)));
102+
"Fail to LZ4F_createDecompressionContext, msg=$0", LZ4F_getErrorName(ret2)));
104103
}
105-
output->size = compressed_len;
104+
ctx_d_inited = true;
105+
106106
return Status::OK();
107107
}
108108

109+
~Lz4fBlockCompression() override {
110+
if (ctx_c_inited) LZ4F_freeCompressionContext(ctx_c);
111+
if (ctx_d_inited) LZ4F_freeDecompressionContext(ctx_d);
112+
}
113+
114+
Status compress(const Slice& input, Slice* output) const override {
115+
std::vector<Slice> inputs {input};
116+
return compress(inputs, output);
117+
}
118+
109119
Status compress(const std::vector<Slice>& inputs, Slice* output) const override {
110-
LZ4F_compressionContext_t ctx = nullptr;
111-
auto lres = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
112-
if (lres != 0) {
113-
return Status::InvalidArgument(strings::Substitute("Fail to do LZ4F compress, res=$0",
114-
LZ4F_getErrorName(lres)));
115-
}
116-
auto st = _compress(ctx, inputs, output);
117-
LZ4F_freeCompressionContext(ctx);
118-
return st;
120+
if (!ctx_c_inited)
121+
return Status::InvalidArgument("LZ4F_createCompressionContext not sucess");
122+
123+
return _compress(ctx_c, inputs, output);
119124
}
120125

121126
Status decompress(const Slice& input, Slice* output) const override {
122-
LZ4F_decompressionContext_t ctx;
123-
auto lres = LZ4F_createDecompressionContext(&ctx, LZ4F_VERSION);
124-
if (LZ4F_isError(lres)) {
125-
return Status::InvalidArgument(strings::Substitute("Fail to do LZ4F decompress, res=$0",
126-
LZ4F_getErrorName(lres)));
127-
}
128-
auto st = _decompress(ctx, input, output);
129-
LZ4F_freeDecompressionContext(ctx);
130-
return st;
127+
if (!ctx_d_inited)
128+
return Status::InvalidArgument("LZ4F_createDecompressionContext not sucess");
129+
130+
return _decompress(ctx_d, input, output);
131131
}
132132

133133
size_t max_compressed_len(size_t len) const override {
@@ -167,6 +167,8 @@ class Lz4fBlockCompression : public BlockCompressionCodec {
167167
}
168168

169169
Status _decompress(LZ4F_decompressionContext_t ctx, const Slice& input, Slice* output) const {
170+
// reset decompression context to avoid ERROR_maxBlockSize_invalid
171+
LZ4F_resetDecompressionContext(ctx);
170172
size_t input_size = input.size;
171173
auto lres =
172174
LZ4F_decompress(ctx, output->data, &output->size, input.data, &input_size, nullptr);
@@ -187,6 +189,10 @@ class Lz4fBlockCompression : public BlockCompressionCodec {
187189

188190
private:
189191
static LZ4F_preferences_t _s_preferences;
192+
LZ4F_compressionContext_t ctx_c;
193+
bool ctx_c_inited = false;
194+
LZ4F_decompressionContext_t ctx_d;
195+
bool ctx_d_inited = false;
190196
};
191197

192198
LZ4F_preferences_t Lz4fBlockCompression::_s_preferences = {
@@ -370,27 +376,38 @@ class ZlibBlockCompression : public BlockCompressionCodec {
370376
};
371377

372378
Status get_block_compression_codec(segment_v2::CompressionTypePB type,
373-
const BlockCompressionCodec** codec) {
379+
std::unique_ptr<BlockCompressionCodec>& codec) {
380+
BlockCompressionCodec* ptr = nullptr;
374381
switch (type) {
375382
case segment_v2::CompressionTypePB::NO_COMPRESSION:
376-
*codec = nullptr;
377-
break;
383+
codec.reset(nullptr);
384+
return Status::OK();
378385
case segment_v2::CompressionTypePB::SNAPPY:
379-
*codec = SnappyBlockCompression::instance();
386+
ptr = new SnappyBlockCompression();
380387
break;
381388
case segment_v2::CompressionTypePB::LZ4:
382-
*codec = Lz4BlockCompression::instance();
389+
ptr = new Lz4BlockCompression();
383390
break;
384391
case segment_v2::CompressionTypePB::LZ4F:
385-
*codec = Lz4fBlockCompression::instance();
392+
ptr = new Lz4fBlockCompression();
386393
break;
387394
case segment_v2::CompressionTypePB::ZLIB:
388-
*codec = ZlibBlockCompression::instance();
395+
ptr = new ZlibBlockCompression();
389396
break;
390397
default:
391398
return Status::NotFound(strings::Substitute("unknown compression type($0)", type));
392399
}
393-
return Status::OK();
400+
401+
if (!ptr) return Status::NotFound("Failed to create compression codec");
402+
403+
Status st = ptr->init();
404+
if (st.ok()) {
405+
codec.reset(ptr);
406+
} else {
407+
delete ptr;
408+
}
409+
410+
return st;
394411
}
395412

396413
} // namespace doris

‎be/src/util/block_compression.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,8 @@ class BlockCompressionCodec {
3434
public:
3535
virtual ~BlockCompressionCodec() {}
3636

37+
virtual Status init() { return Status::OK(); }
38+
3739
// This function will compress input data into output.
3840
// output should be preallocated, and its capacity must be large enough
3941
// for compressed input, which can be get through max_compressed_len function.
@@ -61,6 +63,6 @@ class BlockCompressionCodec {
6163
//
6264
// Return not OK, if error happens.
6365
Status get_block_compression_codec(segment_v2::CompressionTypePB type,
64-
const BlockCompressionCodec** codec);
66+
std::unique_ptr<BlockCompressionCodec>& codec);
6567

6668
} // namespace doris

0 commit comments

Comments
 (0)