Skip to content

Commit 4d28bde

Browse files
committed
[fix](be) Reduce complex array_agg serialization memory
### What problem does this PR solve? Issue Number: close apache#65976 Related PR: apache#66601 Problem Summary: Complex array_agg states stored immutable type and execution-version metadata in every group and foreach position, adding per-state overhead. Serialization also allocated an untracked upper-bound string and copied it into the tracked destination, doubling peak payload memory. Keep serializer metadata on the aggregate function, serialize once into tracked padded destination storage with rollback on failure, and retain exact logical framing for zero-copy reads. ### Release note Reduce memory usage for complex array_agg and array_agg_foreach state serialization. ### Check List (For Author) - Test: Unit Test - Unit Test: GLIBC_COMPATIBILITY=OFF ./run-be-ut.sh -j 48 --run --filter=AggregateFunctionArrayAggTest.*:AggregateFunctionExceptionTest.* - Behavior changed: Yes. Complex array_agg state serialization removes redundant per-state metadata and tracked scratch duplication without changing query results. - Does this need documentation: No
1 parent 6d36bea commit 4d28bde

2 files changed

Lines changed: 102 additions & 28 deletions

File tree

‎be/src/exprs/aggregate/aggregate_function_array_agg.h‎

Lines changed: 36 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ class Arena;
3838
template <PrimitiveType T>
3939
struct AggregateFunctionArrayAggData {
4040
static constexpr PrimitiveType PType = T;
41+
static constexpr bool use_native_serde = false;
4142
using ElementType = typename PrimitiveTypeTraits<T>::CppType;
4243
using ColVecType = typename PrimitiveTypeTraits<T>::ColumnType;
4344
using Self = AggregateFunctionArrayAggData<T>;
@@ -137,6 +138,7 @@ template <PrimitiveType T>
137138
requires(is_string_type(T))
138139
struct AggregateFunctionArrayAggData<T> {
139140
static constexpr PrimitiveType PType = T;
141+
static constexpr bool use_native_serde = false;
140142
using ElementType = StringRef;
141143
using ColVecType = ColumnString;
142144
using Self = AggregateFunctionArrayAggData<T>;
@@ -232,16 +234,13 @@ template <PrimitiveType T>
232234
!is_date_type(T) && !is_ip(T))
233235
struct AggregateFunctionArrayAggData<T> {
234236
static constexpr PrimitiveType PType = T;
237+
static constexpr bool use_native_serde = true;
235238
using ElementType = StringRef;
236239
using Self = AggregateFunctionArrayAggData<T>;
237240
MutableColumnPtr column_data;
238-
DataTypePtr column_type;
239-
int be_exec_version;
240241

241-
AggregateFunctionArrayAggData(const DataTypes& argument_types, int be_exec_version_ = 0)
242-
: column_data(argument_types[0]->create_column()),
243-
column_type(argument_types[0]),
244-
be_exec_version(be_exec_version_) {}
242+
AggregateFunctionArrayAggData(const DataTypes& argument_types)
243+
: column_data(argument_types[0]->create_column()) {}
245244

246245
void add(const IColumn& column, size_t row_num) { column_data->insert_from(column, row_num); }
247246

@@ -267,23 +266,32 @@ struct AggregateFunctionArrayAggData<T> {
267266
to_arr.get_offsets().push_back(to_nested_col.size());
268267
}
269268

270-
void write(BufferWritable& buf) const {
271-
const auto serialized_bytes =
272-
column_type->get_uncompressed_serialized_bytes(*column_data, be_exec_version);
273-
std::string serialized_buffer(serialized_bytes, '\0');
274-
const auto* end =
275-
column_type->serialize(*column_data, serialized_buffer.data(), be_exec_version);
276-
DORIS_CHECK_LE(end, serialized_buffer.data() + serialized_bytes);
277-
serialized_buffer.resize(end - serialized_buffer.data());
278-
buf.write_binary(serialized_buffer);
269+
void write(BufferWritable& buf, const IDataType& column_type, int be_exec_version) const {
270+
const auto max_serialized_bytes = cast_set<size_t>(
271+
column_type.get_uncompressed_serialized_bytes(*column_data, be_exec_version));
272+
buf.resize(sizeof(UInt64) + max_serialized_bytes);
273+
auto* serialized_data = buf.data() + sizeof(UInt64);
274+
const char* end = nullptr;
275+
try {
276+
end = column_type.serialize(*column_data, serialized_data, be_exec_version);
277+
} catch (...) {
278+
buf.resize(0);
279+
throw;
280+
}
281+
DORIS_CHECK_LE(end, serialized_data + max_serialized_bytes);
282+
const auto serialized_bytes = static_cast<UInt64>(end - serialized_data);
283+
memcpy(buf.data(), &serialized_bytes, sizeof(serialized_bytes));
284+
const auto frame_bytes = sizeof(serialized_bytes) + cast_set<size_t>(serialized_bytes);
285+
buf.resize(frame_bytes);
286+
buf.add_offset(frame_bytes);
279287
}
280288

281-
void read(BufferReadable& buf) {
289+
void read(BufferReadable& buf, const IDataType& column_type, int be_exec_version) {
282290
DORIS_CHECK(column_data->empty());
283291
UInt64 serialized_bytes = 0;
284-
buf.read_var_uint(serialized_bytes);
292+
buf.read_binary(serialized_bytes);
285293
const auto* serialized_data = buf.data();
286-
const auto* end = column_type->deserialize(serialized_data, &column_data, be_exec_version);
294+
const auto* end = column_type.deserialize(serialized_data, &column_data, be_exec_version);
287295
DORIS_CHECK_EQ(end, serialized_data + serialized_bytes);
288296
buf.add_offset(serialized_bytes);
289297
}
@@ -311,14 +319,6 @@ class AggregateFunctionArrayAgg final
311319

312320
DataTypePtr get_return_type() const override { return return_type; }
313321

314-
void create(AggregateDataPtr __restrict place) const override {
315-
if constexpr (Data::PType == INVALID_TYPE) {
316-
new (place) Data(this->argument_types, this->version);
317-
} else {
318-
Base::create(place);
319-
}
320-
}
321-
322322
void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
323323
Arena& arena) const override {
324324
this->data(place).add(*columns[0], row_num);
@@ -330,12 +330,20 @@ class AggregateFunctionArrayAgg final
330330
}
331331

332332
void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
333-
this->data(place).write(buf);
333+
if constexpr (Data::use_native_serde) {
334+
this->data(place).write(buf, *this->argument_types[0], this->version);
335+
} else {
336+
this->data(place).write(buf);
337+
}
334338
}
335339

336340
void deserialize(AggregateDataPtr __restrict place, BufferReadable& buf,
337341
Arena&) const override {
338-
this->data(place).read(buf);
342+
if constexpr (Data::use_native_serde) {
343+
this->data(place).read(buf, *this->argument_types[0], this->version);
344+
} else {
345+
this->data(place).read(buf);
346+
}
339347
}
340348

341349
void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {

‎be/test/exprs/aggregate/agg_array_agg_test.cpp‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,9 +44,12 @@
4444
#include "core/types.h"
4545
#include "exprs/aggregate/agg_function_test.h"
4646
#include "exprs/aggregate/aggregate_function.h"
47+
#include "exprs/aggregate/aggregate_function_array_agg.h"
4748
#include "exprs/aggregate/aggregate_function_simple_factory.h"
4849
#include "exprs/aggregate/aggregate_function_sort.h"
4950
#include "gtest/gtest_pred_impl.h"
51+
#include "runtime/memory/mem_tracker_limiter.h"
52+
#include "runtime/thread_context.h"
5053

5154
namespace doris {
5255
class IColumn;
@@ -121,6 +124,16 @@ void check_complex_array_agg_state(const DataTypePtr& data_type,
121124
EXPECT_TRUE(ColumnHelper::column_equal(std::move(result_column), std::move(expected_column)));
122125
}
123126

127+
class ThrowOnSerializeDataType final : public DataTypeString {
128+
public:
129+
char* serialize(const IColumn&, char* buf, int) const override {
130+
*buf = 1;
131+
throw Exception(ErrorCode::MEM_ALLOC_FAILED, "mock serialize allocation failure");
132+
}
133+
};
134+
135+
static_assert(sizeof(AggregateFunctionArrayAggData<INVALID_TYPE>) == sizeof(MutableColumnPtr));
136+
124137
} // namespace
125138

126139
TEST_F(AggregateFunctionArrayAggTest, test_array_agg_aint64) {
@@ -350,6 +363,59 @@ TEST_F(AggregateFunctionArrayAggTest, foreach_complex_type_state_growth_and_roun
350363
EXPECT_TRUE(ColumnHelper::column_equal(std::move(result_column), std::move(expected_column)));
351364
}
352365

366+
TEST_F(AggregateFunctionArrayAggTest, complex_type_state_write_rolls_back_on_failure) {
367+
auto data_type = std::make_shared<ThrowOnSerializeDataType>();
368+
AggregateFunctionArrayAggData<INVALID_TYPE> data(DataTypes {data_type});
369+
auto serialized_column = ColumnString::create();
370+
BufferWritable writer(*serialized_column);
371+
writer.write_c_string("prefix");
372+
373+
EXPECT_THROW(data.write(writer, *data_type, BeExecVersionManager::get_newest_version()),
374+
Exception);
375+
EXPECT_EQ(serialized_column->get_chars().size(), 6);
376+
377+
writer.commit();
378+
EXPECT_EQ(serialized_column->get_data_at(0).to_string(), "prefix");
379+
}
380+
381+
TEST_F(AggregateFunctionArrayAggTest, large_complex_type_state_serialization_is_tracked) {
382+
constexpr size_t PAYLOAD_BYTES = 2 * 1024 * 1024;
383+
auto nullable_string = make_nullable(std::make_shared<DataTypeString>());
384+
auto nullable_inner_array = make_nullable(std::make_shared<DataTypeArray>(nullable_string));
385+
auto input_type = std::make_shared<DataTypeArray>(nullable_inner_array);
386+
auto function = AggregateFunctionSimpleFactory::instance().get(
387+
"array_agg_foreach", {input_type}, input_type, false,
388+
BeExecVersionManager::get_newest_version(), {.is_foreach = true, .column_names = {}});
389+
ASSERT_NE(function, nullptr);
390+
function->set_version(BeExecVersionManager::get_newest_version());
391+
392+
auto input_column = input_type->create_column();
393+
input_column->insert(array_field(
394+
{array_field({Field::create_field<TYPE_STRING>(String(PAYLOAD_BYTES, 'x'))})}));
395+
Arena arena;
396+
AggregateFunctionGuard state(function.get());
397+
add_column_to_state(*function, state.data(), *input_column, arena);
398+
399+
auto tracker = MemTrackerLimiter::create_shared(MemTrackerLimiter::Type::OTHER,
400+
"ArrayAggLargeStateSerializationTest");
401+
auto switch_tracker = SwitchThreadMemTrackerLimiter(tracker);
402+
thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
403+
const auto baseline = tracker->consumption();
404+
{
405+
auto serialized_column = ColumnString::create();
406+
BufferWritable writer(*serialized_column);
407+
function->serialize(state.data(), writer);
408+
writer.commit();
409+
thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
410+
411+
const auto tracked_bytes = tracker->consumption() - baseline;
412+
EXPECT_GT(tracked_bytes, PAYLOAD_BYTES);
413+
EXPECT_GE(tracked_bytes, serialized_column->allocated_bytes());
414+
}
415+
thread_context()->thread_mem_tracker_mgr->flush_untracked_mem();
416+
EXPECT_EQ(tracker->consumption(), baseline);
417+
}
418+
353419
TEST(AggregateFunctionSortDataTest, merge_does_not_share_rhs_block) {
354420
auto data_type = std::make_shared<DataTypeInt64>();
355421
Block prototype({ColumnWithTypeAndName(data_type->create_column(), data_type, "value"),

0 commit comments

Comments
 (0)