@@ -52,6 +52,10 @@ size_t PartialBlockWritebackManager::BlockKeyHash::operator()(const BlockKey& ke
5252}
5353
5454struct PartialBlockWritebackManager ::Task {
55+ // Allocate one tracked block buffer and copy the first fragment into it.
56+ static TaskPtr create (PartialBlockWritebackRequest request, const BlockKey& task_key,
57+ size_t block_size);
58+
5559 // A queued task may merge while the manager lock is free. Once activate() wins, later
5660 // fragments are deduplicated and the worker obtains their bytes from the source read instead.
5761 std::optional<PartialBlockSubmitResult> try_merge (size_t fragment_offset, Slice data) {
@@ -80,6 +84,10 @@ struct PartialBlockWritebackManager::Task {
8084 return HoleFillPlanner::plan (block, covered_intervals, options, read_ranges);
8185 }
8286
87+ // Read a single range on the block worker; submit multiple ranges through its reusable token
88+ // and join them, including on failure.
89+ Status read_holes (const std::vector<FileRange>& read_ranges, ThreadPoolToken& token);
90+
8391 void activate () {
8492 bool expected = false ;
8593 DORIS_CHECK (active.compare_exchange_strong (expected, true , std::memory_order_acq_rel));
@@ -114,6 +122,10 @@ struct PartialBlockWritebackManager::Task {
114122 // A queued task may absorb foreground fragments while unrelated queue operations proceed.
115123 std::mutex fragment_mutex;
116124 std::atomic<bool > active {false };
125+
126+ private:
127+ // Read one buffer slice with per-call IO statistics on a block worker or remote-read thread.
128+ Status _read_hole (const FileRange& range);
117129};
118130
119131class PartialBlockWritebackManager ::Worker : public std::enable_shared_from_this<Worker> {
@@ -232,7 +244,7 @@ Status PartialBlockWritebackManager::_start() {
232244
233245PartialBlockSubmitResult PartialBlockWritebackManager::try_submit (
234246 PartialBlockWritebackRequest request) {
235- _validate_request ( request);
247+ request. sanity_check (_options. block_size );
236248
237249 if (!request.write_manager ->accepting ()) {
238250 return PartialBlockSubmitResult::REJECTED ;
@@ -272,7 +284,7 @@ PartialBlockSubmitResult PartialBlockWritebackManager::try_submit(
272284 }
273285 }
274286
275- auto candidate = _create_task (std::move (request), key);
287+ auto candidate = Task::create (std::move (request), key, _options. block_size );
276288 if (candidate == nullptr ) {
277289 return PartialBlockSubmitResult::BUFFER_ALLOCATION_FAILED ;
278290 }
@@ -294,32 +306,31 @@ PartialBlockSubmitResult PartialBlockWritebackManager::try_submit(
294306 }
295307}
296308
297- void PartialBlockWritebackManager::_validate_request (
298- const PartialBlockWritebackRequest& request) const {
299- DORIS_CHECK (request.write_manager != nullptr );
300- DORIS_CHECK (request.source_reader != nullptr );
301- DORIS_CHECK (request.write_epoch .key_token != nullptr );
302- DORIS_CHECK (request.block_offset % _options.block_size == 0 );
303- DORIS_CHECK (request.block_valid_size > 0 );
304- DORIS_CHECK (request.block_valid_size <= _options.block_size );
305- DORIS_CHECK (request.block_offset <= request.source_reader ->size ());
306- DORIS_CHECK (request.block_valid_size <= request.source_reader ->size () - request.block_offset );
307- DORIS_CHECK (request.data .data != nullptr );
308- DORIS_CHECK (request.data .size > 0 );
309- DORIS_CHECK (request.fragment_offset < request.block_valid_size );
310- DORIS_CHECK (request.data .size <= request.block_valid_size - request.fragment_offset );
309+ void PartialBlockWritebackRequest::sanity_check (size_t block_size) const {
310+ DORIS_CHECK (write_manager != nullptr );
311+ DORIS_CHECK (source_reader != nullptr );
312+ DORIS_CHECK (write_epoch.key_token != nullptr );
313+ DORIS_CHECK (block_offset % block_size == 0 );
314+ DORIS_CHECK (block_valid_size > 0 );
315+ DORIS_CHECK (block_valid_size <= block_size);
316+ DORIS_CHECK (block_offset <= source_reader->size ());
317+ DORIS_CHECK (block_valid_size <= source_reader->size () - block_offset);
318+ DORIS_CHECK (data.data != nullptr );
319+ DORIS_CHECK (data.size > 0 );
320+ DORIS_CHECK (fragment_offset < block_valid_size);
321+ DORIS_CHECK (data.size <= block_valid_size - fragment_offset);
311322}
312323
313- PartialBlockWritebackManager::TaskPtr PartialBlockWritebackManager::_create_task (
314- PartialBlockWritebackRequest request, const BlockKey& key ) {
324+ PartialBlockWritebackManager::TaskPtr PartialBlockWritebackManager::Task::create (
325+ PartialBlockWritebackRequest request, const BlockKey& task_key, size_t block_size ) {
315326 AsyncCacheWriteBufferPtr buffer;
316- if (!request.write_manager ->allocate_tracked_buffer (_options. block_size , &buffer).ok ()) {
327+ if (!request.write_manager ->allocate_tracked_buffer (block_size, &buffer).ok ()) {
317328 return nullptr ;
318329 }
319330 std::memcpy (buffer->data () + request.fragment_offset , request.data .data , request.data .size );
320331
321332 auto task = std::make_shared<Task>();
322- task->key = key ;
333+ task->key = task_key ;
323334 task->inflight_index = request.inflight_index ;
324335 task->source_reader = std::move (request.source_reader );
325336 task->block_valid_size = request.block_valid_size ;
@@ -644,7 +655,7 @@ void PartialBlockWritebackManager::_process_task(const TaskPtr& task, ThreadPool
644655 return ;
645656 }
646657
647- status = _read_holes ( task, read_ranges, token);
658+ status = task-> read_holes ( read_ranges, token);
648659 if (!status.ok ()) {
649660 read_ahead_bvars ().hole_fill_failed_blocks << 1 ;
650661 LOG (WARNING ) << " Read partial block holes failed, hash=" << task->key .cache_hash .to_string ()
@@ -669,19 +680,18 @@ void PartialBlockWritebackManager::_process_task(const TaskPtr& task, ThreadPool
669680 }
670681}
671682
672- Status PartialBlockWritebackManager::_read_holes (const TaskPtr& task,
673- const std::vector<FileRange>& read_ranges,
674- ThreadPoolToken& token) {
683+ Status PartialBlockWritebackManager::Task::read_holes (const std::vector<FileRange>& read_ranges,
684+ ThreadPoolToken& token) {
675685 if (read_ranges.empty ()) {
676686 return Status::OK ();
677687 }
678688 if (read_ranges.size () == 1 ) {
679- return _read_hole (task, read_ranges.front ());
689+ return _read_hole (read_ranges.front ());
680690 }
681691 std::vector<Status> results (read_ranges.size ());
682692 for (size_t index = 0 ; index < read_ranges.size (); ++index) {
683693 Status status = token.submit_func (
684- [&, index]() { results[index] = _read_hole (task, read_ranges[index]); });
694+ [&, index]() { results[index] = _read_hole (read_ranges[index]); });
685695 if (!status.ok ()) {
686696 results[index] = std::move (status);
687697 break ;
@@ -695,22 +705,21 @@ Status PartialBlockWritebackManager::_read_holes(const TaskPtr& task,
695705 return Status::OK ();
696706}
697707
698- Status PartialBlockWritebackManager::_read_hole (const TaskPtr& task, const FileRange& range) {
708+ Status PartialBlockWritebackManager::Task:: _read_hole (const FileRange& range) {
699709 FileCacheStatistics file_cache_stats;
700710 FileReaderStats file_reader_stats;
701- auto io_context = task-> io_context ;
702- io_context .io_context .file_cache_stats = &file_cache_stats;
703- io_context .io_context .file_reader_stats = &file_reader_stats;
711+ auto read_context = io_context;
712+ read_context .io_context .file_cache_stats = &file_cache_stats;
713+ read_context .io_context .file_reader_stats = &file_reader_stats;
704714 size_t bytes_read = 0 ;
705715 int64_t read_ns = 0 ;
706716 Status status;
707717 read_ahead_bvars ().hole_fill_remote_requests << 1 ;
708718 {
709719 SCOPED_RAW_TIMER (&read_ns);
710- status = task->source_reader ->read_at (
711- range.offset ,
712- Slice (task->buffer ->data () + range.offset - task->key .block_offset , range.size ),
713- &bytes_read, &io_context.io_context );
720+ status = source_reader->read_at (
721+ range.offset , Slice (buffer->data () + range.offset - key.block_offset , range.size ),
722+ &bytes_read, &read_context.io_context );
714723 }
715724 read_ahead_bvars ().hole_fill_remote_read_time_ns << read_ns;
716725 read_ahead_bvars ().hole_fill_remote_bytes << static_cast <int64_t >(bytes_read);
0 commit comments