#![cfg(feature = "std")]
use std::hint::black_box;
use stackler::Stack;
#[inline(never)]
#[allow(dead_code)] fn burn_stack(bytes: usize) {
let mut frame = [0u8; 64 * 1024];
black_box(&mut frame[..bytes]);
}
#[test]
fn discovers_its_own_stack() {
let stack = Stack::current().expect("stack bounds are discoverable on this platform");
assert!(stack.size() > 0);
assert!(stack.contains(stackler::sp()));
assert_eq!(stack.base() - stack.limit(), stack.size());
let sp = stackler::sp();
assert_eq!(
stack.depth_at(sp).unwrap() + stack.headroom_at(sp).unwrap(),
stack.size()
);
assert!(stack.depth().unwrap() > 0);
assert!(stack.headroom().unwrap() > 0);
}
#[test]
fn bounds_are_validated() {
assert!(Stack::from_bounds(0x2000, 0x1000).is_none()); assert!(Stack::from_bounds(0x1000, 0x1000).is_none()); assert!(Stack::from_limit_and_size(0x1000, 0).is_none()); assert!(Stack::from_limit_and_size(usize::MAX, 2).is_none());
let stack = Stack::from_limit_and_size(0x1000, 0x1000).unwrap();
assert_eq!(stack.base(), 0x2000);
assert_eq!(stack.size(), 0x1000);
assert!(stack.contains(0x1000));
assert!(!stack.contains(0x2000)); assert_eq!(stack.depth_at(0x1800), Some(0x800));
assert_eq!(stack.depth_at(0x800), None); }
#[test]
fn depth_grows_with_recursion() {
#[inline(never)]
fn recurse(remaining: usize, depths: &mut Vec<usize>) {
let mut frame = [0u8; 1024];
black_box(&mut frame);
depths.push(stackler::depth().expect("this thread is tracked"));
if remaining > 0 {
recurse(remaining - 1, depths);
}
}
let mut depths = Vec::new();
recurse(8, &mut depths);
for step in depths.windows(2) {
assert!(step[1] > step[0], "{depths:?}");
}
assert!(
depths.last().unwrap() - depths.first().unwrap() >= 8 * 1024,
"{depths:?}"
);
}
#[test]
fn headroom_shrinks_as_depth_grows() {
let (depth, headroom) = (stackler::depth().unwrap(), stackler::headroom().unwrap());
#[inline(never)]
fn deeper() -> (usize, usize) {
let mut frame = [0u8; 4096];
black_box(&mut frame);
(stackler::depth().unwrap(), stackler::headroom().unwrap())
}
let (deep_depth, deep_headroom) = deeper();
assert!(deep_depth > depth);
assert!(deep_headroom < headroom);
assert_eq!(depth + headroom, deep_depth + deep_headroom);
}
#[test]
fn guard_answers_and_counts() {
stackler::reset();
assert!(stackler::has_headroom(1024));
assert_eq!(stackler::stats().guard_trip_count, 0);
assert!(!stackler::has_headroom(usize::MAX));
assert_eq!(stackler::stats().guard_trip_count, 1);
assert!(!stackler::has_headroom(usize::MAX));
assert_eq!(stackler::stats().guard_trip_count, 2);
}
#[test]
fn sampling_feeds_the_aggregates() {
stackler::reset();
let sampled = stackler::sample().expect("this thread is tracked");
let stats = stackler::stats();
assert_eq!(stats.sample_count, 1);
assert_eq!(stats.sample_sum, sampled as u64);
assert_eq!(stats.sample_avg, Some(sampled));
assert!(stats.peak_max >= sampled);
assert!(stats.threads_live >= 1);
assert!(stats.reserved_sum >= stats.peak_sum);
assert_eq!(stats.untracked, 0);
#[inline(never)]
fn sample_deeper() -> usize {
let mut frame = [0u8; 8192];
black_box(&mut frame);
stackler::sample().unwrap()
}
let deeper = sample_deeper();
assert!(deeper > sampled);
let stats = stackler::stats();
assert_eq!(stats.sample_count, 2);
assert!(stats.peak_max >= deeper);
}
#[test]
fn stats_subtraction() {
stackler::reset();
let before = stackler::stats();
stackler::sample();
let after = stackler::stats();
let diff = &after - &before;
assert_eq!(diff.sample_count, 1);
assert_eq!(diff.threads_live, after.threads_live);
assert_eq!(diff.reserved_sum, after.reserved_sum);
let weird = &before - &after;
assert_eq!(weird.sample_count, 0);
}
#[test]
fn measure_diffs_counters() {
stackler::reset();
stackler::sample();
let (result, stats) = stackler::measure(|| {
stackler::sample();
stackler::sample();
42
});
assert_eq!(result, 42);
assert_eq!(stats.sample_count, 2);
}
#[test]
fn threads_come_and_go() {
stackler::reset();
stackler::attach();
let before = stackler::stats();
std::thread::spawn(|| {
stackler::sample().expect("a spawned thread is tracked too");
let mine = stackler::current_stack().unwrap();
assert!(mine.contains(stackler::sp()));
})
.join()
.unwrap();
let after = stackler::stats();
assert_eq!(after.threads_seen, before.threads_seen + 1);
assert_eq!(after.threads_live, before.threads_live);
assert!(after.sample_count > before.sample_count);
}
#[test]
fn thread_snapshots_describe_this_thread() {
stackler::attach();
stackler::sample();
let me = stackler::sp();
let mine = stackler::threads()
.into_iter()
.find(|thread| thread.stack().is_some_and(|stack| stack.contains(me)))
.expect("this thread appears in the registry");
assert_eq!(mine.size, mine.base - mine.limit);
assert!(mine.depth_last > 0);
assert!(mine.peak >= mine.depth_last);
assert!(mine.sample_count >= 1);
assert!(mine.utilization().unwrap() > 0.0);
}
#[test]
#[cfg(feature = "watermark")]
fn measure_peak_sees_a_deep_frame() {
let (_, peak) = stackler::measure_peak(|| burn_stack(32 * 1024));
let peak = peak.expect("this thread's stack can be painted");
assert!(!peak.is_saturated(), "{peak:?}");
assert!(peak.bytes() >= 32 * 1024, "{peak:?}");
assert!(peak.bytes() < 96 * 1024, "{peak:?}");
}
#[test]
#[cfg(feature = "watermark")]
fn measure_peak_of_a_shallow_operation_is_quiet() {
let (result, peak) = stackler::measure_peak(|| 42);
assert_eq!(result, 42);
let peak = peak.unwrap();
assert!(peak.bytes() < 4096, "{peak:?}");
}
#[test]
#[cfg(feature = "watermark")]
fn measure_peak_saturates_instead_of_lying() {
stackler::Stackler::new().paint_depth(4096).install();
let (_, peak) = stackler::measure_peak(|| burn_stack(32 * 1024));
let peak = peak.expect("this thread's stack can be painted");
assert!(peak.is_saturated(), "{peak:?}");
stackler::Stackler::new().install();
}
#[test]
#[cfg(feature = "watermark")]
fn watermark_outlives_the_operation() {
stackler::repaint().expect("this thread's stack can be painted");
burn_stack(24 * 1024);
let peak = stackler::peak().expect("a painted thread has a watermark");
assert!(peak.bytes() >= 24 * 1024, "{peak:?}");
burn_stack(1024);
let again = stackler::peak().unwrap();
assert!(again.bytes() >= peak.bytes());
}
#[test]
#[cfg(feature = "watermark")]
fn polling_reads_the_watermark_of_another_thread() {
use std::sync::mpsc;
stackler::reset();
let (deep_tx, deep_rx) = mpsc::channel();
let (done_tx, done_rx) = mpsc::channel();
let worker = std::thread::spawn(move || {
stackler::attach();
burn_stack(48 * 1024);
deep_tx.send(()).unwrap();
done_rx.recv().unwrap();
});
deep_rx.recv().unwrap();
stackler::poll_all();
let deepest = stackler::threads()
.into_iter()
.map(|thread| thread.peak)
.max()
.unwrap_or(0);
assert!(deepest >= 48 * 1024, "{deepest}");
done_tx.send(()).unwrap();
worker.join().unwrap();
assert!(stackler::stats().peak_max >= 48 * 1024);
}
#[test]
#[cfg(feature = "watermark")]
fn painting_is_bounded_by_the_stack() {
let stack = Stack::current().unwrap();
let paint = unsafe { stack.paint(usize::MAX) }.expect("a whole stack can be painted");
assert!(paint.bytes() <= stack.size());
assert!(paint.lo() >= stack.limit());
assert!(paint.hi() < stack.base());
assert!(paint.hi() < stackler::sp());
assert_eq!(paint.bytes() % size_of::<usize>(), 0);
assert_eq!(
stackler::Paint::from_bounds(paint.lo(), paint.hi()),
Some(paint)
);
assert!(stackler::Paint::from_bounds(paint.hi(), paint.lo()).is_none()); assert!(stackler::Paint::from_bounds(paint.lo() + 1, paint.hi()).is_none()); }
#[test]
#[cfg(feature = "histograms")]
fn histogram_quantile() {
use stackler::Histogram;
let empty = Histogram::default();
assert!(empty.is_empty());
assert_eq!(empty.total(), 0);
assert_eq!(empty.quantile(0.5), None);
let mut buckets = [0u64; 64];
buckets[5] = 10; let histogram = Histogram::from_buckets(buckets);
assert_eq!(histogram.quantile(-0.1), None);
assert_eq!(histogram.quantile(1.1), None);
let q50 = histogram.quantile(0.5).unwrap();
assert!((32..64).contains(&q50));
let q10 = histogram.quantile(0.1).unwrap();
let q90 = histogram.quantile(0.9).unwrap();
assert!(q10 <= q50 && q50 <= q90);
}
#[test]
#[cfg(feature = "histograms")]
fn depth_histogram_tracks_samples() {
stackler::reset();
let depth = stackler::sample().unwrap();
let histogram = stackler::stats().depth_histogram;
assert_eq!(histogram.total(), 1);
let quantile = histogram.quantile(1.0).unwrap();
assert!(quantile <= depth && depth < quantile.next_power_of_two().max(2) * 2);
}
#[test]
#[cfg(feature = "histograms")]
fn histogram_outlives_the_threads_it_describes() {
stackler::reset();
let before = stackler::stats();
assert_eq!(before.depth_histogram.total(), before.sample_count);
std::thread::spawn(|| {
for _ in 0..10 {
stackler::sample().expect("tracked");
}
})
.join()
.unwrap();
let after = stackler::stats();
assert_eq!(after.sample_count, before.sample_count + 10);
assert_eq!(
after.depth_histogram.total(),
after.sample_count,
"every observation is in exactly one bucket, whether its thread is alive or not"
);
stackler::sample();
let after = stackler::stats();
assert_eq!(after.depth_histogram.total(), after.sample_count);
}
#[test]
#[cfg(all(feature = "histograms", feature = "serde"))]
fn serde_roundtrip() {
use stackler::Histogram;
let mut buckets = [0u64; 64];
buckets[3] = 7;
buckets[63] = 1; let histogram = Histogram::from_buckets(buckets);
let json = serde_json::to_string(&histogram).unwrap();
let restored: Histogram = serde_json::from_str(&json).unwrap();
assert_eq!(histogram.buckets(), restored.buckets());
stackler::sample();
let stats = stackler::stats();
let json = serde_json::to_string(&stats).unwrap();
let restored: stackler::Stats = serde_json::from_str(&json).unwrap();
assert_eq!(stats.sample_count, restored.sample_count);
assert_eq!(stats.peak_max, restored.peak_max);
}
#[test]
#[cfg(feature = "fmt")]
fn display_impls() {
stackler::attach();
stackler::sample();
burn_stack(16 * 1024);
stackler::sample();
println!("{}", stackler::stats());
stackler::for_each_thread(|thread| println!("{thread}"));
#[cfg(feature = "watermark")]
{
let peak = stackler::peak().unwrap();
println!("peak: {peak}");
assert!(!format!("{}", stackler::Peak::AtLeast(1024)).is_empty());
}
}
#[test]
#[cfg(feature = "sampler")]
fn background_sampler_keeps_peaks_fresh() {
use std::time::Duration;
stackler::reset();
stackler::attach();
let sampler = stackler::sampler::spawn(Duration::from_millis(5)).unwrap();
burn_stack(40 * 1024);
let deadline = std::time::Instant::now() + Duration::from_secs(5);
while stackler::stats().peak_max < 40 * 1024 {
assert!(
std::time::Instant::now() < deadline,
"the sampler never ran"
);
std::thread::sleep(Duration::from_millis(5));
}
sampler.stop();
}
#[test]
#[cfg(feature = "hook_pthread")]
fn interposed_pthread_create_registers_a_thread() {
stackler::reset();
stackler::attach();
let before = stackler::stats().threads_seen;
let seen_from_inside = std::thread::spawn(|| stackler::stats().threads_seen)
.join()
.unwrap();
assert_eq!(seen_from_inside, before + 1);
}