#![cfg(all(feature = "std", feature = "watermark"))]
use std::{
collections::HashMap,
hint::black_box,
sync::{Arc, Barrier, mpsc},
thread,
};
const THREADS: usize = 8;
const FRAME: usize = 8 * 1024;
const STACK_SIZE: usize = 4 * 1024 * 1024;
#[inline(never)]
fn recurse(levels: usize) {
let mut frame = [0u8; FRAME];
black_box(&mut frame);
if levels > 0 {
recurse(levels - 1);
}
}
#[test]
fn threads_of_known_depth() {
stackler::Stackler::new().paint_depth(1024 * 1024).install();
stackler::reset();
let baseline = stackler::stats();
let barrier = Arc::new(Barrier::new(THREADS + 1));
let (tx, rx) = mpsc::channel();
let workers: Vec<_> = (0..THREADS)
.map(|i| {
let barrier = Arc::clone(&barrier);
let tx = tx.clone();
thread::Builder::new()
.stack_size(STACK_SIZE)
.spawn(move || {
let levels = i + 1;
let expected = levels * FRAME;
assert!(stackler::attach());
let base = stackler::current_stack().unwrap().base();
let (_, peak) = stackler::measure_peak(|| recurse(levels));
let peak = peak.unwrap();
assert!(peak.bytes() >= expected, "{i}: {peak:?} < {expected}");
assert!(!peak.is_saturated(), "{i}: {peak:?}");
tx.send((base, expected)).unwrap();
barrier.wait();
})
.unwrap()
})
.collect();
drop(tx);
let expectations: HashMap<usize, usize> = rx.iter().take(THREADS).collect();
assert_eq!(expectations.len(), THREADS);
stackler::poll_all();
let threads = stackler::threads();
let stats = stackler::stats();
let mut matched = 0;
let mut peak_max = 0;
let mut reserved_sum = 0;
for thread in &threads {
reserved_sum += thread.size as u64;
peak_max = peak_max.max(thread.peak);
if let Some(expected) = expectations.get(&thread.base) {
matched += 1;
assert!(
thread.peak >= *expected,
"{thread:?}: peak below the {expected} bytes it recursed through"
);
assert!(thread.peak < *expected + 64 * 1024, "{thread:?}");
assert!(thread.size.abs_diff(STACK_SIZE) <= 4096, "{thread:?}");
assert!(!thread.saturated, "{thread:?}");
}
}
assert_eq!(matched, THREADS, "every worker is in the registry");
assert_eq!(stats.threads_live, threads.len() as u64);
assert_eq!(stats.threads_live, baseline.threads_live + THREADS as u64);
assert_eq!(stats.threads_seen, baseline.threads_seen + THREADS as u64);
assert_eq!(stats.reserved_sum, reserved_sum);
assert_eq!(stats.peak_max, peak_max);
assert_eq!(stats.untracked, 0);
assert_eq!(stats.saturated_count, 0);
assert!(stats.peak_max >= THREADS * FRAME);
assert!(stats.reserved_sum > stats.peak_sum);
assert_eq!(stats.waste(), stats.reserved_sum - stats.peak_sum);
assert!(stats.utilization().unwrap() < 0.5);
barrier.wait();
for worker in workers {
worker.join().unwrap();
}
let after = stackler::stats();
assert_eq!(after.threads_live, baseline.threads_live);
assert_eq!(after.threads_seen, stats.threads_seen);
assert_eq!(after.peak_max, stats.peak_max);
assert!(after.reserved_sum < stats.reserved_sum);
}
#[test]
fn slots_are_recycled() {
stackler::reset();
let baseline = stackler::stats().threads_live;
for _ in 0..(stackler::MAX_THREADS / 4 + 3) {
let batch: Vec<_> = (0..4)
.map(|_| thread::spawn(|| assert!(stackler::attach())))
.collect();
for thread in batch {
thread.join().unwrap();
}
}
let stats = stackler::stats();
assert_eq!(stats.threads_live, baseline);
assert!(stats.threads_seen > stackler::MAX_THREADS as u64);
assert_eq!(stats.untracked, 0, "a recycled slot was not handed back");
}
#[test]
fn registry_reports_what_it_cannot_track() {
stackler::attach();
stackler::reset();
let baseline = stackler::stats().threads_live;
let overflow = stackler::MAX_THREADS + 8;
let barrier = Arc::new(Barrier::new(overflow + 1));
let hold = Arc::new(Barrier::new(overflow + 1));
let (tx, rx) = mpsc::channel();
let squatters: Vec<_> = (0..overflow)
.map(|_| {
let (barrier, hold, tx) = (Arc::clone(&barrier), Arc::clone(&hold), tx.clone());
thread::Builder::new()
.stack_size(128 * 1024)
.spawn(move || {
tx.send(stackler::attach()).unwrap();
barrier.wait();
hold.wait();
})
.unwrap()
})
.collect();
drop(tx);
let attached = rx.iter().take(overflow).filter(|ok| *ok).count();
barrier.wait();
let stats = stackler::stats();
assert_eq!(attached as u64 + baseline, stats.threads_live);
assert!(
attached < overflow,
"the registry is not supposed to be unbounded"
);
assert_eq!(
stats.untracked,
(overflow - attached) as u64,
"threads that missed out are counted"
);
hold.wait();
for squatter in squatters {
squatter.join().unwrap();
}
}
#[test]
#[cfg(feature = "sampler")]
fn churn_under_a_sampler() {
use std::sync::atomic::{AtomicBool, Ordering};
const CHURNERS: usize = 6;
const RUN: std::time::Duration = std::time::Duration::from_millis(750);
stackler::Stackler::new().paint_depth(64 * 1024).install();
let sampler = stackler::sampler::spawn(std::time::Duration::from_micros(500)).unwrap();
let stop = Arc::new(AtomicBool::new(false));
let churners: Vec<_> = (0..CHURNERS)
.map(|i| {
let stop = Arc::clone(&stop);
thread::spawn(move || {
let mut spawned = 0u64;
while !stop.load(Ordering::Relaxed) {
thread::Builder::new()
.stack_size(256 * 1024)
.spawn(move || {
recurse(i);
stackler::sample();
if i % 2 == 0 {
stackler::peak();
}
})
.unwrap()
.join()
.unwrap();
spawned += 1;
}
spawned
})
})
.collect();
let reader = {
let stop = Arc::clone(&stop);
thread::spawn(move || {
let mut snapshots = 0u64;
while !stop.load(Ordering::Relaxed) {
let threads = stackler::threads();
let stats = stackler::stats();
for thread in &threads {
assert_eq!(thread.size, thread.base - thread.limit, "{thread:?}");
assert!(
thread.size >= 4096 && thread.size <= 1024 * 1024 * 1024,
"implausible stack: {thread:?}"
);
assert!(thread.peak <= thread.size, "peak past the end: {thread:?}");
assert!(
thread.peak >= thread.depth_last,
"peak below a depth it recorded: {thread:?}"
);
}
assert!(stats.threads_live <= stackler::MAX_THREADS as u64);
assert!(threads.len() <= stackler::MAX_THREADS);
assert!(stats.threads_live >= 1 && !threads.is_empty());
assert!(stats.threads_seen >= stats.threads_live);
assert!(stats.reserved_sum >= stats.peak_sum);
assert_eq!(stats.untracked, 0, "a thread went untracked");
if let Some(avg) = stats.sample_avg {
assert!(
avg <= stats.peak_max,
"avg {avg} over max {}",
stats.peak_max
);
}
snapshots += 1;
}
snapshots
})
};
thread::sleep(RUN);
stop.store(true, Ordering::Relaxed);
let spawned: u64 = churners.into_iter().map(|c| c.join().unwrap()).sum();
let snapshots = reader.join().unwrap();
sampler.stop();
assert!(spawned > 100, "only {spawned} threads came and went");
assert!(snapshots > 100, "only {snapshots} snapshots were taken");
}