Skip to content

Commit c611239

Browse files
authored
[opt](exec) Avoid copies when publishing projection results (apache#66085)
### What problem does this PR solve? Projection results were converted to mutable columns before being published. Shared results such as SlotRef columns therefore triggered COW clones and full-column copies. This change keeps scoped output-block reuse while moving exclusive results directly and publishing shared immutable columns after restore. It also makes `ColumnConst` and `ColumnVariant` ownership checks include their nested columns, and uses actual peak memory tracking instead of charging shared input buffers as projection allocations. ### Release note None ### Check List (For Author) - Test <!-- At least one of them must be included. --> - [ ] Regression test - [ ] Unit Test - [ ] Manual test (add detailed scripts or steps below) - [ ] No need to test or manual test. Explain why: - [ ] This is a refactor/code format and no logic has been changed. - [ ] Previous test can cover this change. - [ ] No code files have been changed. - [ ] Other reason <!-- Add your reason? --> - Behavior changed: - [ ] No. - [ ] Yes. <!-- Explain the behavior change --> - Does this need documentation? - [ ] No. - [ ] Yes. <!-- Add document PR link here. eg: apache/doris-website#1214 --> ### Check List (For Reviewer who merge this PR) - [ ] Confirm the release note - [ ] Confirm test cases - [ ] Confirm document - [ ] Add branch pick label <!-- Add branch pick label that this PR should merge into -->
1 parent 8429776 commit c611239

11 files changed

Lines changed: 279 additions & 97 deletions

File tree

‎be/src/core/column/column_const.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -119,6 +119,8 @@ class ColumnConst final : public COWHelper<IColumn, ColumnConst> {
119119

120120
bool is_variable_length() const override { return data->is_variable_length(); }
121121

122+
bool is_exclusive() const override { return IColumn::is_exclusive() && data->is_exclusive(); }
123+
122124
std::string get_name() const override { return "Const(" + data->get_name() + ")"; }
123125

124126
void resize(size_t new_size) override { s = new_size; }

‎be/src/core/column/column_variant.cpp‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -829,6 +829,20 @@ size_t ColumnVariant::allocated_bytes() const {
829829
return res;
830830
}
831831

832+
bool ColumnVariant::is_exclusive() const {
833+
if (!IColumn::is_exclusive()) {
834+
return false;
835+
}
836+
for (const auto& entry : subcolumns) {
837+
for (const auto& part : entry->data.data) {
838+
if (!part->is_exclusive()) {
839+
return false;
840+
}
841+
}
842+
}
843+
return serialized_sparse_column->is_exclusive() && serialized_doc_value_column->is_exclusive();
844+
}
845+
832846
void ColumnVariant::mutate_subcolumns() {
833847
for (auto& entry : subcolumns) {
834848
for (auto& part : entry->data.data) {

‎be/src/core/column/column_variant.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -469,6 +469,8 @@ class ColumnVariant final : public COWHelper<IColumn, ColumnVariant> {
469469

470470
bool has_enough_capacity(const IColumn& src) const override { return false; }
471471

472+
bool is_exclusive() const override;
473+
472474
void mutate_subcolumns() override;
473475
void for_each_subcolumn(ColumnCallback callback) const override;
474476

‎be/src/exec/operator/operator.cpp‎

Lines changed: 53 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -323,63 +323,45 @@ Status OperatorXBase::do_projections(RuntimeState* state, Block* origin_block,
323323
if (rows == 0) {
324324
return Status::OK();
325325
}
326-
Block input_block = *origin_block;
327-
328-
size_t bytes_usage = 0;
329-
ColumnsWithTypeAndName new_columns;
330-
for (const auto& projections : local_state->_intermediate_projections) {
331-
if (projections.empty()) {
332-
return Status::InternalError("meet empty intermediate projection, node id: {}",
333-
node_id());
334-
}
335-
new_columns.resize(projections.size());
336-
for (int i = 0; i < projections.size(); i++) {
337-
RETURN_IF_ERROR(projections[i]->execute(&input_block, new_columns[i]));
338-
if (new_columns[i].column->size() != rows) {
339-
return Status::InternalError(
340-
"intermediate projection result column size {} not equal input rows {}, "
341-
"expr: {}",
342-
new_columns[i].column->size(), rows,
343-
projections[i]->root()->debug_string());
344-
}
345-
}
346-
Block tmp_block {new_columns};
347-
bytes_usage += tmp_block.allocated_bytes();
348-
input_block.swap(tmp_block);
349-
}
350-
351-
if (input_block.rows() != rows) {
352-
return Status::InternalError(
353-
"after intermediate projections input block rows {} not equal origin rows {}, "
354-
"input_block: {}",
355-
input_block.rows(), rows, input_block.dump_structure());
356-
}
357-
auto insert_column_datas = [&](auto& to, ColumnPtr& from, size_t rows) {
358-
if (is_column_nullable(*to) && !is_column_nullable(*from)) {
359-
if (_keep_origin || !from->is_exclusive()) {
360-
auto& null_column = reinterpret_cast<ColumnNullable&>(*to);
361-
null_column.get_nested_column().insert_range_from(*from, 0, rows);
362-
null_column.get_null_map_column().get_data().resize_fill(rows, 0);
363-
bytes_usage += null_column.allocated_bytes();
364-
} else {
365-
to = make_nullable(from, false)->assert_mutable();
326+
SCOPED_PEAK_MEM(&local_state->_estimate_memory_usage);
327+
328+
{
329+
Block input_block = *origin_block;
330+
331+
ColumnsWithTypeAndName new_columns;
332+
for (const auto& projections : local_state->_intermediate_projections) {
333+
if (projections.empty()) {
334+
return Status::InternalError("meet empty intermediate projection, node id: {}",
335+
node_id());
366336
}
367-
} else {
368-
if (_keep_origin || !from->is_exclusive()) {
369-
to->insert_range_from(*from, 0, rows);
370-
bytes_usage += from->allocated_bytes();
371-
} else {
372-
to = from->assert_mutable();
337+
new_columns.resize(projections.size());
338+
for (int i = 0; i < projections.size(); i++) {
339+
RETURN_IF_ERROR(projections[i]->execute(&input_block, new_columns[i]));
340+
if (new_columns[i].column->size() != rows) {
341+
return Status::InternalError(
342+
"intermediate projection result column size {} not equal input rows "
343+
"{}, expr: {}",
344+
new_columns[i].column->size(), rows,
345+
projections[i]->root()->debug_string());
346+
}
373347
}
348+
Block tmp_block {new_columns};
349+
input_block.swap(tmp_block);
374350
}
375-
};
376351

377-
auto scoped_mutable_block = VectorizedUtils::build_scoped_mutable_mem_reuse_block(
378-
output_block, *_output_row_descriptor);
379-
auto& mutable_block = scoped_mutable_block.mutable_block();
380-
auto& mutable_columns = mutable_block.mutable_columns();
381-
if (rows != 0) {
352+
if (input_block.rows() != rows) {
353+
return Status::InternalError(
354+
"after intermediate projections input block rows {} not equal origin rows {}, "
355+
"input_block: {}",
356+
input_block.rows(), rows, input_block.dump_structure());
357+
}
358+
359+
auto scoped_mutable_block = VectorizedUtils::build_scoped_mutable_mem_reuse_block(
360+
output_block, *_output_row_descriptor);
361+
auto& mutable_columns = scoped_mutable_block.mutable_columns();
382362
DCHECK_EQ(mutable_columns.size(), local_state->_projections.size()) << debug_string();
363+
Columns shared_columns(mutable_columns.size());
364+
383365
for (int i = 0; i < mutable_columns.size(); ++i) {
384366
ColumnPtr column_ptr;
385367
RETURN_IF_ERROR(local_state->_projections[i]->execute(&input_block, column_ptr));
@@ -390,12 +372,27 @@ Status OperatorXBase::do_projections(RuntimeState* state, Block* origin_block,
390372
local_state->_projections[i]->root()->debug_string());
391373
}
392374
column_ptr = column_ptr->convert_to_full_column_if_const();
393-
bytes_usage += column_ptr->allocated_bytes();
394-
insert_column_datas(mutable_columns[i], column_ptr, rows);
375+
if (is_column_nullable(*mutable_columns[i]) && !is_column_nullable(*column_ptr)) {
376+
column_ptr = make_nullable(column_ptr, false);
377+
}
378+
if (column_ptr->is_exclusive()) {
379+
mutable_columns[i] = IColumn::mutate(std::move(column_ptr));
380+
} else {
381+
shared_columns[i] = std::move(column_ptr);
382+
}
383+
}
384+
385+
scoped_mutable_block.restore();
386+
for (int i = 0; i < shared_columns.size(); ++i) {
387+
if (shared_columns[i]) {
388+
output_block->replace_by_position(i, std::move(shared_columns[i]));
389+
}
395390
}
396-
DCHECK(mutable_block.rows() == rows);
397391
}
398-
local_state->_estimate_memory_usage += bytes_usage;
392+
393+
origin_block->clear_column_data(
394+
local_state->_parent->intermediate_row_desc().num_materialized_slots());
395+
DCHECK_EQ(output_block->rows(), rows);
399396

400397
return Status::OK();
401398
}

‎be/src/exec/operator/operator.h‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1014,10 +1014,6 @@ class OperatorXBase : public OperatorBase {
10141014
std::string _op_name;
10151015
int _parallel_tasks = 0;
10161016

1017-
//_keep_origin is used to avoid copying during projection,
1018-
// currently set to false only in the nestloop join.
1019-
bool _keep_origin = true;
1020-
10211017
// _blockable is true if the operator contains expressions that may block execution
10221018
bool _blockable = false;
10231019
};

‎be/src/exec/scan/scanner.cpp‎

Lines changed: 37 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -210,41 +210,50 @@ Status Scanner::_do_projections(Block* origin_block, Block* output_block) {
210210
if (rows == 0) {
211211
return Status::OK();
212212
}
213-
Block input_block = *origin_block;
214213

215-
std::vector<int> result_column_ids;
216-
for (auto& projections : _intermediate_projections) {
217-
result_column_ids.resize(projections.size());
218-
for (int i = 0; i < projections.size(); i++) {
219-
RETURN_IF_ERROR(projections[i]->execute(&input_block, &result_column_ids[i]));
220-
}
221-
input_block.shuffle_columns(result_column_ids);
222-
}
223-
224-
DCHECK_EQ(rows, input_block.rows());
225-
auto scoped_mutable_block = VectorizedUtils::build_scoped_mutable_mem_reuse_block(
226-
output_block, *_output_row_descriptor);
227-
auto& mutable_block = scoped_mutable_block.mutable_block();
214+
{
215+
Block input_block = *origin_block;
228216

229-
auto& mutable_columns = mutable_block.mutable_columns();
217+
std::vector<int> result_column_ids;
218+
for (auto& projections : _intermediate_projections) {
219+
result_column_ids.resize(projections.size());
220+
for (int i = 0; i < projections.size(); i++) {
221+
RETURN_IF_ERROR(projections[i]->execute(&input_block, &result_column_ids[i]));
222+
}
223+
input_block.shuffle_columns(result_column_ids);
224+
}
230225

231-
DCHECK_EQ(mutable_columns.size(), _projections.size());
226+
DCHECK_EQ(rows, input_block.rows());
227+
auto scoped_mutable_block = VectorizedUtils::build_scoped_mutable_mem_reuse_block(
228+
output_block, *_output_row_descriptor);
229+
auto& mutable_columns = scoped_mutable_block.mutable_columns();
230+
DCHECK_EQ(mutable_columns.size(), _projections.size());
231+
Columns shared_columns(mutable_columns.size());
232+
233+
for (int i = 0; i < mutable_columns.size(); ++i) {
234+
ColumnPtr column_ptr;
235+
RETURN_IF_ERROR(_projections[i]->execute(&input_block, column_ptr));
236+
column_ptr = column_ptr->convert_to_full_column_if_const();
237+
if (mutable_columns[i]->is_nullable() != column_ptr->is_nullable()) {
238+
throw Exception(ErrorCode::INTERNAL_ERROR, "Nullable mismatch");
239+
}
240+
if (column_ptr->is_exclusive()) {
241+
mutable_columns[i] = IColumn::mutate(std::move(column_ptr));
242+
} else {
243+
shared_columns[i] = std::move(column_ptr);
244+
}
245+
}
232246

233-
for (int i = 0; i < mutable_columns.size(); ++i) {
234-
ColumnPtr column_ptr;
235-
RETURN_IF_ERROR(_projections[i]->execute(&input_block, column_ptr));
236-
column_ptr = column_ptr->convert_to_full_column_if_const();
237-
if (mutable_columns[i]->is_nullable() != column_ptr->is_nullable()) {
238-
throw Exception(ErrorCode::INTERNAL_ERROR, "Nullable mismatch");
247+
scoped_mutable_block.restore();
248+
for (int i = 0; i < shared_columns.size(); ++i) {
249+
if (shared_columns[i]) {
250+
output_block->replace_by_position(i, std::move(shared_columns[i]));
251+
}
239252
}
240-
mutable_columns[i] = IColumn::mutate(std::move(column_ptr));
241253
}
242254

243-
scoped_mutable_block.restore();
244-
245-
// origin columns was moved into output_block, so we need to set origin_block to empty columns
246-
auto empty_columns = origin_block->clone_empty_columns();
247-
origin_block->set_columns(std::move(empty_columns));
255+
origin_block->clear_column_data(
256+
_local_state->_parent->row_descriptor().num_materialized_slots());
248257
DCHECK_EQ(output_block->rows(), rows);
249258

250259
return Status::OK();

‎be/test/core/column/column_const_test.cpp‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ TEST(ColumnConstTest, TestCreate) {
4242
EXPECT_TRUE(!is_column_const(column_const2->get_data_column()));
4343
}
4444

45+
TEST(ColumnConstTest, IsExclusiveChecksNestedColumn) {
46+
auto column_data = ColumnHelper::create_column<DataTypeInt64>({7});
47+
auto column_const = ColumnConst::create(column_data, 3);
48+
49+
EXPECT_FALSE(column_const->is_exclusive());
50+
column_data.reset();
51+
EXPECT_TRUE(column_const->is_exclusive());
52+
}
53+
4554
TEST(ColumnConstTest, ConstNullableIsSemanticallyNullable) {
4655
auto nullable_data = ColumnHelper::create_nullable_column<DataTypeInt64>({7}, {0});
4756
auto const_nullable = ColumnConst::create(nullable_data, 3);

‎be/test/core/column/column_nullable_test.cpp‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -136,6 +136,13 @@ TEST(ColumnNullableTest, SharedCreatePreservesImmutableSubcolumns) {
136136
EXPECT_EQ(nullable_ref.get_null_map_column_ptr().get(), null_map_alias.get());
137137
EXPECT_EQ(nested_alias->size(), 1);
138138
EXPECT_EQ(null_map_alias->size(), 1);
139+
EXPECT_FALSE(nullable->is_exclusive());
140+
141+
nested.reset();
142+
nested_alias.reset();
143+
null_map.reset();
144+
null_map_alias.reset();
145+
EXPECT_TRUE(nullable->is_exclusive());
139146
}
140147

141148
TEST(ColumnNullableTest, UpdateCrc32cBatchKeepsBlockInsertable) {

‎be/test/core/column/column_variant_test.cpp‎

Lines changed: 29 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1817,16 +1817,36 @@ TEST_F(ColumnVariantTest, is_scalar_variant) {
18171817
}
18181818

18191819
TEST_F(ColumnVariantTest, is_exclusive) {
1820-
auto test_func = [](const auto& source_column) {
1821-
auto src_size = source_column->size();
1822-
EXPECT_TRUE(src_size > 0);
1820+
auto variant = VariantUtil::construct_basic_varint_column();
1821+
EXPECT_GT(variant->size(), 0);
1822+
EXPECT_TRUE(variant->is_exclusive());
18231823

1824-
// Test is_exclusive
1825-
bool is_exclusive = source_column->is_exclusive();
1826-
// The result depends on the actual data structure
1827-
EXPECT_TRUE(is_exclusive);
1828-
};
1829-
test_func(column_variant);
1824+
const auto& subcolumns = variant->get_subcolumns();
1825+
const auto* root = subcolumns.get_root();
1826+
ColumnPtr shared_subcolumn;
1827+
for (const auto& entry : subcolumns) {
1828+
if (entry.get() != root && !entry->data.data.empty()) {
1829+
shared_subcolumn = static_cast<const IColumn::Ptr&>(entry->data.data[0]);
1830+
break;
1831+
}
1832+
}
1833+
ASSERT_TRUE(shared_subcolumn);
1834+
EXPECT_FALSE(variant->is_exclusive());
1835+
1836+
shared_subcolumn.reset();
1837+
EXPECT_TRUE(variant->is_exclusive());
1838+
1839+
auto shared_sparse_column = variant->get_sparse_column();
1840+
EXPECT_FALSE(variant->is_exclusive());
1841+
1842+
shared_sparse_column.reset();
1843+
EXPECT_TRUE(variant->is_exclusive());
1844+
1845+
auto shared_doc_value_column = variant->get_doc_value_column();
1846+
EXPECT_FALSE(variant->is_exclusive());
1847+
1848+
shared_doc_value_column.reset();
1849+
EXPECT_TRUE(variant->is_exclusive());
18301850
}
18311851

18321852
TEST_F(ColumnVariantTest, get_root_type) {

0 commit comments

Comments
 (0)