@@ -39,11 +39,9 @@ use std::{
3939 } ,
4040} ;
4141
42- use datafusion_common:: { Result , human_readable_size} ;
42+ use datafusion_common:: human_readable_size;
4343use parking_lot:: Mutex ;
4444
45- use super :: { MemoryConsumer , MemoryLimit , MemoryPool , MemoryReservation } ;
46-
4745/// Returns the number of bytes currently allocated by the process.
4846///
4947/// This is called on every reservation change (`grow`, `try_grow` and
@@ -55,8 +53,10 @@ pub type AllocatedBytesFn = Arc<dyn Fn() -> usize + Send + Sync>;
5553/// Default rise in drift, in bytes, needed before another line is logged.
5654pub const DEFAULT_DRIFT_LOG_THRESHOLD : usize = 64 * 1024 * 1024 ;
5755
58- /// Compares allocated bytes against the total reserved by every
59- /// [`DriftLoggingPool`] that reports to it.
56+ /// Compares allocated bytes against the total reserved by every pool that
57+ /// reports to it (see [`PeakRecordingPool::with_drift_tracker`]).
58+ ///
59+ /// [`PeakRecordingPool::with_drift_tracker`]: super::PeakRecordingPool::with_drift_tracker
6060///
6161/// A single tracker can be shared by many pools, e.g. one pool per
6262/// `SessionContext` in a process running several at once. The reserved total
@@ -72,15 +72,14 @@ pub const DEFAULT_DRIFT_LOG_THRESHOLD: usize = 64 * 1024 * 1024;
7272/// ```
7373/// # use std::sync::Arc;
7474/// # use datafusion_execution::memory_pool::{
75- /// # MemoryConsumer, MemoryDriftTracker, MemoryPool, DriftLoggingPool , UnboundedMemoryPool,
75+ /// # MemoryConsumer, MemoryDriftTracker, MemoryPool, PeakRecordingPool , UnboundedMemoryPool,
7676/// # };
7777/// // A real caller would read a counting allocator or allocator stats here.
7878/// let tracker = Arc::new(MemoryDriftTracker::new(Arc::new(|| 10_000)));
79- /// let pool: Arc<dyn MemoryPool> = Arc::new(DriftLoggingPool::new(
80- /// Arc::new(UnboundedMemoryPool::default()),
81- /// Arc::clone(&tracker),
82- /// "example",
83- /// ));
79+ /// let pool: Arc<dyn MemoryPool> = Arc::new(
80+ /// PeakRecordingPool::new(Arc::new(UnboundedMemoryPool::default()))
81+ /// .with_drift_tracker(Arc::clone(&tracker), "example"),
82+ /// );
8483///
8584/// let reservation = MemoryConsumer::new("op").register(&pool);
8685/// reservation.grow(4_000);
@@ -104,8 +103,7 @@ pub struct MemoryDriftTracker {
104103/// One observation of drift, recorded by [`MemoryDriftTracker`].
105104#[ derive( Debug , Clone , PartialEq , Eq ) ]
106105pub struct DriftSample {
107- /// Label of the [`DriftLoggingPool`] whose reservation change took this
108- /// sample, or the source passed to [`MemoryDriftTracker::sample`]. When
106+ /// Label of the pool whose reservation change took this sample, or the source passed to [`MemoryDriftTracker::sample`]. When
109107 /// several pools share a tracker, the untracked memory can come from any
110108 /// of them.
111109 pub pool : String ,
@@ -180,13 +178,13 @@ impl MemoryDriftTracker {
180178 self . observe ( source, "" , self . reserved ( ) ) ;
181179 }
182180
183- fn grew ( & self , pool : & str , consumer : & str , additional : usize ) {
181+ pub ( super ) fn grew ( & self , pool : & str , consumer : & str , additional : usize ) {
184182 let reserved =
185183 self . reserved . fetch_add ( additional, Ordering :: Relaxed ) + additional;
186184 self . observe ( pool, consumer, reserved) ;
187185 }
188186
189- fn shrank ( & self , pool : & str , consumer : & str , shrink : usize ) {
187+ pub ( super ) fn shrank ( & self , pool : & str , consumer : & str , shrink : usize ) {
190188 let reserved = self . reserved . fetch_sub ( shrink, Ordering :: Relaxed ) - shrink;
191189 self . observe ( pool, consumer, reserved) ;
192190 }
@@ -218,7 +216,7 @@ impl MemoryDriftTracker {
218216 // lowers the baseline so the next rise is seen.
219217 let untracked = drift. max ( 0 ) ;
220218 let last = self . last_logged . load ( Ordering :: Relaxed ) ;
221- let rose = untracked >= last. saturating_add ( self . log_threshold as isize ) ;
219+ let rose = untracked >= last. saturating_add_unsigned ( self . log_threshold ) ;
222220 if !rose && untracked >= last {
223221 return false ;
224222 }
@@ -244,126 +242,34 @@ impl Debug for MemoryDriftTracker {
244242 }
245243}
246244
247- /// Wraps a [`MemoryPool`], reporting every reservation change to a
248- /// [`MemoryDriftTracker`].
249- ///
250- /// Every method delegates to the wrapped pool, so wrapping does not change how
251- /// memory is granted, limited, or reported. As with other wrappers,
252- /// downcasting the pool finds this wrapper rather than the pool it wraps.
253- pub struct DriftLoggingPool {
254- inner : Arc < dyn MemoryPool > ,
255- tracker : Arc < MemoryDriftTracker > ,
256- label : String ,
257- }
258-
259- impl DriftLoggingPool {
260- /// Wrap `inner`, reporting to `tracker`. `label` identifies this pool in
261- /// log lines, which matters when several pools share one tracker.
262- ///
263- /// `inner` is expected to be empty: anything reserved before wrapping is
264- /// not counted.
265- pub fn new (
266- inner : Arc < dyn MemoryPool > ,
267- tracker : Arc < MemoryDriftTracker > ,
268- label : impl Into < String > ,
269- ) -> Self {
270- Self {
271- inner,
272- tracker,
273- label : label. into ( ) ,
274- }
275- }
276-
277- /// The tracker this pool reports to.
278- pub fn tracker ( & self ) -> & Arc < MemoryDriftTracker > {
279- & self . tracker
280- }
281- }
282-
283- impl Debug for DriftLoggingPool {
284- fn fmt ( & self , f : & mut Formatter < ' _ > ) -> std:: fmt:: Result {
285- f. debug_struct ( "DriftLoggingPool" )
286- . field ( "inner" , & self . inner )
287- . field ( "label" , & self . label )
288- . finish ( )
289- }
290- }
291-
292- impl Display for DriftLoggingPool {
293- fn fmt ( & self , f : & mut Formatter < ' _ > ) -> std:: fmt:: Result {
294- // Keep output identical to running without the wrapper.
295- Display :: fmt ( & self . inner , f)
296- }
297- }
298-
299- impl MemoryPool for DriftLoggingPool {
300- fn name ( & self ) -> & str {
301- self . inner . name ( )
302- }
303-
304- fn register ( & self , consumer : & MemoryConsumer ) {
305- self . inner . register ( consumer) ;
306- }
307-
308- fn unregister ( & self , consumer : & MemoryConsumer ) {
309- self . inner . unregister ( consumer) ;
310- }
311-
312- fn grow ( & self , reservation : & MemoryReservation , additional : usize ) {
313- self . inner . grow ( reservation, additional) ;
314- self . tracker
315- . grew ( & self . label , reservation. consumer ( ) . name ( ) , additional) ;
316- }
317-
318- fn shrink ( & self , reservation : & MemoryReservation , shrink : usize ) {
319- self . inner . shrink ( reservation, shrink) ;
320- self . tracker
321- . shrank ( & self . label , reservation. consumer ( ) . name ( ) , shrink) ;
322- }
323-
324- fn try_grow ( & self , reservation : & MemoryReservation , additional : usize ) -> Result < ( ) > {
325- self . inner . try_grow ( reservation, additional) ?;
326- self . tracker
327- . grew ( & self . label , reservation. consumer ( ) . name ( ) , additional) ;
328- Ok ( ( ) )
329- }
330-
331- fn reserved ( & self ) -> usize {
332- self . inner . reserved ( )
333- }
334-
335- fn memory_limit ( & self ) -> MemoryLimit {
336- self . inner . memory_limit ( )
337- }
338- }
339-
340245#[ cfg( test) ]
341246mod tests {
342- use crate :: memory_pool:: { GreedyMemoryPool , UnboundedMemoryPool } ;
247+ use crate :: memory_pool:: {
248+ MemoryConsumer , MemoryPool , PeakRecordingPool , UnboundedMemoryPool ,
249+ } ;
343250
344251 use super :: * ;
345252
346253 /// A tracker whose allocated byte count is set by the test.
347- fn tracker ( ) -> ( Arc < AtomicUsize > , Arc < MemoryDriftTracker > ) {
254+ fn tracker ( log_threshold : usize ) -> ( Arc < AtomicUsize > , Arc < MemoryDriftTracker > ) {
348255 let allocated = Arc :: new ( AtomicUsize :: new ( 0 ) ) ;
349256 let source = Arc :: clone ( & allocated) ;
350- let tracker = Arc :: new ( MemoryDriftTracker :: new ( Arc :: new ( move || {
351- source. load ( Ordering :: Relaxed )
352- } ) ) ) ;
353- ( allocated, tracker)
257+ let tracker =
258+ MemoryDriftTracker :: new ( Arc :: new ( move || source. load ( Ordering :: Relaxed ) ) )
259+ . with_log_threshold ( log_threshold ) ;
260+ ( allocated, Arc :: new ( tracker) )
354261 }
355262
356263 fn pool ( tracker : & Arc < MemoryDriftTracker > , label : & str ) -> Arc < dyn MemoryPool > {
357- Arc :: new ( DriftLoggingPool :: new (
358- Arc :: new ( UnboundedMemoryPool :: default ( ) ) ,
359- Arc :: clone ( tracker) ,
360- label,
361- ) )
264+ Arc :: new (
265+ PeakRecordingPool :: new ( Arc :: new ( UnboundedMemoryPool :: default ( ) ) )
266+ . with_drift_tracker ( Arc :: clone ( tracker) , label) ,
267+ )
362268 }
363269
364270 #[ test]
365271 fn records_peak_drift_and_where_it_happened ( ) {
366- let ( allocated, tracker) = tracker ( ) ;
272+ let ( allocated, tracker) = tracker ( DEFAULT_DRIFT_LOG_THRESHOLD ) ;
367273 let pool = pool ( & tracker, "q1" ) ;
368274
369275 let a = MemoryConsumer :: new ( "a" ) . register ( & pool) ;
@@ -391,7 +297,7 @@ mod tests {
391297
392298 #[ test]
393299 fn sums_reservations_across_pools_sharing_a_tracker ( ) {
394- let ( allocated, tracker) = tracker ( ) ;
300+ let ( allocated, tracker) = tracker ( DEFAULT_DRIFT_LOG_THRESHOLD ) ;
395301 let one = pool ( & tracker, "one" ) ;
396302 let two = pool ( & tracker, "two" ) ;
397303
@@ -413,25 +319,9 @@ mod tests {
413319 assert_eq ! ( tracker. reserved( ) , 0 ) ;
414320 }
415321
416- #[ test]
417- fn failed_growth_is_not_counted ( ) {
418- let ( _allocated, tracker) = tracker ( ) ;
419- let pool: Arc < dyn MemoryPool > = Arc :: new ( DriftLoggingPool :: new (
420- Arc :: new ( GreedyMemoryPool :: new ( 1024 ) ) ,
421- Arc :: clone ( & tracker) ,
422- "limited" ,
423- ) ) ;
424-
425- let reservation = MemoryConsumer :: new ( "a" ) . register ( & pool) ;
426- reservation. try_grow ( 600 ) . unwrap ( ) ;
427- reservation. try_grow ( 600 ) . unwrap_err ( ) ;
428-
429- assert_eq ! ( tracker. reserved( ) , 600 ) ;
430- }
431-
432322 #[ test]
433323 fn drift_can_be_negative ( ) {
434- let ( _allocated, tracker) = tracker ( ) ;
324+ let ( _allocated, tracker) = tracker ( DEFAULT_DRIFT_LOG_THRESHOLD ) ;
435325 let pool = pool ( & tracker, "over-reserved" ) ;
436326
437327 let reservation = MemoryConsumer :: new ( "a" ) . register ( & pool) ;
@@ -447,44 +337,38 @@ mod tests {
447337
448338 #[ test]
449339 fn logs_each_rise_by_the_threshold_and_rearms_after_a_fall ( ) {
450- let allocated = Arc :: new ( AtomicUsize :: new ( 0 ) ) ;
451- let source = Arc :: clone ( & allocated) ;
452- let tracker =
453- MemoryDriftTracker :: new ( Arc :: new ( move || source. load ( Ordering :: Relaxed ) ) )
454- . with_log_threshold ( 1000 ) ;
455- let observe = |bytes : usize | {
340+ let ( allocated, tracker) = tracker ( 1000 ) ;
341+ let observe = |bytes : usize , reserved : usize | {
456342 allocated. store ( bytes, Ordering :: Relaxed ) ;
457- tracker. observe ( "p" , "c" , 0 )
343+ tracker. observe ( "p" , "c" , reserved )
458344 } ;
459345
346+ // Negative drift counts as zero, so the baseline stays at zero.
347+ assert ! ( !observe( 0 , 5000 ) ) ;
460348 // Below the threshold: nothing logged.
461- assert ! ( !observe( 999 ) ) ;
349+ assert ! ( !observe( 999 , 0 ) ) ;
462350 // Reaching the threshold logs and moves the baseline to 1000.
463- assert ! ( observe( 1000 ) ) ;
464- assert ! ( !observe( 1999 ) ) ;
465- assert ! ( observe( 2000 ) ) ;
351+ assert ! ( observe( 1000 , 0 ) ) ;
352+ assert ! ( !observe( 1999 , 0 ) ) ;
353+ assert ! ( observe( 2000 , 0 ) ) ;
466354 // Falling drift is not logged but lowers the baseline to 500...
467- assert ! ( !observe( 500 ) ) ;
355+ assert ! ( !observe( 500 , 0 ) ) ;
468356 // ...so a rise of the threshold from there logs again.
469- assert ! ( !observe( 1499 ) ) ;
470- assert ! ( observe( 1500 ) ) ;
357+ assert ! ( !observe( 1499 , 0 ) ) ;
358+ assert ! ( observe( 1500 , 0 ) ) ;
471359 }
472360
473361 #[ test]
474- fn negative_drift_counts_as_zero_for_logging ( ) {
475- let ( allocated, tracker) = tracker ( ) ;
476- let tracker = Arc :: into_inner ( tracker) . unwrap ( ) . with_log_threshold ( 1000 ) ;
362+ fn a_threshold_above_isize_max_never_logs ( ) {
363+ let ( allocated, tracker) = tracker ( usize:: MAX ) ;
477364
478- assert ! ( !tracker. observe( "p" , "c" , 5000 ) ) ;
479- allocated. store ( 999 , Ordering :: Relaxed ) ;
365+ allocated. store ( 1 << 40 , Ordering :: Relaxed ) ;
480366 assert ! ( !tracker. observe( "p" , "c" , 0 ) ) ;
481- allocated. store ( 1000 , Ordering :: Relaxed ) ;
482- assert ! ( tracker. observe( "p" , "c" , 0 ) ) ;
483367 }
484368
485369 #[ test]
486370 fn sample_observes_without_a_reservation_change ( ) {
487- let ( allocated, tracker) = tracker ( ) ;
371+ let ( allocated, tracker) = tracker ( DEFAULT_DRIFT_LOG_THRESHOLD ) ;
488372 let pool = pool ( & tracker, "q1" ) ;
489373 let reservation = MemoryConsumer :: new ( "a" ) . register ( & pool) ;
490374 reservation. grow ( 100 ) ;
@@ -503,15 +387,4 @@ mod tests {
503387 } )
504388 ) ;
505389 }
506-
507- #[ test]
508- fn delegates_to_the_wrapped_pool ( ) {
509- let ( _allocated, tracker) = tracker ( ) ;
510- let inner: Arc < dyn MemoryPool > = Arc :: new ( GreedyMemoryPool :: new ( 4096 ) ) ;
511- let wrapped = DriftLoggingPool :: new ( Arc :: clone ( & inner) , tracker, "x" ) ;
512-
513- assert_eq ! ( wrapped. name( ) , inner. name( ) ) ;
514- assert_eq ! ( wrapped. to_string( ) , inner. to_string( ) ) ;
515- assert ! ( matches!( wrapped. memory_limit( ) , MemoryLimit :: Finite ( 4096 ) ) ) ;
516- }
517390}
0 commit comments