diff --git a/crates/iceberg/src/arrow/caching_delete_file_loader.rs b/crates/iceberg/src/arrow/caching_delete_file_loader.rs index 5582e4397f..9ee981f595 100644 --- a/crates/iceberg/src/arrow/caching_delete_file_loader.rs +++ b/crates/iceberg/src/arrow/caching_delete_file_loader.rs @@ -101,7 +101,11 @@ impl CachingDeleteFileLoader { ) -> Self { let scan_metrics = ScanMetrics::new(); CachingDeleteFileLoader { - basic_delete_file_loader: BasicDeleteFileLoader::new(file_io, scan_metrics), + basic_delete_file_loader: BasicDeleteFileLoader::new( + file_io, + scan_metrics, + runtime.clone(), + ), concurrency_limit_data_files, delete_filter: DeleteFilter::new(runtime.clone()), runtime, @@ -112,6 +116,7 @@ impl CachingDeleteFileLoader { self.basic_delete_file_loader = BasicDeleteFileLoader::new( self.basic_delete_file_loader.file_io().clone(), scan_metrics, + self.runtime.clone(), ); self } @@ -204,7 +209,10 @@ impl CachingDeleteFileLoader { let del_filter = self.delete_filter.clone(); let concurrency_limit_data_files = self.concurrency_limit_data_files; let basic_delete_file_loader = self.basic_delete_file_loader.clone(); - self.runtime.io().spawn(async move { + let io = self.runtime.io().clone(); + // Decode Parquet batches and construct delete filters on CPU workers. + // Storage operations are dispatched separately to the I/O runtime. + self.runtime.cpu().spawn(async move { let result = async move { let mut del_filter = del_filter; let basic_delete_file_loader = basic_delete_file_loader.clone(); @@ -212,12 +220,14 @@ impl CachingDeleteFileLoader { let mut results_stream = task_stream .map(move |(task, file_io, del_filter, schema)| { let basic_delete_file_loader = basic_delete_file_loader.clone(); + let io = io.clone(); async move { Self::load_file_for_task( &task, basic_delete_file_loader.clone(), del_filter, schema, + io, ) .await } @@ -262,13 +272,20 @@ impl CachingDeleteFileLoader { basic_delete_file_loader: BasicDeleteFileLoader, del_filter: DeleteFilter, schema: SchemaRef, + io: crate::runtime::RuntimeHandle, ) -> Result { match task.file_type() { DataContentType::PositionDeletes => { // A V3 deletion vector arrives as a PositionDeletes entry whose deletes live in // a Puffin blob, not in a positional-delete parquet file. if task.file_format() == DataFileFormat::Puffin { - return Self::load_deletion_vector(task, basic_delete_file_loader).await; + let task = task.clone(); + return io + .spawn(async move { + Self::load_deletion_vector(&task, basic_delete_file_loader).await + }) + .abort_on_drop() + .await?; } match del_filter.try_start_pos_del_load(task.file_path()) { @@ -840,6 +857,41 @@ mod tests { use crate::spec::{DataContentType, DataFileFormat, Schema}; use crate::test_utils::encode_dv_blob; + #[test] + fn delete_loading_requires_cpu_runtime() { + let io = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .enable_all() + .build() + .unwrap(); + // Deliberately not driven until after the I/O runtime has had a chance + // to run. A loader accidentally spawned on I/O would finish early. + let cpu = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap(); + let runtime = Runtime::new_with_split(&io, &cpu); + let dir = TempDir::new().unwrap(); + let tasks = setup(dir.path()); + let loader = CachingDeleteFileLoader::new(FileIO::new_with_fs(), 2, runtime); + let mut loaded = loader.load_deletes(tasks[0].deletes(), tasks[0].schema_ref()); + io.block_on(async { + assert!( + tokio::time::timeout(std::time::Duration::from_millis(100), &mut loaded) + .await + .is_err() + ); + }); + let filter = cpu.block_on(async { + tokio::time::timeout(std::time::Duration::from_secs(5), loaded) + .await + .unwrap() + .unwrap() + .unwrap() + }); + assert!(filter.get_delete_vector(&tasks[0]).is_some()); + } + #[test] fn test_deserialized_deletion_vector_rejects_missing_fields() { // A deletion vector that omits its required coordinates fails validation @@ -869,7 +921,7 @@ mod tests { let eq_delete_file_path = setup_write_equality_delete_file_1(table_location); let basic_delete_file_loader = - BasicDeleteFileLoader::new(file_io.clone(), ScanMetrics::new()); + BasicDeleteFileLoader::new(file_io.clone(), ScanMetrics::new(), Runtime::current()); let record_batch_stream = basic_delete_file_loader .parquet_to_batch_stream( &eq_delete_file_path, @@ -1307,7 +1359,7 @@ mod tests { let file_io = FileIO::new_with_fs(); let basic_delete_file_loader = - BasicDeleteFileLoader::new(file_io.clone(), ScanMetrics::new()); + BasicDeleteFileLoader::new(file_io.clone(), ScanMetrics::new(), Runtime::current()); let batch_stream = basic_delete_file_loader .parquet_to_batch_stream( @@ -1488,7 +1540,7 @@ mod tests { writer.close().unwrap(); let basic_delete_file_loader = - BasicDeleteFileLoader::new(file_io.clone(), ScanMetrics::new()); + BasicDeleteFileLoader::new(file_io.clone(), ScanMetrics::new(), Runtime::current()); let record_batch_stream = basic_delete_file_loader .parquet_to_batch_stream(&path, std::fs::metadata(&path).unwrap().len(), None) .await diff --git a/crates/iceberg/src/arrow/delete_file_loader.rs b/crates/iceberg/src/arrow/delete_file_loader.rs index ec61710a42..1f3f32c75e 100644 --- a/crates/iceberg/src/arrow/delete_file_loader.rs +++ b/crates/iceberg/src/arrow/delete_file_loader.rs @@ -47,14 +47,16 @@ pub trait DeleteFileLoader { pub(crate) struct BasicDeleteFileLoader { file_io: FileIO, scan_metrics: ScanMetrics, + runtime: crate::Runtime, } #[allow(unused_variables)] impl BasicDeleteFileLoader { - pub fn new(file_io: FileIO, scan_metrics: ScanMetrics) -> Self { + pub fn new(file_io: FileIO, scan_metrics: ScanMetrics, runtime: crate::Runtime) -> Self { BasicDeleteFileLoader { file_io, scan_metrics, + runtime, } } @@ -78,6 +80,7 @@ impl BasicDeleteFileLoader { let (parquet_file_reader, arrow_metadata) = ArrowReader::open_parquet_file( data_file_path, &self.file_io, + &self.runtime, file_size_in_bytes, parquet_read_options, self.scan_metrics.bytes_read_counter(), @@ -156,7 +159,8 @@ mod tests { let file_io = FileIO::new_with_fs(); let scan_metrics = ScanMetrics::new(); - let delete_file_loader = BasicDeleteFileLoader::new(file_io.clone(), scan_metrics); + let delete_file_loader = + BasicDeleteFileLoader::new(file_io.clone(), scan_metrics, crate::Runtime::current()); let file_scan_tasks = setup(table_location); @@ -241,7 +245,8 @@ mod tests { .unwrap(); let scan_metrics = ScanMetrics::new(); - let delete_file_loader = BasicDeleteFileLoader::new(file_io, scan_metrics); + let delete_file_loader = + BasicDeleteFileLoader::new(file_io, scan_metrics, crate::Runtime::current()); let result = delete_file_loader .read_delete_file(&task, schema) @@ -317,7 +322,8 @@ mod tests { .unwrap(); let scan_metrics = ScanMetrics::new(); - let delete_file_loader = BasicDeleteFileLoader::new(file_io, scan_metrics); + let delete_file_loader = + BasicDeleteFileLoader::new(file_io, scan_metrics, crate::Runtime::current()); let result = delete_file_loader .read_delete_file(&task, schema) diff --git a/crates/iceberg/src/arrow/mod.rs b/crates/iceberg/src/arrow/mod.rs index 28cf6e94a4..cea7c849d7 100644 --- a/crates/iceberg/src/arrow/mod.rs +++ b/crates/iceberg/src/arrow/mod.rs @@ -33,6 +33,7 @@ mod reader; pub mod record_batch_projector; pub(crate) mod record_batch_transformer; pub(crate) use record_batch_transformer::build_partition_constant; +mod runtime_file_read; mod scan_metrics; mod value; diff --git a/crates/iceberg/src/arrow/reader/batch_stream.rs b/crates/iceberg/src/arrow/reader/batch_stream.rs new file mode 100644 index 0000000000..b6d76c605c --- /dev/null +++ b/crates/iceberg/src/arrow/reader/batch_stream.rs @@ -0,0 +1,197 @@ +// 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. + +//! Bounded delivery of batches decoded on the CPU runtime. + +use futures::StreamExt; + +use crate::Result; +use crate::runtime::RuntimeHandle; +use crate::scan::ArrowRecordBatchStream; + +pub(super) fn decode_on_cpu( + mut stream: ArrowRecordBatchStream, + cpu: &RuntimeHandle, +) -> ArrowRecordBatchStream { + let (tx, rx) = tokio::sync::mpsc::channel(1); + let task = cpu + .spawn(async move { + loop { + // Reserve before polling Parquet: a slow consumer allows at most + // one decoded batch ahead, without decoding another while full. + let Ok(permit) = tx.reserve().await else { + return Ok(()); + }; + match stream.next().await { + Some(batch) => { + permit.send(batch?); + } + None => return Ok(()), + } + } + }) + .abort_on_drop(); + + // Retain the task with the receiver so dropping the stream also cancels a + // pending storage read. Await it at EOF to surface decoding errors, panics, + // and runtime shutdown instead of silently truncating the scan. + Box::pin(futures::stream::try_unfold( + (rx, task), + |(mut rx, task)| async move { + match rx.recv().await { + Some(batch) => Ok(Some((batch, (rx, task)))), + None => { + let result: Result<()> = task.await?; + result?; + Ok(None) + } + } + }, + )) +} + +#[cfg(test)] +mod tests { + use std::sync::Arc; + use std::sync::atomic::{AtomicUsize, Ordering}; + + use arrow_array::{Int32Array, RecordBatch}; + use futures::{StreamExt, TryStreamExt}; + + use super::*; + use crate::{Error, ErrorKind, Runtime}; + + fn batch() -> RecordBatch { + RecordBatch::try_from_iter(vec![("id", Arc::new(Int32Array::from(vec![1])) as _)]).unwrap() + } + + #[test] + fn polling_runs_on_cpu_even_when_consumer_runs_on_io() { + let io = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .thread_name("consumer-io") + .enable_all() + .build() + .unwrap(); + let cpu = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .thread_name("decode-cpu") + .enable_all() + .build() + .unwrap(); + let runtime = Runtime::new_with_split(&io, &cpu); + let source = futures::stream::iter(vec![Ok(batch()), Ok(batch())]).inspect(|_| { + assert_eq!(std::thread::current().name(), Some("decode-cpu")); + }); + let stream = decode_on_cpu(Box::pin(source), runtime.cpu()); + let batches = io + .block_on( + runtime + .io() + .spawn(async move { stream.try_collect::>().await.unwrap() }), + ) + .unwrap(); + assert_eq!(batches.len(), 2); + } + + #[tokio::test] + async fn slow_consumer_bounds_decoding_and_drop_cancels_producer() { + let polls = Arc::new(AtomicUsize::new(0)); + let dropped = Arc::new(tokio::sync::Notify::new()); + struct OnDrop(Arc); + impl Drop for OnDrop { + fn drop(&mut self) { + self.0.notify_one(); + } + } + let guard = OnDrop(dropped.clone()); + let observed = polls.clone(); + let source = futures::stream::poll_fn(move |_| { + let _keep_alive = &guard; + observed.fetch_add(1, Ordering::SeqCst); + std::task::Poll::Ready(Some(Ok(batch()))) + }); + let mut stream = decode_on_cpu(Box::pin(source), Runtime::current().cpu()); + for _ in 0..20 { + tokio::task::yield_now().await; + } + assert_eq!(polls.load(Ordering::SeqCst), 1); + stream.next().await.unwrap().unwrap(); + for _ in 0..20 { + tokio::task::yield_now().await; + } + assert_eq!(polls.load(Ordering::SeqCst), 2); + drop(stream); + tokio::time::timeout(std::time::Duration::from_secs(5), dropped.notified()) + .await + .unwrap(); + assert_eq!(polls.load(Ordering::SeqCst), 2); + } + + #[tokio::test] + async fn decode_error_follows_already_buffered_batches() { + let source = futures::stream::iter(vec![ + Ok(batch()), + Err(Error::new(ErrorKind::DataInvalid, "bad page")), + ]); + let mut stream = decode_on_cpu(Box::pin(source), Runtime::current().cpu()); + assert_eq!(stream.next().await.unwrap().unwrap().num_rows(), 1); + assert_eq!( + stream.next().await.unwrap().unwrap_err().kind(), + ErrorKind::DataInvalid + ); + assert!(stream.next().await.is_none()); + } + + #[tokio::test] + async fn producer_panic_is_not_reported_as_eof() { + let source = + futures::stream::poll_fn(|_| -> std::task::Poll>> { + panic!("decoder panic"); + }); + let mut stream = decode_on_cpu(Box::pin(source), Runtime::current().cpu()); + let error = stream.next().await.unwrap().unwrap_err(); + assert_eq!(error.kind(), ErrorKind::Unexpected); + assert!(error.to_string().contains("decoder panic")); + } + + #[tokio::test] + async fn dropping_stream_cancels_pending_decode() { + let started = Arc::new(tokio::sync::Notify::new()); + let dropped = Arc::new(tokio::sync::Notify::new()); + struct OnDrop(Arc); + impl Drop for OnDrop { + fn drop(&mut self) { + self.0.notify_one(); + } + } + let guard = OnDrop(dropped.clone()); + let signal = started.clone(); + let source = + futures::stream::poll_fn(move |_| -> std::task::Poll>> { + let _keep_alive = &guard; + signal.notify_one(); + std::task::Poll::Pending + }); + let stream = decode_on_cpu(Box::pin(source), Runtime::current().cpu()); + started.notified().await; + drop(stream); + tokio::time::timeout(std::time::Duration::from_secs(5), dropped.notified()) + .await + .unwrap(); + } +} diff --git a/crates/iceberg/src/arrow/reader/mod.rs b/crates/iceberg/src/arrow/reader/mod.rs index cda1909846..1293f6ff47 100644 --- a/crates/iceberg/src/arrow/reader/mod.rs +++ b/crates/iceberg/src/arrow/reader/mod.rs @@ -34,6 +34,7 @@ const DEFAULT_RANGE_FETCH_CONCURRENCY: usize = 10; /// Matches DataFusion's default `ParquetOptions::metadata_size_hint`. const DEFAULT_METADATA_SIZE_HINT: usize = 512 * 1024; +mod batch_stream; mod file_reader; mod options; mod pipeline; @@ -63,7 +64,12 @@ pub struct ArrowReaderBuilder { } impl ArrowReaderBuilder { - /// Create a new ArrowReaderBuilder + /// Create a new ArrowReaderBuilder. + /// + /// File opens and byte reads use the I/O runtime. Parquet metadata and page + /// decoding, filtering, and batch transformation use the CPU runtime, + /// regardless of which runtime polls the returned scan stream. Each data + /// file producer buffers at most one output batch ahead of its consumer. pub fn new(file_io: FileIO, runtime: Runtime) -> Self { let num_cpus = available_parallelism().get(); diff --git a/crates/iceberg/src/arrow/reader/pipeline.rs b/crates/iceberg/src/arrow/reader/pipeline.rs index 1ddee493c4..52e3ad4637 100644 --- a/crates/iceberg/src/arrow/reader/pipeline.rs +++ b/crates/iceberg/src/arrow/reader/pipeline.rs @@ -42,6 +42,7 @@ use crate::arrow::build_partition_constant; use crate::arrow::caching_delete_file_loader::CachingDeleteFileLoader; use crate::arrow::int96::coerce_int96_timestamps; use crate::arrow::record_batch_transformer::RecordBatchTransformerBuilder; +use crate::arrow::runtime_file_read::RuntimeFileRead; use crate::arrow::scan_metrics::{CountingFileRead, ScanMetrics, ScanResult}; use crate::encryption::StandardKeyMetadata; use crate::error::{Result, invalid_data}; @@ -151,6 +152,18 @@ fn candidate_row_groups( impl FileScanTaskReader { async fn process(self, task: FileScanTask) -> Result { + let runtime = self.runtime.clone(); + // Spawn the complete open/planning phase so it can keep progressing + // while try_flatten_unordered is polling other files (#3276). + let stream = runtime + .cpu() + .spawn(self.process_inner(task)) + .abort_on_drop() + .await??; + Ok(super::batch_stream::decode_on_cpu(stream, runtime.cpu())) + } + + async fn process_inner(self, task: FileScanTask) -> Result { let should_load_page_index = (self.row_selection_enabled && task.predicate().is_some()) || !task.deletes().is_empty(); let mut parquet_read_options = self.parquet_read_options; @@ -160,31 +173,16 @@ impl FileScanTaskReader { .delete_file_loader .load_deletes(task.deletes(), task.schema_ref()); - // `try_flatten_unordered` stops polling the buffered opens once it holds - // `concurrency_limit_data_files` streams, so spawn the open (#3276). - // Footer and page-index decode also run on the IO runtime. - // Aborts on drop. - let path = task.data_file_path().to_string(); - let file_io = self.file_io.clone(); - let file_size_in_bytes = task.file_size_in_bytes(); - let bytes_read = Arc::clone(self.scan_metrics.bytes_read_counter()); - let key_metadata = task.key_metadata().map(|km| km.to_vec()); - let opening = self - .runtime - .io() - .spawn(async move { - ArrowReader::open_parquet_file( - &path, - &file_io, - file_size_in_bytes, - parquet_read_options, - &bytes_read, - key_metadata.as_deref(), - ) - .await - }) - .abort_on_drop(); - let (parquet_file_reader, arrow_metadata) = opening.await??; + let (parquet_file_reader, arrow_metadata) = ArrowReader::open_parquet_file( + task.data_file_path(), + &self.file_io, + &self.runtime, + task.file_size_in_bytes(), + parquet_read_options, + self.scan_metrics.bytes_read_counter(), + task.key_metadata(), + ) + .await?; // Check if Parquet file has embedded field IDs // Corresponds to Java's ParquetSchemaUtil.hasIds() @@ -582,28 +580,13 @@ impl FileScanTaskReader { record_batch_stream_builder.metadata().num_row_groups(), ); - // Spawned for the same reason as the open (#3276). - let bloom_predicate = predicate.clone(); - let bloom_candidates = candidates.as_ref().to_vec(); - let bloom_field_ids = field_id_map.clone(); - let mut builder = record_batch_stream_builder; - let (builder, bloom_filtered) = self - .runtime - .io() - .spawn(async move { - let filtered = Self::filter_row_groups_by_bloom_filter( - &bloom_predicate, - &mut builder, - &bloom_candidates, - &bloom_field_ids, - ) - .await; - (builder, filtered) - }) - .abort_on_drop() - .await?; - record_batch_stream_builder = builder; - let bloom_filtered = bloom_filtered?; + let bloom_filtered = Self::filter_row_groups_by_bloom_filter( + &predicate, + &mut record_batch_stream_builder, + candidates.as_ref(), + &field_id_map, + ) + .await?; if bloom_filtered.len() < candidates.len() { selected_row_group_indices = Some(bloom_filtered); @@ -815,14 +798,14 @@ impl ArrowReader { pub(crate) async fn open_parquet_file( data_file_path: &str, file_io: &FileIO, + runtime: &Runtime, file_size_in_bytes: u64, parquet_read_options: ParquetReadOptions, bytes_read: &Arc, key_metadata: Option<&[u8]>, ) -> Result<(ArrowFileReader, ArrowReaderMetadata)> { - let parquet_file = file_io.new_input(data_file_path)?; - let counting_reader = - CountingFileRead::new(parquet_file.reader().await?, Arc::clone(bytes_read)); + let reader = RuntimeFileRead::open(file_io, data_file_path, runtime.io()).await?; + let counting_reader = CountingFileRead::new(reader, Arc::clone(bytes_read)); Self::build_parquet_reader( Box::new(counting_reader), file_size_in_bytes, @@ -3979,6 +3962,7 @@ mod tests { #[derive(Debug, Default)] struct Reads { + expected_io_thread: Option, last_start: Option, started: usize, finished: usize, @@ -4021,6 +4005,9 @@ mod tests { async fn read(&self, range: Range) -> Result { { let mut reads = self.log.0.lock().unwrap(); + if let Some(expected) = &reads.expected_io_thread { + assert_eq!(std::thread::current().name(), Some(expected.as_str())); + } reads.last_start = Some(range.start); reads.started += 1; } @@ -4038,6 +4025,9 @@ mod tests { #[typetag::serde] impl Storage for DeferredStorage { async fn reader(&self, path: &str) -> Result> { + if let Some(expected) = &self.log.0.lock().unwrap().expected_io_thread { + assert_eq!(std::thread::current().name(), Some(expected.as_str())); + } Ok(Box::new(DeferredRead { contents: self.files.read(path).await?, log: self.log.clone(), @@ -4175,6 +4165,75 @@ mod tests { } } + #[test] + fn scan_with_split_runtimes_keeps_storage_on_io() { + let io = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .thread_name("parquet-storage") + .enable_all() + .build() + .unwrap(); + let cpu = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .thread_name("parquet-decoding") + .enable_all() + .build() + .unwrap(); + let runtime = Runtime::new_with_split(&io, &cpu); + let dir = TempDir::new().unwrap(); + let path = write_plain_parquet( + dir.path().to_str().unwrap(), + "split.parquet", + vec![], + vec![], + ); + let contents = Bytes::from(std::fs::read(path).unwrap()); + let storage = DeferredStorage::default(); + storage.log.0.lock().unwrap().expected_io_thread = Some("parquet-storage".to_owned()); + let schema = Arc::new( + Schema::builder() + .with_fields(vec![ + NestedField::required(1, "id", Type::Primitive(PrimitiveType::Int)).into(), + ]) + .build() + .unwrap(), + ); + let batches = io.block_on(async { + storage + .files + .write("memory:/split.parquet", contents.clone()) + .await + .unwrap(); + let task = FileScanTask::builder() + .with_data_file_path("memory:/split.parquet".to_owned()) + .with_file_size_in_bytes(contents.len() as u64) + .with_start(0) + .with_length(0) + .with_data_file_format(DataFileFormat::Parquet) + .with_schema(schema) + .with_project_field_ids(vec![1]) + .with_case_sensitive(false) + .build() + .unwrap(); + let file_io = + FileIOBuilder::new(Arc::new(DeferredStorageFactory { storage })).build(); + let reader = ArrowReaderBuilder::new(file_io, runtime) + .with_batch_size(1) + .with_data_file_concurrency_limit(1) + .build(); + let tasks = Box::pin(futures::stream::iter(vec![Ok(task)])); + tokio::time::timeout( + std::time::Duration::from_secs(5), + reader.read(tasks).unwrap().stream().try_collect::>(), + ) + .await + .unwrap() + .unwrap() + }); + assert_eq!(batches.len(), 3); + assert_eq!(batches.iter().map(|b| b.num_rows()).sum::(), 3); + } + /// An open must finish its requests even when the scan is never polled again. #[tokio::test] async fn test_open_proceeds_without_the_scan_being_polled() { diff --git a/crates/iceberg/src/arrow/runtime_file_read.rs b/crates/iceberg/src/arrow/runtime_file_read.rs new file mode 100644 index 0000000000..d205ba3d43 --- /dev/null +++ b/crates/iceberg/src/arrow/runtime_file_read.rs @@ -0,0 +1,152 @@ +// 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. + +//! Dispatch storage operations without moving Parquet decoding off its caller's runtime. + +use std::ops::Range; +use std::sync::Arc; + +use bytes::Bytes; + +use crate::Result; +use crate::io::{FileIO, FileRead}; +use crate::runtime::RuntimeHandle; + +pub(super) struct RuntimeFileRead { + inner: Arc, + io: RuntimeHandle, +} + +impl RuntimeFileRead { + pub(super) async fn open(file_io: &FileIO, path: &str, io: &RuntimeHandle) -> Result { + let file_io = file_io.clone(); + let path = path.to_owned(); + let inner = io + .spawn(async move { file_io.new_input(&path)?.reader().await }) + .abort_on_drop() + .await??; + Ok(Self { + inner: Arc::from(inner), + io: io.clone(), + }) + } +} + +#[async_trait::async_trait] +impl FileRead for RuntimeFileRead { + async fn read(&self, range: Range) -> Result { + let inner = self.inner.clone(); + self.io + .spawn(async move { inner.read(range).await }) + .abort_on_drop() + .await? + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{Error, ErrorKind, Runtime}; + + struct CheckedRead; + + #[async_trait::async_trait] + impl FileRead for CheckedRead { + async fn read(&self, range: Range) -> Result { + assert_eq!(std::thread::current().name(), Some("parquet-io")); + tokio::task::yield_now().await; + assert_eq!(std::thread::current().name(), Some("parquet-io")); + if range.is_empty() { + return Err(Error::new(ErrorKind::DataInvalid, "empty test range")); + } + Ok(Bytes::from_static(b"data")) + } + } + + #[test] + fn reads_run_on_io_and_errors_reach_cpu() { + let io = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .thread_name("parquet-io") + .enable_all() + .build() + .unwrap(); + let cpu = tokio::runtime::Builder::new_multi_thread() + .worker_threads(1) + .thread_name("parquet-cpu") + .enable_all() + .build() + .unwrap(); + let runtime = Runtime::new_with_split(&io, &cpu); + let reader = RuntimeFileRead { + inner: Arc::new(CheckedRead), + io: runtime.io().clone(), + }; + cpu.block_on(runtime.cpu().spawn(async move { + assert_eq!( + reader.read(0..4).await.unwrap(), + Bytes::from_static(b"data") + ); + assert_eq!(std::thread::current().name(), Some("parquet-cpu")); + assert_eq!( + reader.read(0..0).await.unwrap_err().kind(), + ErrorKind::DataInvalid + ); + })) + .unwrap(); + } + + struct PendingRead { + started: tokio::sync::Notify, + dropped: Arc, + } + + #[async_trait::async_trait] + impl FileRead for PendingRead { + async fn read(&self, _range: Range) -> Result { + struct OnDrop(Arc); + impl Drop for OnDrop { + fn drop(&mut self) { + self.0.notify_one(); + } + } + let _guard = OnDrop(self.dropped.clone()); + self.started.notify_one(); + std::future::pending().await + } + } + + #[tokio::test] + async fn dropping_read_aborts_storage_request() { + let dropped = Arc::new(tokio::sync::Notify::new()); + let inner = Arc::new(PendingRead { + started: tokio::sync::Notify::new(), + dropped: dropped.clone(), + }); + let reader = RuntimeFileRead { + inner: inner.clone(), + io: Runtime::current().io().clone(), + }; + let mut read = Box::pin(reader.read(0..4)); + assert!(futures::poll!(&mut read).is_pending()); + inner.started.notified().await; + drop(read); + tokio::time::timeout(std::time::Duration::from_secs(5), dropped.notified()) + .await + .unwrap(); + } +}