@@ -35,8 +35,8 @@ use crate::metrics::{ByteProgress, RowFilterSkippedFullyMatchedMetric};
3535use crate :: optional_filter:: OptionalFilterOptions ;
3636use crate :: page_filter:: PagePruningAccessPlanFilter ;
3737use crate :: push_decoder:: {
38- DecoderBuilderConfig , InitialDecoderState , PushDecoderStreamState , ReadAhead ,
39- ReadAheadMemory , RgPlanEntry , RowFilterContext , RowGroupPruner ,
38+ DecoderBuilderConfig , InitialDecoderState , PrefetchBudget , PushDecoderStreamState ,
39+ ReadAhead , ReadAheadMemory , RgPlanEntry , RowFilterContext , RowGroupPruner ,
4040} ;
4141use crate :: row_filter:: { OptionalFilterRowFilterContext , PrebuiltRowFilterCandidate } ;
4242use crate :: row_group_filter:: { RowGroupAccessPlanFilter , row_group_in_range} ;
@@ -325,6 +325,11 @@ pub(super) struct ParquetMorselizer {
325325 /// Bytes each file stream fetches when it is built. Sourced from
326326 /// `datafusion.execution.read_ahead_eager_bytes`. 0 turns it off.
327327 pub read_ahead_eager_bytes : u64 ,
328+ /// The budget that bounds eager read-ahead over all files of this
329+ /// partition. Sourced from
330+ /// `datafusion.execution.read_ahead_prefetch_budget_bytes`. `None` means
331+ /// no shared bound.
332+ pub read_ahead_prefetch_budget : Option < Arc < PrefetchBudget > > ,
328333 /// Whether to read row groups in reverse order
329334 pub reverse_row_groups : bool ,
330335 /// Optional sort order used to reorder row groups by their min/max statistics.
@@ -533,6 +538,7 @@ struct PreparedParquetOpen {
533538 row_group_range_assignment : RowGroupRangeAssignment ,
534539 read_ahead_bytes : Option < u64 > ,
535540 read_ahead_eager_bytes : u64 ,
541+ read_ahead_prefetch_budget : Option < Arc < PrefetchBudget > > ,
536542 reverse_row_groups : bool ,
537543 sort_order_for_reorder : Option < LexOrdering > ,
538544 preserve_order : bool ,
@@ -1183,6 +1189,7 @@ impl ParquetMorselizer {
11831189 row_group_range_assignment : self . row_group_range_assignment ,
11841190 read_ahead_bytes : self . read_ahead_bytes ,
11851191 read_ahead_eager_bytes : self . read_ahead_eager_bytes ,
1192+ read_ahead_prefetch_budget : self . read_ahead_prefetch_budget . clone ( ) ,
11861193 reverse_row_groups : self . reverse_row_groups ,
11871194 sort_order_for_reorder : self . sort_order_for_reorder . clone ( ) ,
11881195 preserve_order : self . preserve_order ,
@@ -1925,6 +1932,7 @@ impl RowGroupsPrunedParquetOpen {
19251932
19261933 let read_ahead_bytes = prepared. read_ahead_bytes ;
19271934 let read_ahead_eager_bytes = prepared. read_ahead_eager_bytes ;
1935+ let read_ahead_prefetch_budget = prepared. read_ahead_prefetch_budget . clone ( ) ;
19281936
19291937 // Lazily-registered suppression counter shared by the open-time first-RG
19301938 // skip below and the stream's per-RG toggle (registered on first use so
@@ -2152,7 +2160,10 @@ impl RowGroupsPrunedParquetOpen {
21522160 projection_builder,
21532161 read_ahead,
21542162 } ;
2155- stream_state. start_eager_read_ahead ( read_ahead_eager_bytes) ;
2163+ stream_state. start_eager_read_ahead (
2164+ read_ahead_eager_bytes,
2165+ read_ahead_prefetch_budget. as_ref ( ) ,
2166+ ) ;
21562167 let stream = stream_state. into_stream ( ) ;
21572168
21582169 // Wrap the stream so a dynamic filter can stop the file scan early, but
@@ -2470,6 +2481,7 @@ mod test {
24702481 row_group_range_assignment : RowGroupRangeAssignment ,
24712482 read_ahead_bytes : Option < u64 > ,
24722483 read_ahead_eager_bytes : u64 ,
2484+ read_ahead_prefetch_budget : Option < Arc < PrefetchBudget > > ,
24732485 memory_pool : Option < Arc < dyn MemoryPool > > ,
24742486 reverse_row_groups : bool ,
24752487 preserve_order : bool ,
@@ -2695,6 +2707,7 @@ mod test {
26952707 row_group_range_assignment : RowGroupRangeAssignment :: default ( ) ,
26962708 read_ahead_bytes : None ,
26972709 read_ahead_eager_bytes : 0 ,
2710+ read_ahead_prefetch_budget : None ,
26982711 memory_pool : None ,
26992712 reverse_row_groups : false ,
27002713 preserve_order : false ,
@@ -2792,6 +2805,15 @@ mod test {
27922805 self
27932806 }
27942807
2808+ /// Set the shared prefetch budget of eager read-ahead.
2809+ fn with_read_ahead_prefetch_budget (
2810+ mut self ,
2811+ budget : Arc < PrefetchBudget > ,
2812+ ) -> Self {
2813+ self . read_ahead_prefetch_budget = Some ( budget) ;
2814+ self
2815+ }
2816+
27952817 /// Set the eager read-ahead bytes (`read_ahead_eager_bytes`).
27962818 fn with_read_ahead_eager_bytes ( mut self , bytes : u64 ) -> Self {
27972819 self . read_ahead_eager_bytes = bytes;
@@ -2942,6 +2964,7 @@ mod test {
29422964 row_group_range_assignment : self . row_group_range_assignment ,
29432965 read_ahead_bytes : self . read_ahead_bytes ,
29442966 read_ahead_eager_bytes : self . read_ahead_eager_bytes ,
2967+ read_ahead_prefetch_budget : self . read_ahead_prefetch_budget . clone ( ) ,
29452968 reverse_row_groups : self . reverse_row_groups ,
29462969 sort_order_for_reorder : None ,
29472970 virtual_state,
@@ -7229,6 +7252,56 @@ mod test {
72297252 ( before, rows)
72307253 }
72317254
7255+ /// Verifies that a shared prefetch budget bounds the eager fetches of
7256+ /// the files of one partition: a second file that does not fit waits,
7257+ /// and the first file returns its bytes when its stream is read.
7258+ #[ tokio:: test]
7259+ async fn prefetch_budget_bounds_eager_fetches_across_files ( ) {
7260+ let store = Arc :: new ( InMemory :: new ( ) ) as Arc < dyn ObjectStore > ;
7261+ let ( schema, len) = write_file ( & store) . await ;
7262+ let fetches = Arc :: new ( Mutex :: new ( vec ! [ ] ) ) ;
7263+ let factory = RecordingReaderFactory {
7264+ inner : DefaultParquetFileReaderFactory :: new ( Arc :: clone ( & store) ) ,
7265+ fetches : Arc :: clone ( & fetches) ,
7266+ } ;
7267+ let pool: Arc < dyn MemoryPool > =
7268+ Arc :: new ( GreedyMemoryPool :: new ( 64 * 1024 * 1024 ) ) ;
7269+ let budget_bytes = 400 * 1024 ;
7270+ let budget = Arc :: new ( PrefetchBudget :: new ( budget_bytes) ) ;
7271+ let morselizer = ParquetMorselizerBuilder :: new ( )
7272+ . with_store ( Arc :: clone ( & store) )
7273+ . with_schema ( schema)
7274+ . with_projection_indices ( & [ 0 , 1 ] )
7275+ . with_parquet_file_reader_factory ( Arc :: new ( factory) )
7276+ . with_read_ahead_bytes ( WINDOW )
7277+ . with_read_ahead_eager_bytes ( WINDOW / 2 )
7278+ . with_read_ahead_prefetch_budget ( Arc :: clone ( & budget) )
7279+ . with_memory_pool ( Arc :: clone ( & pool) )
7280+ . build ( ) ;
7281+ let file =
7282+ || PartitionedFile :: new ( "read_ahead.parquet" . to_string ( ) , len as u64 ) ;
7283+
7284+ let first = open_file ( & morselizer, file ( ) ) . await . unwrap ( ) ;
7285+ let second = open_file ( & morselizer, file ( ) ) . await . unwrap ( ) ;
7286+ tokio:: time:: sleep ( std:: time:: Duration :: from_millis ( 50 ) ) . await ;
7287+ let before = fetches. lock ( ) . unwrap ( ) . clone ( ) ;
7288+ assert_eq ! ( before. len( ) , 1 , "only the first file fits: {before:?}" ) ;
7289+ assert_eq ! ( budget. remaining( ) , budget_bytes - before[ 0 ] ) ;
7290+
7291+ let ( _batches, rows) = count_batches_and_rows ( first) . await ;
7292+ assert_eq ! ( rows, ROWS as usize ) ;
7293+ assert_eq ! (
7294+ budget. remaining( ) ,
7295+ budget_bytes,
7296+ "the first file gave its bytes back"
7297+ ) ;
7298+ let ( _batches, rows) = count_batches_and_rows ( second) . await ;
7299+ assert_eq ! ( rows, ROWS as usize ) ;
7300+ drop ( morselizer) ;
7301+ assert_eq ! ( budget. remaining( ) , budget_bytes) ;
7302+ assert_eq ! ( pool. reserved( ) , 0 ) ;
7303+ }
7304+
72327305 /// Verifies that eager read-ahead fetches data before the stream is
72337306 /// polled, within its limit, and that the scan still reads every row.
72347307 #[ tokio:: test]
0 commit comments