use std::alloc::{GlobalAlloc, Layout, System};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Instant;
use cpp_code_analysis::{DiskFiles, OpenDocuments, Session, SessionFiles, WatchFilter};
static LIVE: AtomicUsize = AtomicUsize::new(0);
static PEAK: AtomicUsize = AtomicUsize::new(0);
static TOTAL: AtomicUsize = AtomicUsize::new(0);
struct Counting;
unsafe impl GlobalAlloc for Counting {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
TOTAL.fetch_add(layout.size(), Ordering::Relaxed);
let now = LIVE.fetch_add(layout.size(), Ordering::Relaxed) + layout.size();
PEAK.fetch_max(now, Ordering::Relaxed);
unsafe { System.alloc(layout) }
}
unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout) {
LIVE.fetch_sub(layout.size(), Ordering::Relaxed);
unsafe { System.dealloc(pointer, layout) }
}
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
TOTAL.fetch_add(layout.size(), Ordering::Relaxed);
let now = LIVE.fetch_add(layout.size(), Ordering::Relaxed) + layout.size();
PEAK.fetch_max(now, Ordering::Relaxed);
unsafe { System.alloc_zeroed(layout) }
}
unsafe fn realloc(&self, pointer: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
TOTAL.fetch_add(new_size, Ordering::Relaxed);
if new_size >= layout.size() {
let grown = new_size - layout.size();
let now = LIVE.fetch_add(grown, Ordering::Relaxed) + grown;
PEAK.fetch_max(now, Ordering::Relaxed);
} else {
LIVE.fetch_sub(layout.size() - new_size, Ordering::Relaxed);
}
unsafe { System.realloc(pointer, layout, new_size) }
}
}
#[global_allocator]
static GLOBAL: Counting = Counting;
const THE_CEILING: usize = 1536 * 1024 * 1024;
fn live() -> usize {
LIVE.load(Ordering::Relaxed)
}
fn peak() -> usize {
PEAK.load(Ordering::Relaxed)
}
fn mb(bytes: usize) -> usize {
bytes / (1024 * 1024)
}
fn guard(where_: &str) {
if live() > THE_CEILING {
println!("STOPPED at {where_}: holding {} MB", mb(live()));
std::process::exit(3);
}
}
fn project() -> PathBuf {
PathBuf::from(
std::env::var("CPPLS_REAL_PROJECT")
.unwrap_or_else(|_| r"C:\Users\zc\Desktop\test_cpp".to_string()),
)
}
fn the_sources(root: &Path) -> Vec<PathBuf> {
let directories: Vec<String> = std::env::var("CPPLS_PROBE_DIRS")
.map(|dirs| dirs.split(',').map(|dir| dir.trim().to_string()).collect())
.unwrap_or_else(|_| vec!["src".to_string()]);
let mut files: Vec<PathBuf> = directories
.iter()
.flat_map(|directory| {
std::fs::read_dir(root.join(directory))
.into_iter()
.flatten()
.flatten()
.map(|entry| entry.path())
.collect::<Vec<_>>()
})
.filter(|path| path.extension().is_some_and(|extension| extension == "cpp"))
.collect();
if files.is_empty() {
for directory in &directories {
let mut pending = vec![root.join(directory)];
while let Some(next) = pending.pop() {
let Ok(entries) = std::fs::read_dir(&next) else {
continue;
};
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
pending.push(path);
} else if path.extension().is_some_and(|extension| extension == "cpp") {
files.push(path);
}
}
}
}
}
files.sort();
files
}
#[test]
#[ignore = "a probe: opens a real project and reports instead of asserting"]
fn where_a_cold_start_puts_its_memory() {
let root = project();
let sources = the_sources(&root);
println!(
"project {} ({} source(s))",
root.display(),
sources.len()
);
let mut session = Session::open(
root.clone(),
SessionFiles::new(OpenDocuments::new(), DiskFiles),
WatchFilter::new(&root),
);
session.add_project_files(sources.clone());
println!("\n# the cold index");
let started = Instant::now();
session.index_everything();
let steps: usize = std::env::var("CPPLS_PROBE_STEPS")
.ok()
.and_then(|value| value.parse().ok())
.unwrap_or(64);
let limit: usize = std::env::var("CPPLS_PROBE_SLICES")
.ok()
.and_then(|value| value.parse().ok())
.unwrap_or(1000);
let mut slices = 0usize;
let mut read_ahead_peak = 0usize;
while session.pending_work() > 0 && slices < limit {
session.advance(steps);
slices += 1;
guard("a cold slice");
let report = session.memory_report();
read_ahead_peak = read_ahead_peak.max(report.prefetched_bytes);
println!(
"slice {slices:3} live {:5} MB peak {:5} MB churn {:6} MB | tables {:5} MB (summaries {} / cooked {} / \
units {} / renderings {})",
mb(live()),
mb(peak()),
mb(TOTAL.load(Ordering::Relaxed)),
mb(report.summary_bytes + report.cooked_bytes + report.view_bytes + report.unit_bytes),
report.summaries,
report.cooked_files,
report.units,
report.renderings,
);
}
println!(
"settled after {slices} slice(s) in {:?}; live {} MB, peak {} MB, read-ahead peak {} MB",
started.elapsed(),
mb(live()),
mb(peak()),
mb(read_ahead_peak)
);
println!("\n# the pump, with the reader's files open");
let opening: Vec<PathBuf> = match std::env::var("CPPLS_PROBE_OPEN") {
Ok(names) => {
let names: Vec<&str> = names.split(',').map(str::trim).collect();
sources
.iter()
.filter(|path| {
path.file_name()
.is_some_and(|file| names.contains(&file.to_string_lossy().as_ref()))
})
.cloned()
.collect()
}
Err(_) => sources.clone(),
};
for path in &opening {
let text = std::fs::read_to_string(path).unwrap_or_default();
session.did_open(path, &text);
}
let started = Instant::now();
let limit: usize = std::env::var("CPPLS_PROBE_SLICES")
.ok()
.and_then(|value| value.parse().ok())
.unwrap_or(1000);
let mut slices = 0usize;
let mut read_ahead_peak = 0usize;
while session.pending_work() > 0 && slices < limit {
session.advance(steps);
slices += 1;
guard("an open-file slice");
let report = session.memory_report();
read_ahead_peak = read_ahead_peak.max(report.prefetched_bytes);
println!(
"slice {slices:3} live {:5} MB peak {:5} MB churn {:6} MB | tables {:5} MB (summaries {} / cooked {} / \
units {} / renderings {})",
mb(live()),
mb(peak()),
mb(TOTAL.load(Ordering::Relaxed)),
mb(report.summary_bytes + report.cooked_bytes + report.view_bytes + report.unit_bytes),
report.summaries,
report.cooked_files,
report.units,
report.renderings,
);
}
println!(
"settled after {slices} slice(s) in {:?}; live {} MB, peak {} MB, units {:?}, pending {}, read-ahead peak {} MB",
started.elapsed(),
mb(live()),
mb(peak()),
session.unit_stats(),
session.pending_work(),
mb(read_ahead_peak)
);
println!(
"breakdown: queue {}, cooking {}, refinements {}, work {}",
session.pending(),
session.pending_cooking(),
session.refinements_wanted(),
session.pending_work()
);
println!("\n# one whole-program read at a time, the way the pump takes them");
let mut reads = 0usize;
for path in &sources {
let before = live();
let started = Instant::now();
let read = session.read_the_unit(path);
reads += 1;
guard("a program read");
let report = session.memory_report();
read_ahead_peak = read_ahead_peak.max(report.prefetched_bytes);
println!(
"read {reads:3} {:5} MB -> {:5} MB in {:>7.1} ms peak {:5} MB | tables {:5} MB | {} | {}",
mb(before),
mb(live()),
started.elapsed().as_secs_f64() * 1000.0,
mb(peak()),
mb(report.summary_bytes + report.cooked_bytes + report.view_bytes + report.unit_bytes),
path.file_name().unwrap_or_default().to_string_lossy(),
read.map_or_else(
|| "declined".to_string(),
|reading| format!(
"{} file(s), {} token(s), {} error(s)",
reading.files, reading.tokens, reading.errors
)
),
);
}
let report = session.memory_report();
println!("\n# final");
println!(
"live {} MB, peak {} MB, churn {} MB",
mb(live()),
mb(peak()),
mb(TOTAL.load(Ordering::Relaxed))
);
println!("{report}");
}