use std::fmt;
use std::path::Path;
use std::time::{Duration, Instant};
use crate::crawler::CrawlConfig;
use crate::error::Result;
use crate::fs::RealFs;
use crate::index::{rss_bytes, BuildConfig, IndexStats};
use crate::query::{search, Query, SearchOptions};
use crate::report::{commas, human_bytes, human_bytes_signed, human_duration};
use crate::store::{build_index, open, NoProgress, OpenOptions};
pub const DEFAULT_QUERIES: &[&str] = &[
"fn",
"error",
"impl AND struct",
"error OR result",
"\"pub fn\"",
"\"use std\"",
"test -mod",
"http OR response OR request",
"the quick brown fox",
"zzzz_no_such_term",
];
#[derive(Debug, Clone)]
pub struct QueryTiming {
pub query: String,
pub matches: usize,
pub iterations: u32,
pub mean: Duration,
pub min: Duration,
pub p50: Duration,
pub max: Duration,
}
#[derive(Debug, Clone)]
pub struct BenchReport {
pub index: IndexStats,
pub open_cold: Duration,
pub eviction: &'static str,
pub open_warm: Duration,
pub queries: Vec<QueryTiming>,
pub rss_before_queries: Option<usize>,
pub rss_max_during_queries: Option<usize>,
}
pub fn run(root: &Path, queries: &[String], iterations: u32) -> Result<BenchReport> {
let built = build_index(&RealFs, root, &CrawlConfig::default(), &BuildConfig::default(), &NoProgress)?;
let build_stats = built.stats().clone();
let files = built.files();
drop(built);
let eviction = evict_page_cache(&files);
let t = Instant::now();
let cold = open(&RealFs, root, &OpenOptions::default())?.expect("index was just built");
let open_cold = t.elapsed();
drop(cold);
let t = Instant::now();
let index = open(&RealFs, root, &OpenOptions::default())?.expect("index was just built");
let open_warm = t.elapsed();
let queries: Vec<String> = if queries.is_empty() {
DEFAULT_QUERIES.iter().map(|s| s.to_string()).collect()
} else {
queries.to_vec()
};
let opts = SearchOptions::default();
let iterations = iterations.max(1);
let rss_before_queries = rss_bytes();
let mut rss_max = rss_before_queries;
let mut timings = Vec::with_capacity(queries.len());
for q in queries {
let query = match Query::parse(&q) {
Ok(query) => query,
Err(e) => {
log::warn!("bench: skipping query {q:?}: {e}");
continue;
}
};
let matches = search(&index, &query, &opts).total_matches; let mut samples: Vec<Duration> = (0..iterations)
.map(|_| {
let t = Instant::now();
std::hint::black_box(search(&index, &query, &opts));
t.elapsed()
})
.collect();
samples.sort();
let n = samples.len();
timings.push(QueryTiming {
query: q,
matches,
iterations,
mean: samples.iter().sum::<Duration>() / n as u32,
min: samples[0],
p50: samples[n / 2],
max: samples[n - 1],
});
rss_max = rss_max.max(rss_bytes());
}
Ok(BenchReport {
index: build_stats,
open_cold,
eviction,
open_warm,
queries: timings,
rss_before_queries,
rss_max_during_queries: rss_max,
})
}
fn evict_page_cache(files: &[std::path::PathBuf]) -> &'static str {
#[cfg(target_os = "linux")]
{
use std::os::fd::AsRawFd;
let mut ok = true;
for p in files {
if let Ok(f) = std::fs::File::open(p) {
let r = unsafe { libc::posix_fadvise(f.as_raw_fd(), 0, 0, libc::POSIX_FADV_DONTNEED) };
ok &= r == 0;
}
}
return if ok { "posix_fadvise(DONTNEED) on every index file" } else { "posix_fadvise(DONTNEED) — some calls failed" };
}
#[cfg(windows)]
{
use std::os::windows::fs::OpenOptionsExt;
use windows_sys::Win32::Storage::FileSystem::FILE_FLAG_NO_BUFFERING;
let mut ok = true;
for p in files {
ok &= std::fs::OpenOptions::new().read(true).custom_flags(FILE_FLAG_NO_BUFFERING).open(p).is_ok();
}
return if ok { "FILE_FLAG_NO_BUFFERING open of every index file (best effort)" } else { "FILE_FLAG_NO_BUFFERING open — some failed" };
}
#[allow(unreachable_code)]
{
let _ = files;
"not attempted on this platform"
}
}
impl fmt::Display for BenchReport {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(f, "== build ==")?;
write!(f, "{}", self.index)?;
writeln!(f)?;
writeln!(f, "== open ==")?;
writeln!(f, "cold (best effort) {} eviction: {}", human_duration(self.open_cold), self.eviction)?;
writeln!(f, "warm {}", human_duration(self.open_warm))?;
writeln!(f)?;
let iters = self.queries.first().map_or(0, |q| q.iterations);
writeln!(f, "== queries ({iters} timed runs each, after warm-up) ==")?;
writeln!(
f,
"{:<34} {:>9} {:>11} {:>11} {:>11} {:>11}",
"query", "matches", "mean", "p50", "min", "max"
)?;
for q in &self.queries {
let shown: String = if q.query.chars().count() > 32 {
format!("{}…", q.query.chars().take(31).collect::<String>())
} else {
q.query.clone()
};
writeln!(
f,
"{:<34} {:>9} {:>11} {:>11} {:>11} {:>11}",
shown,
commas(q.matches as u64),
human_duration(q.mean),
human_duration(q.p50),
human_duration(q.min),
human_duration(q.max),
)?;
}
writeln!(f)?;
writeln!(f, "== memory while querying ==")?;
match (self.rss_before_queries, self.rss_max_during_queries) {
(Some(before), Some(max)) => {
let growth = max as i64 - before as i64;
writeln!(f, "RSS after open {}", human_bytes(before as u64))?;
writeln!(f, "RSS max during queries {} ({} growth)", human_bytes(max as u64), human_bytes_signed(growth))?;
let disk = self.index.on_disk_bytes.max(1);
writeln!(
f,
"index on disk {} → queries touched at most {:.1}% of it",
human_bytes(disk),
100.0 * growth.max(0) as f64 / disk as f64
)?;
}
_ => writeln!(f, "RSS unavailable on this platform")?,
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn runs_and_skips_bad_queries() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("a.txt"), "alpha beta gamma").unwrap();
std::fs::write(dir.path().join("b.txt"), "beta delta").unwrap();
let queries = ["beta".to_string(), "-only_negation".to_string(), "\"alpha beta\"".to_string()];
let report = run(dir.path(), &queries, 3).unwrap();
assert_eq!(report.index.docs_indexed, 2);
assert_eq!(report.queries.len(), 2); assert_eq!(report.queries[0].query, "beta");
assert_eq!(report.queries[0].matches, 2);
assert_eq!(report.queries[0].iterations, 3);
assert!(report.queries[0].min <= report.queries[0].p50 && report.queries[0].p50 <= report.queries[0].max);
assert_eq!(report.queries[1].matches, 1);
assert!(report.open_warm < Duration::from_secs(60), "warm open took {:?}", report.open_warm);
let text = report.to_string();
assert!(text.contains("== build =="));
assert!(text.contains("== open =="));
assert!(text.contains("unique terms"));
assert!(text.contains("\"alpha beta\""));
assert!(text.contains("== memory while querying =="));
assert!(open(&RealFs, dir.path(), &OpenOptions { verify: true }).unwrap().is_some());
}
#[test]
fn default_queries_all_parse() {
for q in DEFAULT_QUERIES {
Query::parse(q).unwrap_or_else(|e| panic!("{q:?}: {e}"));
}
}
}