move benches to dedicated crate

Cargo.toml

@@ -4,6 +4,7 @@ resolver = "2"
 
 [workspace.dependencies]
 djls = { path = "crates/djls" }
+djls-bench = { path = "crates/djls-bench" }
 djls-conf = { path = "crates/djls-conf" }
 djls-ide = { path = "crates/djls-ide" }
 djls-project = { path = "crates/djls-project" }

crates/djls-bench/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "djls-bench"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+djls-source = { workspace = true }
+djls-templates = { workspace = true }
+
+camino = { workspace = true }
+divan = { workspace = true }
+salsa = { workspace = true }
+
+[[bench]]
+name = "parser"
+harness = false
+
+[lints]
+workspace = true

crates/djls-templates/benches/parser.rs → crates/djls-bench/benches/parser.rs

@@ -1,35 +1,50 @@
-mod support;
-
 use divan::Bencher;
-use support::db::Db;
-use support::fixtures::template_fixtures;
-use support::fixtures::TemplateFixture;
+use djls_bench::template_fixtures;
+use djls_bench::Db;
+use djls_bench::TemplateFixture;
 
 fn main() {
     divan::main();
 }
 
 #[divan::bench(args = template_fixtures())]
-fn parse_template_fixture(fixture: &TemplateFixture) {
-    let mut db = Db::new();
-    let file = db.file_with_contents(fixture.path.clone(), &fixture.source);
-    if let Some(nodelist) = djls_templates::parse_template(&db, file) {
-        divan::black_box(nodelist.nodelist(&db).len());
-    }
+fn parse_template(bencher: Bencher, fixture: &TemplateFixture) {
+    bencher
+        .with_inputs(|| {
+            let mut db = Db::new();
+            let file = db.file_with_contents(fixture.path.clone(), &fixture.source);
+            (db, file)
+        })
+        .bench_local_values(|(db, file)| {
+            if let Some(nodelist) = djls_templates::parse_template(&db, file) {
+                divan::black_box(nodelist.nodelist(&db).len());
+            }
+        });
 }
 
 #[divan::bench]
 fn parse_all_templates(bencher: Bencher) {
     let fixtures = template_fixtures();
-    bencher.bench_local(|| {
-        let mut db = Db::new();
-        for fixture in fixtures {
-            let file = db.file_with_contents(fixture.path.clone(), &fixture.source);
-            if let Some(nodelist) = djls_templates::parse_template(&db, file) {
-                divan::black_box(nodelist.nodelist(&db).len());
+
+    bencher
+        .with_inputs(|| {
+            let mut db = Db::new();
+            let mut files = Vec::with_capacity(fixtures.len());
+
+            for fixture in fixtures {
+                let file = db.file_with_contents(fixture.path.clone(), &fixture.source);
+                files.push(file);
             }
-        }
-    });
+
+            (db, files)
+        })
+        .bench_local_values(|(db, files)| {
+            for file in files {
+                if let Some(nodelist) = djls_templates::parse_template(&db, file) {
+                    divan::black_box(nodelist.nodelist(&db).len());
+                }
+            }
+        });
 }
 
 #[divan::bench(args = template_fixtures())]
@@ -47,6 +62,8 @@ fn parse_template_incremental(bencher: Bencher, fixture: &TemplateFixture) {
         text
     };
 
+    // Flip between original/modified sources so each iteration simulates an edit or revert
+    // against the same cached parse, forcing Salsa down its incremental path.
     let mut revision = 1_u64;
     let mut use_modified = true;
 

crates/djls-templates/benches/support/db.rs → crates/djls-bench/src/db.rs

@@ -12,29 +12,35 @@ use salsa::Setter;
 
 #[salsa::db]
 #[derive(Clone)]
-pub(crate) struct Db {
+pub struct Db {
     sources: Arc<Mutex<HashMap<Utf8PathBuf, String>>>,
     storage: salsa::Storage<Self>,
 }
 
 impl Db {
     #[must_use]
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             sources: Arc::new(Mutex::new(HashMap::new())),
             storage: salsa::Storage::default(),
         }
     }
 
-    pub(crate) fn file_with_contents(&mut self, path: Utf8PathBuf, contents: &str) -> File {
+    /// ## Panics
+    ///
+    /// If sources mutex is poisoned.
+    pub fn file_with_contents(&mut self, path: Utf8PathBuf, contents: &str) -> File {
         self.sources
             .lock()
             .expect("sources lock poisoned")
             .insert(path.clone(), contents.to_string());
         File::new(self, path, 0)
     }
 
-    pub(crate) fn set_file_contents(&mut self, file: File, contents: &str, revision: u64) {
+    /// ## Panics
+    ///
+    /// If sources mutex is poisoned.
+    pub fn set_file_contents(&mut self, file: File, contents: &str, revision: u64) {
         let path = file.path(self);
         self.sources
             .lock()

crates/djls-templates/benches/support/fixtures.rs → crates/djls-bench/src/fixtures.rs

@@ -7,7 +7,7 @@ use camino::Utf8Path;
 use camino::Utf8PathBuf;
 
 #[derive(Clone)]
-pub(crate) struct TemplateFixture {
+pub struct TemplateFixture {
     pub label: String,
     pub path: Utf8PathBuf,
     pub source: String,
@@ -19,7 +19,7 @@ impl fmt::Display for TemplateFixture {
     }
 }
 
-pub(crate) fn template_fixtures() -> &'static [TemplateFixture] {
+pub fn template_fixtures() -> &'static [TemplateFixture] {
     static FIXTURES: OnceLock<Vec<TemplateFixture>> = OnceLock::new();
     FIXTURES.get_or_init(load_template_fixtures).as_slice()
 }

crates/djls-bench/src/lib.rs

@@ -0,0 +1,6 @@
+mod db;
+mod fixtures;
+
+pub use db::Db;
+pub use fixtures::template_fixtures;
+pub use fixtures::TemplateFixture;

crates/djls-templates/Cargo.toml

@@ -16,17 +16,8 @@ toml = { workspace = true }
 
 [dev-dependencies]
 camino = { workspace = true }
-divan = { workspace = true }
 insta = { workspace = true }
 tempfile = { workspace = true }
 
-[[bench]]
-name = "lexer"
-harness = false
-
-[[bench]]
-name = "parser"
-harness = false
-
 [lints]
 workspace = true