be/src/exec/operator/data_queue.cpp

Source
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include "exec/operator/data_queue.h"

#include <glog/logging.h>

#include <algorithm>
#include <utility>

#include "common/thread_safety_annotations.h"
#include "core/block/block.h"
#include "exec/pipeline/dependency.h"

namespace doris {

void SubQueue::try_pop(std::unique_ptr<Block>* output_block) {
    LockGuard l(queue_lock);
    if (!blocks.empty()) {
        *output_block = std::move(blocks.front());
        blocks.pop_front();
        bytes_in_queue -= (*output_block)->allocated_bytes();
        blocks_in_queue -= 1;
        if (blocks.empty()) {
            sink_dependency->set_ready();
        }
    }
}

bool SubQueue::try_push(std::unique_ptr<Block> block, std::atomic_uint32_t& total_counter) {
    LockGuard l(queue_lock);
    if (is_finished) {
        return false;
    }
    total_counter++;
    bytes_in_queue += block->allocated_bytes();
    blocks.emplace_back(std::move(block));
    blocks_in_queue += 1;
    if (static_cast<int64_t>(blocks.size()) > max_blocks_in_queue.load()) {
        sink_dependency->block();
    }
    return true;
}

bool SubQueue::mark_finished(std::atomic_uint32_t& unfinished_counter,
                             std::atomic_bool& all_finished) {
    LockGuard l(queue_lock);
    if (is_finished) {
        return false;
    }
    is_finished = true;
    if (unfinished_counter.fetch_sub(1) == 1) {
        all_finished = true;
    }
    return true;
}

void SubQueue::clear_blocks() {
    bool need_set_always_ready = false;
    {
        LockGuard l(queue_lock);
        if (!blocks.empty()) {
            blocks.clear();
            bytes_in_queue = 0;
            blocks_in_queue = 0;
            need_set_always_ready = true;
        }
    }
    // Notify outside of queue_lock to keep lock ordering simple.
    if (need_set_always_ready) {
        sink_dependency->set_always_ready();
    }
}

DataQueue::DataQueue(int child_count) : _sub_queues(child_count), _child_count(child_count) {
    for (auto& sub : _sub_queues) {
        sub = std::make_unique<SubQueue>();
    }
    _un_finished_counter = child_count;
}

bool DataQueue::has_more_data() const {
    return _cur_blocks_total_nums.load() > 0;
}

void DataQueue::set_source_dependency(std::shared_ptr<Dependency> source_dependency)
        NO_THREAD_SAFETY_ANALYSIS {
    _source_dependency = std::move(source_dependency);
}

void DataQueue::set_sink_dependency(Dependency* sink_dependency, int child_idx) {
    _sub_queues[child_idx]->sink_dependency = sink_dependency;
}

void DataQueue::set_max_blocks_in_sub_queue(int64_t max_blocks) {
    for (auto& sub : _sub_queues) {
        sub->max_blocks_in_queue = max_blocks;
    }
}

void DataQueue::set_low_memory_mode() {
    _is_low_memory_mode = true;
    for (auto& sub : _sub_queues) {
        sub->max_blocks_in_queue = 1;
    }
    clear_free_blocks();
}

std::unique_ptr<Block> DataQueue::get_free_block(int child_idx) {
    auto& sub = *_sub_queues[child_idx];
    {
        LockGuard l(sub.free_lock);
        if (!sub.free_blocks.empty()) {
            auto block = std::move(sub.free_blocks.front());
            sub.free_blocks.pop_front();
            return block;
        }
    }

    return Block::create_unique();
}

void DataQueue::push_free_block(std::unique_ptr<Block> block, int child_idx) {
    DCHECK(block->rows() == 0);

    if (!_is_low_memory_mode) {
        auto& sub = *_sub_queues[child_idx];
        LockGuard l(sub.free_lock);
        sub.free_blocks.emplace_back(std::move(block));
    }
}

void DataQueue::clear_free_blocks() {
    for (auto& sub : _sub_queues) {
        LockGuard l(sub->free_lock);
        std::deque<std::unique_ptr<Block>> tmp_queue;
        sub->free_blocks.swap(tmp_queue);
    }
}

void DataQueue::terminate() {
    for (int i = 0; i < _child_count; ++i) {
        set_finish(i);
        _sub_queues[i]->clear_blocks();
    }
    clear_free_blocks();
}

//check which queue have data, and save the idx in _flag_queue_idx,
//so next loop, will check the record idx + 1 first
//maybe it's useful with many queue, others maybe always 0
bool DataQueue::remaining_has_data() {
    int count = _child_count;
    while (--count >= 0) {
        _flag_queue_idx++;
        if (_flag_queue_idx == _child_count) {
            _flag_queue_idx = 0;
        }
        if (_sub_queues[_flag_queue_idx]->blocks_in_queue.load() > 0) {
            return true;
        }
    }
    return false;
}

//the _flag_queue_idx indicate which queue has data, and in check can_read
//will be set idx in remaining_has_data function
Status DataQueue::get_block_from_queue(std::unique_ptr<Block>* output_block, int* child_idx) {
    const int idx = _flag_queue_idx;
    auto& sub = *_sub_queues[idx];

    sub.try_pop(output_block);
    if (*output_block) {
        if (child_idx) {
            *child_idx = idx;
        }
        auto old_total = _cur_blocks_total_nums.fetch_sub(1);
        if (old_total == 1) {
            set_source_block();
        }
    }
    return Status::OK();
}

Status DataQueue::push_block(std::unique_ptr<Block> block, int child_idx) {
    if (!block) {
        return Status::OK();
    }
    auto& sub = *_sub_queues[child_idx];
    // total_counter is incremented inside try_push under queue_lock, only when the
    // block is actually enqueued. This ensures get_block_from_queue() always observes
    // _cur_blocks_total_nums >= 1 when it successfully pops a block, with no risk of
    // underflow or the need for a rollback on failure.
    if (!sub.try_push(std::move(block), _cur_blocks_total_nums)) {
        return Status::EndOfFile("SubQueue already finished");
    }
    set_source_ready();
    return Status::OK();
}

void DataQueue::set_finish(int child_idx) {
    auto& sub = *_sub_queues[child_idx];
    if (!sub.mark_finished(_un_finished_counter, _is_all_finished)) {
        return;
    }
    set_source_ready();
}

bool DataQueue::is_all_finish() {
    return _is_all_finished;
}

void DataQueue::set_source_ready() {
    LockGuard lc(_source_lock);
    if (_source_dependency) {
        _source_dependency->set_ready();
    }
}

void DataQueue::set_source_block() {
    // Re-check under _source_lock to avoid blocking the source when a concurrent push
    // has already added new blocks (or all children have finished) since we observed
    // the counter drop to zero.
    LockGuard lc(_source_lock);
    if (_source_dependency && _cur_blocks_total_nums == 0 && !is_all_finish()) {
        _source_dependency->block();
    }
}

} // namespace doris

Coverage Report

Created: 2026-07-12 14:58

Line	Count	Source
1		// Licensed to the Apache Software Foundation (ASF) under one
2		// or more contributor license agreements. See the NOTICE file
3		// distributed with this work for additional information
4		// regarding copyright ownership. The ASF licenses this file
5		// to you under the Apache License, Version 2.0 (the
6		// "License"); you may not use this file except in compliance
7		// with the License. You may obtain a copy of the License at
8		//
9		// http://www.apache.org/licenses/LICENSE-2.0
10		//
11		// Unless required by applicable law or agreed to in writing,
12		// software distributed under the License is distributed on an
13		// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14		// KIND, either express or implied. See the License for the
15		// specific language governing permissions and limitations
16		// under the License.
17
18		#include "exec/operator/data_queue.h"
19
20		#include <glog/logging.h>
21
22		#include <algorithm>
23		#include <utility>
24
25		#include "common/thread_safety_annotations.h"
26		#include "core/block/block.h"
27		#include "exec/pipeline/dependency.h"
28
29		namespace doris {
30
31	344	void SubQueue::try_pop(std::unique_ptr<Block>* output_block) {
32	344	LockGuard l(queue_lock);
33	344	if (!blocks.empty()) {
34	338	*output_block = std::move(blocks.front());
35	338	blocks.pop_front();
36	338	bytes_in_queue -= (*output_block)->allocated_bytes();
37	338	blocks_in_queue -= 1;
38	338	if (blocks.empty()) {
39	216	sink_dependency->set_ready();
40	216	}
41	338	}
42	344	}
43
44	370	bool SubQueue::try_push(std::unique_ptr<Block> block, std::atomic_uint32_t& total_counter) {
45	370	LockGuard l(queue_lock);
46	370	if (is_finished) {
47	2	return false;
48	2	}
49	368	total_counter++;
50	368	bytes_in_queue += block->allocated_bytes();
51	368	blocks.emplace_back(std::move(block));
52	368	blocks_in_queue += 1;
53	368	if (static_cast<int64_t>(blocks.size()) > max_blocks_in_queue.load()) {
54	138	sink_dependency->block();
55	138	}
56	368	return true;
57	370	}
58
59		bool SubQueue::mark_finished(std::atomic_uint32_t& unfinished_counter,
60	46	std::atomic_bool& all_finished) {
61	46	LockGuard l(queue_lock);
62	46	if (is_finished) {
63	4	return false;
64	4	}
65	42	is_finished = true;
66	42	if (unfinished_counter.fetch_sub(1) == 1) {
67	20	all_finished = true;
68	20	}
69	42	return true;
70	46	}
71
72	10	void SubQueue::clear_blocks() {
73	10	bool need_set_always_ready = false;
74	10	{
75	10	LockGuard l(queue_lock);
76	10	if (!blocks.empty()) {
77	6	blocks.clear();
78	6	bytes_in_queue = 0;
79	6	blocks_in_queue = 0;
80	6	need_set_always_ready = true;
81	6	}
82	10	}
83		// Notify outside of queue_lock to keep lock ordering simple.
84	10	if (need_set_always_ready) {
85	6	sink_dependency->set_always_ready();
86	6	}
87	10	}
88
89	30	DataQueue::DataQueue(int child_count) : _sub_queues(child_count), _child_count(child_count) {
90	78	for (auto& sub : _sub_queues) {
91	78	sub = std::make_unique<SubQueue>();
92	78	}
93	30	_un_finished_counter = child_count;
94	30	}
95
96	6	bool DataQueue::has_more_data() const {
97	6	return _cur_blocks_total_nums.load() > 0;
98	6	}
99
100		void DataQueue::set_source_dependency(std::shared_ptr<Dependency> source_dependency)
101	30	NO_THREAD_SAFETY_ANALYSIS {
102	30	_source_dependency = std::move(source_dependency);
103	30	}
104
105	78	void DataQueue::set_sink_dependency(Dependency* sink_dependency, int child_idx) {
106	78	_sub_queues[child_idx]->sink_dependency = sink_dependency;
107	78	}
108
109	14	void DataQueue::set_max_blocks_in_sub_queue(int64_t max_blocks) {
110	30	for (auto& sub : _sub_queues) {
111	30	sub->max_blocks_in_queue = max_blocks;
112	30	}
113	14	}
114
115	2	void DataQueue::set_low_memory_mode() {
116	2	_is_low_memory_mode = true;
117	6	for (auto& sub : _sub_queues) {
118	6	sub->max_blocks_in_queue = 1;
119	6	}
120	2	clear_free_blocks();
121	2	}
122
123	28	std::unique_ptr<Block> DataQueue::get_free_block(int child_idx) {
124	28	auto& sub = *_sub_queues[child_idx];
125	28	{
126	28	LockGuard l(sub.free_lock);
127	28	if (!sub.free_blocks.empty()) {
128	4	auto block = std::move(sub.free_blocks.front());
129	4	sub.free_blocks.pop_front();
130	4	return block;
131	4	}
132	28	}
133
134	24	return Block::create_unique();
135	28	}
136
137	26	void DataQueue::push_free_block(std::unique_ptr<Block> block, int child_idx) {
138	26	DCHECK(block->rows() == 0);
139
140	26	if (!_is_low_memory_mode) {
141	24	auto& sub = *_sub_queues[child_idx];
142	24	LockGuard l(sub.free_lock);
143	24	sub.free_blocks.emplace_back(std::move(block));
144	24	}
145	26	}
146
147	4	void DataQueue::clear_free_blocks() {
148	12	for (auto& sub : _sub_queues) {
149	12	LockGuard l(sub->free_lock);
150	12	std::deque<std::unique_ptr<Block>> tmp_queue;
151	12	sub->free_blocks.swap(tmp_queue);
152	12	}
153	4	}
154
155	2	void DataQueue::terminate() {
156	8	for (int i = 0; i < _child_count; ++i) {
157	6	set_finish(i);
158	6	_sub_queues[i]->clear_blocks();
159	6	}
160	2	clear_free_blocks();
161	2	}
162
163		//check which queue have data, and save the idx in _flag_queue_idx,
164		//so next loop, will check the record idx + 1 first
165		//maybe it's useful with many queue, others maybe always 0
166	342	bool DataQueue::remaining_has_data() {
167	342	int count = _child_count;
168	454	while (--count >= 0) {
169	431	_flag_queue_idx++;
170	431	if (_flag_queue_idx == _child_count) {
171	144	_flag_queue_idx = 0;
172	144	}
173	431	if (_sub_queues[_flag_queue_idx]->blocks_in_queue.load() > 0) {
174	319	return true;
175	319	}
176	431	}
177	23	return false;
178	342	}
179
180		//the _flag_queue_idx indicate which queue has data, and in check can_read
181		//will be set idx in remaining_has_data function
182	332	Status DataQueue::get_block_from_queue(std::unique_ptr<Block>* output_block, int* child_idx) {
183	332	const int idx = _flag_queue_idx;
184	332	auto& sub = *_sub_queues[idx];
185
186	332	sub.try_pop(output_block);
187	332	if (*output_block) {
188	328	if (child_idx) {
189	328	*child_idx = idx;
190	328	}
191	328	auto old_total = _cur_blocks_total_nums.fetch_sub(1);
192	328	if (old_total == 1) {
193	25	set_source_block();
194	25	}
195	328	}
196	332	return Status::OK();
197	332	}
198
199	348	Status DataQueue::push_block(std::unique_ptr<Block> block, int child_idx) {
200	348	if (!block) {
201	0	return Status::OK();
202	0	}
203	348	auto& sub = *_sub_queues[child_idx];
204		// total_counter is incremented inside try_push under queue_lock, only when the
205		// block is actually enqueued. This ensures get_block_from_queue() always observes
206		// _cur_blocks_total_nums >= 1 when it successfully pops a block, with no risk of
207		// underflow or the need for a rollback on failure.
208	348	if (!sub.try_push(std::move(block), _cur_blocks_total_nums)) {
209	0	return Status::EndOfFile("SubQueue already finished");
210	0	}
211	348	set_source_ready();
212	348	return Status::OK();
213	348	}
214
215	38	void DataQueue::set_finish(int child_idx) {
216	38	auto& sub = *_sub_queues[child_idx];
217	38	if (!sub.mark_finished(_un_finished_counter, _is_all_finished)) {
218	2	return;
219	2	}
220	36	set_source_ready();
221	36	}
222
223	49	bool DataQueue::is_all_finish() {
224	49	return _is_all_finished;
225	49	}
226
227	384	void DataQueue::set_source_ready() {
228	384	LockGuard lc(_source_lock);
229	384	if (_source_dependency) {
230	384	_source_dependency->set_ready();
231	384	}
232	384	}
233
234	25	void DataQueue::set_source_block() {
235		// Re-check under _source_lock to avoid blocking the source when a concurrent push
236		// has already added new blocks (or all children have finished) since we observed
237		// the counter drop to zero.
238	25	LockGuard lc(_source_lock);
239	25	if (_source_dependency && _cur_blocks_total_nums == 0 && !is_all_finish()) {
240	13	_source_dependency->block();
241	13	}
242	25	}
243
244		} // namespace doris