@@ -73,15 +73,9 @@ impl Display for UnboundedMemoryPool {
7373/// This pool works well for queries that do not need to spill or have
7474/// a single spillable operator. See [`FairSpillPool`] if there are
7575/// multiple spillable operators that all will spill.
76- ///
77- /// Supports [`MemoryPool::try_resize`] for in-place limit adjustment, so
78- /// callers routing through
79- /// [`RuntimeEnvBuilder::with_memory_limit`](crate::runtime_env::RuntimeEnvBuilder::with_memory_limit)
80- /// can keep the existing pool (and any wrappers around it) rather than
81- /// replacing it on every change.
8276#[ derive( Debug ) ]
8377pub struct GreedyMemoryPool {
84- pool_size : AtomicUsize ,
78+ pool_size : usize ,
8579 used : AtomicUsize ,
8680}
8781
@@ -90,7 +84,7 @@ impl GreedyMemoryPool {
9084 pub fn new ( pool_size : usize ) -> Self {
9185 debug ! ( "Created new GreedyMemoryPool(pool_size={pool_size})" ) ;
9286 Self {
93- pool_size : AtomicUsize :: new ( pool_size ) ,
87+ pool_size,
9488 used : AtomicUsize :: new ( 0 ) ,
9589 }
9690 }
@@ -110,17 +104,16 @@ impl MemoryPool for GreedyMemoryPool {
110104 }
111105
112106 fn try_grow ( & self , reservation : & MemoryReservation , additional : usize ) -> Result < ( ) > {
113- let pool_size = self . pool_size . load ( Ordering :: Relaxed ) ;
114107 self . used
115108 . fetch_update ( Ordering :: Relaxed , Ordering :: Relaxed , |used| {
116109 let new_used = used + additional;
117- ( new_used <= pool_size) . then_some ( new_used)
110+ ( new_used <= self . pool_size ) . then_some ( new_used)
118111 } )
119112 . map_err ( |used| {
120113 insufficient_capacity_err (
121114 reservation,
122115 additional,
123- pool_size. saturating_sub ( used) ,
116+ self . pool_size . saturating_sub ( used) ,
124117 self ,
125118 )
126119 } ) ?;
@@ -132,25 +125,19 @@ impl MemoryPool for GreedyMemoryPool {
132125 }
133126
134127 fn memory_limit ( & self ) -> MemoryLimit {
135- MemoryLimit :: Finite ( self . pool_size . load ( Ordering :: Relaxed ) )
136- }
137-
138- fn try_resize ( & self , new_limit : usize ) -> Result < ( ) > {
139- self . pool_size . store ( new_limit, Ordering :: Relaxed ) ;
140- Ok ( ( ) )
128+ MemoryLimit :: Finite ( self . pool_size )
141129 }
142130}
143131
144132impl Display for GreedyMemoryPool {
145133 fn fmt ( & self , f : & mut Formatter < ' _ > ) -> std:: fmt:: Result {
146134 let used = self . used . load ( Ordering :: Relaxed ) ;
147- let pool_size = self . pool_size . load ( Ordering :: Relaxed ) ;
148135 write ! (
149136 f,
150137 "{}(used: {}, pool_size: {})" ,
151138 & self . name( ) ,
152139 human_readable_size( used) ,
153- human_readable_size( pool_size)
140+ human_readable_size( self . pool_size)
154141 )
155142 }
156143}
@@ -613,10 +600,6 @@ impl<I: MemoryPool> MemoryPool for TrackConsumersPool<I> {
613600 fn memory_limit ( & self ) -> MemoryLimit {
614601 self . inner . memory_limit ( )
615602 }
616-
617- fn try_resize ( & self , new_limit : usize ) -> Result < ( ) > {
618- self . inner . try_resize ( new_limit)
619- }
620603}
621604
622605fn provide_top_memory_consumers_to_error_msg (
@@ -1063,43 +1046,4 @@ mod tests {
10631046 "TrackConsumersPool<UnboundedMemoryPool> Display"
10641047 ) ;
10651048 }
1066-
1067- #[ test]
1068- fn test_greedy_try_resize_in_place ( ) {
1069- let pool: Arc < dyn MemoryPool > = Arc :: new ( GreedyMemoryPool :: new ( 100 ) ) ;
1070- let r = MemoryConsumer :: new ( "r" ) . register ( & pool) ;
1071-
1072- // Fill the pool, then verify it rejects further growth.
1073- r. try_grow ( 100 ) . unwrap ( ) ;
1074- r. try_grow ( 1 ) . unwrap_err ( ) ;
1075-
1076- // Resize *up*: previously-rejected growth now succeeds.
1077- pool. try_resize ( 200 ) . unwrap ( ) ;
1078- assert ! ( matches!( pool. memory_limit( ) , MemoryLimit :: Finite ( 200 ) ) ) ;
1079- r. try_grow ( 50 ) . unwrap ( ) ;
1080- assert_eq ! ( pool. reserved( ) , 150 ) ;
1081-
1082- // Resize *down* below current usage: subsequent grows fail because
1083- // reserved (150) already exceeds the new limit (120). Already-issued
1084- // reservations are not retroactively shrunk.
1085- pool. try_resize ( 120 ) . unwrap ( ) ;
1086- assert ! ( matches!( pool. memory_limit( ) , MemoryLimit :: Finite ( 120 ) ) ) ;
1087- r. try_grow ( 1 ) . unwrap_err ( ) ;
1088- }
1089-
1090- #[ test]
1091- fn test_track_consumers_try_resize_forwards ( ) {
1092- let pool: Arc < dyn MemoryPool > = Arc :: new ( TrackConsumersPool :: new (
1093- GreedyMemoryPool :: new ( 100 ) ,
1094- NonZeroUsize :: new ( 3 ) . unwrap ( ) ,
1095- ) ) ;
1096- pool. try_resize ( 500 ) . unwrap ( ) ;
1097- assert ! ( matches!( pool. memory_limit( ) , MemoryLimit :: Finite ( 500 ) ) ) ;
1098- }
1099-
1100- #[ test]
1101- fn test_unbounded_try_resize_returns_err ( ) {
1102- let pool: Arc < dyn MemoryPool > = Arc :: new ( UnboundedMemoryPool :: default ( ) ) ;
1103- assert ! ( pool. try_resize( 100 ) . is_err( ) ) ;
1104- }
11051049}
0 commit comments