Fixed 0.9.4

Author: James Gober

README.md

@@ -163,7 +163,7 @@ with `cargo run --release --example bench_overhead`:
 Tier 1 comes in well under the 50 ns target from the spec
 ([`REPS.md`](REPS.md) section 6). Tier 2 is currently above the
 200 ns target in that section; closing that gap is tracked for
-v0.9.1.1. The Tier 2 path is correct and recursion-safe in the
+v0.9.6. The Tier 2 path is correct and recursion-safe in the
 current release; the optimisation is a separate, focused pass.
 
 ## Why a new allocation profiler
@@ -186,11 +186,11 @@ demand.
 | Name-claim placeholder                     | `v0.1.0`   | shipped |
 | Real `GlobalAlloc` + Tier 1 counters       | `v0.9.0`   | shipped |
 | Tier 2: inline backtrace capture           | `v0.9.1`   | shipped |
-| Tier 2 perf optimisation                   | `v0.9.1.1` | planned |
 | Symbolication for reports                  | `v0.9.2`   | shipped |
 | Tier 3: DHAT-compatible JSON output        | `v0.9.3`   | shipped |
 | dhat-rs drop-in compat surface             | `v0.9.4`   | shipped |
 | `dev-bench` swap (consumer side)           | `v0.9.5`   | planned |
+| Tier 2 perf optimisation                   | `v0.9.6`   | planned |
 | Stable API (`1.0`)                         | `v1.0.0`   | planned |
 
 The `1.0` release freezes the public API and the wire format.

dhat-heap.json

@@ -0,0 +1 @@
+{"dhatFileVersion":2,"mode":"rust-heap","verb":"Allocated","bklt":false,"bkacc":false,"bu":"byte","bsu":"bytes","bksu":"blocks","tu":"instrs","Mtu":"Minstr","tuth":0,"cmd":"C:\\Dev\\libraries\\Rust\\mod-alloc\\target\\debug\\deps\\mod_alloc-706d9fc9797ded60.exe","pid":35544,"tg":0,"te":0,"pps":[{"tb":64,"tbk":1,"eb":0,"ebk":0,"fs":[1,2,3]}],"ftbl":["[root]","0x1000: std::collections::hash::set::HashSet<T>::new::hc8018216f96c1513","0x2000: <core::slice::iter::Iter<T> as core::iter::traits::iterator::Iterator>::next::h1f41dd7f8faabf33","0x3000: core::slice::sort::stable::drift::sort::h10052e29f271759c"]}

tests/dhat_compat_surface.rs

@@ -3,11 +3,28 @@
 
 #![cfg(feature = "dhat-compat")]
 
+use std::sync::Mutex;
+
 use mod_alloc::dhat_compat::{ad_hoc_event, AdHocStats, Alloc, HeapStats, Profiler};
 
 #[global_allocator]
 static ALLOC: Alloc = Alloc;
 
+// `live_count` / `curr_blocks` is a process-wide counter shared
+// across every test in this binary. Cargo runs tests in parallel
+// by default, so a test that allocates and a test that reads the
+// counter race continuously. We serialise *every* test in this
+// file behind one mutex so the precise-relative claims about
+// `curr_blocks` in `live_block_count_rises_and_falls` are not
+// disturbed by allocations from sibling tests running in parallel
+// threads. The file's total runtime stays under a second so
+// sequential execution costs nothing.
+static TEST_LOCK: Mutex<()> = Mutex::new(());
+
+fn lock() -> std::sync::MutexGuard<'static, ()> {
+    TEST_LOCK.lock().unwrap_or_else(|p| p.into_inner())
+}
+
 #[inline(never)]
 fn workload(n: usize) -> Vec<Vec<u8>> {
     let mut keep: Vec<Vec<u8>> = Vec::with_capacity(n);
@@ -19,6 +36,7 @@ fn workload(n: usize) -> Vec<Vec<u8>> {
 
 #[test]
 fn alloc_swap_pattern_compiles_and_tracks_total_bytes() {
+    let _g = lock();
     let before = HeapStats::get();
     let kept = workload(16);
     let after = HeapStats::get();
@@ -35,28 +53,43 @@ fn alloc_swap_pattern_compiles_and_tracks_total_bytes() {
 
 #[test]
 fn live_block_count_rises_and_falls() {
-    let baseline = HeapStats::get().curr_blocks;
+    let _g = lock();
+
+    // `curr_blocks` is a process-wide instantaneous counter. The
+    // test harness runs worker threads that allocate and
+    // deallocate outside our mutex, and `max_blocks` (the
+    // high-water mark) may already exceed any modest delta we
+    // can produce — so neither `before+N` nor `max + N` is a
+    // race-free assertion.
+    //
+    // What IS provable: while we *own* `kept_count` live
+    // allocations, the process-wide `curr_blocks` count
+    // must include them — it cannot drop below `kept_count`
+    // because we have not released them yet.
     let kept = workload(8);
-    let peak = HeapStats::get();
     let kept_count = kept.len();
+    let with_kept = HeapStats::get();
     drop(kept);
-    let after = HeapStats::get();
+    let after_drop = HeapStats::get();
 
     assert!(
-        peak.curr_blocks >= baseline + kept_count,
-        "curr_blocks {} should be at least baseline {} + {}",
-        peak.curr_blocks,
-        baseline,
+        with_kept.curr_blocks >= kept_count,
+        "while {} vecs are alive, curr_blocks ({}) must be >= {}",
+        kept_count,
+        with_kept.curr_blocks,
         kept_count
     );
     assert!(
-        after.curr_blocks <= peak.curr_blocks,
-        "curr_blocks should fall after drop"
+        after_drop.max_blocks >= with_kept.max_blocks,
+        "max_blocks is monotonic; after_drop ({}) must be >= with_kept ({})",
+        after_drop.max_blocks,
+        with_kept.max_blocks
     );
 }
 
 #[test]
 fn profiler_drop_writes_file_with_dhat_json_shape() {
+    let _g = lock();
     let path = std::env::temp_dir().join(format!(
         "mod-alloc-dhat-compat-test-{}-{}.json",
         std::process::id(),
@@ -93,6 +126,7 @@ fn profiler_drop_writes_file_with_dhat_json_shape() {
 
 #[test]
 fn testing_mode_suppresses_drop_write() {
+    let _g = lock();
     let path = std::env::temp_dir().join(format!(
         "mod-alloc-dhat-compat-testing-{}-{}.json",
         std::process::id(),
@@ -119,6 +153,7 @@ fn testing_mode_suppresses_drop_write() {
 
 #[test]
 fn ad_hoc_event_accumulates_counts_and_weights() {
+    let _g = lock();
     let before = AdHocStats::get();
     ad_hoc_event(7);
     ad_hoc_event(3);
@@ -129,6 +164,7 @@ fn ad_hoc_event_accumulates_counts_and_weights() {
 
 #[test]
 fn trim_backtraces_accepts_oversize_value_without_panic() {
+    let _g = lock();
     // 100 > walker cap of 8 — must not panic, must still build.
     let _p = Profiler::builder()
         .testing()
@@ -138,6 +174,7 @@ fn trim_backtraces_accepts_oversize_value_without_panic() {
 
 #[test]
 fn profiler_new_heap_constructs_and_drops_cleanly() {
+    let _g = lock();
     // Default `dhat-heap.json` write to CWD would litter the
     // workspace, so we route it to tmp instead.
     let path = std::env::temp_dir().join(format!(