Skip to content

Commit f79c1f9

Browse files
committed
refactor: report memory drift from PeakRecordingPool instead of a new wrapper
- Replace DriftLoggingPool with PeakRecordingPool::with_drift_tracker - Use saturating_add_unsigned so thresholds above isize::MAX never log - Flush per-thread allocation counts from tokio's on_thread_stop hook and count from process start - Re-wrap the pool after SET in the substrait round-trip engine too - Drop the unused allocated_bytes export and CountingAllocator's type parameter, and consolidate the drift tests - Fix the --memory-drift help text
1 parent 956f9a0 commit f79c1f9

7 files changed

Lines changed: 122 additions & 222 deletions

File tree

‎datafusion/execution/src/memory_pool/drift.rs‎

Lines changed: 45 additions & 172 deletions
Original file line numberDiff line numberDiff line change
@@ -39,11 +39,9 @@ use std::{
3939
},
4040
};
4141

42-
use datafusion_common::{Result, human_readable_size};
42+
use datafusion_common::human_readable_size;
4343
use 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.
5654
pub 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)]
106105
pub 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)]
341246
mod 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

Comments
 (0)