@@ -59,7 +59,7 @@ use datafusion_common::{
5959use datafusion_common_runtime:: SpawnedTask ;
6060use datafusion_execution:: TaskContext ;
6161use datafusion_execution:: memory_pool:: {
62- MemoryConsumer , MemoryPool , MemoryReservation , MergeMemoryPool ,
62+ MemoryConsumer , MemoryLimit , MemoryPool , MemoryReservation , MergeMemoryPool ,
6363} ;
6464use datafusion_execution:: runtime_env:: RuntimeEnv ;
6565use datafusion_physical_expr:: LexOrdering ;
@@ -707,7 +707,8 @@ impl ExternalSorter {
707707 if self . in_mem_batches . len ( ) == 1 {
708708 let batch = self . in_mem_batches . swap_remove ( 0 ) ;
709709 let reservation = self . reservation . take ( ) ;
710- let sorted_stream = self . sort_batch_stream ( batch, reservation, None ) ?;
710+ let sorted_stream =
711+ self . sort_batch_stream ( batch, reservation, None , self . batch_size ) ?;
711712 return Ok ( self . observe_if_output ( sorted_stream, is_output_stream) ) ;
712713 }
713714
@@ -724,7 +725,8 @@ impl ExternalSorter {
724725 . try_resize ( get_reserved_bytes_for_record_batch ( & batch) ?)
725726 . map_err ( Self :: err_with_oom_context) ?;
726727 let reservation = self . reservation . take ( ) ;
727- let sorted_stream = self . sort_batch_stream ( batch, reservation, None ) ?;
728+ let sorted_stream =
729+ self . sort_batch_stream ( batch, reservation, None , self . batch_size ) ?;
728730 return Ok ( self . observe_if_output ( sorted_stream, is_output_stream) ) ;
729731 }
730732
@@ -780,13 +782,19 @@ impl ExternalSorter {
780782 let ( sizes, shared_input_size) = self . sort_run_sizes ( & runs) ?;
781783 let shared_input =
782784 shared_input_size. map ( |size| Arc :: new ( self . reservation . split ( size) ) ) ;
785+ let batch_size = self . merge_run_batch_size ( ) ;
783786 let jobs =
784787 runs. into_iter ( )
785788 . zip ( sizes)
786789 . enumerate ( )
787790 . map ( move |( index, ( batch, size) ) | {
788791 let reservation = self . reservation . split ( size) ;
789- let sort = self . sort_run ( batch, reservation, shared_input. clone ( ) ) ?;
792+ let sort = self . sort_run (
793+ batch,
794+ reservation,
795+ shared_input. clone ( ) ,
796+ batch_size,
797+ ) ?;
790798 let permits = Arc :: clone ( & concurrency. permits ) ;
791799 Ok :: < _ , DataFusionError > ( async move {
792800 let stream = Self :: prepare_sort_run ( sort, permits) . await ?;
@@ -968,11 +976,12 @@ impl ExternalSorter {
968976 let ( sizes, shared_input_size) = self . sort_run_sizes ( & runs) ?;
969977 let shared_input =
970978 shared_input_size. map ( |size| Arc :: new ( self . reservation . split ( size) ) ) ;
979+ let batch_size = self . merge_run_batch_size ( ) ;
971980 runs. into_iter ( )
972981 . zip ( sizes)
973982 . map ( |( run, size) | {
974983 let reservation = self . reservation . split ( size) ;
975- self . sort_batch_stream ( run, reservation, shared_input. clone ( ) )
984+ self . sort_batch_stream ( run, reservation, shared_input. clone ( ) , batch_size )
976985 } )
977986 . collect ( )
978987 }
@@ -995,11 +1004,11 @@ impl ExternalSorter {
9951004 batch : RecordBatch ,
9961005 reservation : MemoryReservation ,
9971006 shared_input : Option < Arc < MemoryReservation > > ,
1007+ batch_size : usize ,
9981008 ) -> Result < SendableRecordBatchStream > {
9991009 let schema = batch. schema ( ) ;
1000- let stream =
1001- futures:: stream:: once ( self . sort_run ( batch, reservation, shared_input) ?)
1002- . try_flatten ( ) ;
1010+ let sort = self . sort_run ( batch, reservation, shared_input, batch_size) ?;
1011+ let stream = futures:: stream:: once ( sort) . try_flatten ( ) ;
10031012 Ok ( Box :: pin ( RecordBatchStreamAdapter :: new ( schema, stream) ) )
10041013 }
10051014
@@ -1012,6 +1021,7 @@ impl ExternalSorter {
10121021 batch : RecordBatch ,
10131022 reservation : MemoryReservation ,
10141023 shared_input : Option < Arc < MemoryReservation > > ,
1024+ batch_size : usize ,
10151025 ) -> Result < impl Future < Output = Result < SendableRecordBatchStream > > + Send + use <>>
10161026 {
10171027 let reserved_bytes = get_reserved_bytes_for_record_batch ( & batch) ?;
@@ -1024,7 +1034,6 @@ impl ExternalSorter {
10241034 }
10251035
10261036 let expressions = self . expr . clone ( ) ;
1027- let batch_size = self . batch_size ;
10281037 let merge_pool = Arc :: clone ( & self . merge_pool ) ;
10291038 let elapsed_compute = self . metrics . baseline . elapsed_compute ( ) . clone ( ) ;
10301039
@@ -1068,6 +1077,23 @@ impl ExternalSorter {
10681077 } )
10691078 }
10701079
1080+ /// Batch size of the sorted runs that feed a merge. A multi-column merge holds
1081+ /// the row-format keys of every run's current batch at once, and these keys can
1082+ /// be larger than the batches. With a memory limit, runs therefore use an eighth
1083+ /// of `batch_size`, but at least 1024 rows to keep the per-batch merge cost
1084+ /// small. The merge output still uses `batch_size`.
1085+ fn merge_run_batch_size ( & self ) -> usize {
1086+ let limited = !matches ! (
1087+ self . runtime. memory_pool. memory_limit( ) ,
1088+ MemoryLimit :: Infinite
1089+ ) ;
1090+ if limited && self . expr . len ( ) > 1 {
1091+ ( self . batch_size / 8 ) . max ( 1024 ) . min ( self . batch_size )
1092+ } else {
1093+ self . batch_size
1094+ }
1095+ }
1096+
10711097 /// If this sort may spill, pre-allocates
10721098 /// `sort_spill_reservation_bytes` of memory to guarantee memory
10731099 /// left for the in memory sort/merge.
@@ -2601,7 +2627,8 @@ mod tests {
26012627 let reservation = sorter. reservation . new_empty ( ) ;
26022628 reservation. try_grow ( get_reserved_bytes_for_record_batch ( & batch) ?) ?;
26032629 let before = elapsed_compute. value ( ) ;
2604- let sort = sorter. sort_run ( batch. clone ( ) , reservation, None ) ?;
2630+ let sort =
2631+ sorter. sort_run ( batch. clone ( ) , reservation, None , sorter. batch_size ) ?;
26052632 assert_eq ! ( elapsed_compute. value( ) , before) ;
26062633
26072634 let stream = if spawned {
0 commit comments