refactor: convert benches back to criterion

codspeed compat with divan wouldn't let me use byte counters for measuring throughput

Author: dyc3

Cargo.lock

@@ -55,7 +55,7 @@ biome_plugin_loader = { workspace = true }
 biome_service       = { workspace = true }
 biome_test_utils    = { path = "../biome_test_utils" }
 criterion           = { package = "codspeed-criterion-compat", version = "=3.0.5" }
-divan               = { package = "codspeed-divan-compat", version = "4.0.4" }
+
 insta               = { workspace = true, features = ["glob"] }
 tests_macros        = { path = "../tests_macros" }
 

crates/biome_js_analyze/Cargo.toml

@@ -1,9 +1,5 @@
-//! Benchmark for the Tailwind CSS class parser in `use_sorted_classes` rule.
-//!
-//! Useful for comparing performance to the newer (and hopefully better) `biome_tailwind_parser` crate.
-
 use biome_js_analyze::lint::nursery::use_sorted_classes::class_lexer::tokenize_class;
-use divan::{Bencher, counter::BytesCount};
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 
 #[cfg(target_os = "windows")]
 #[global_allocator]
@@ -21,11 +17,8 @@ static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 #[global_allocator]
 static GLOBAL: std::alloc::System = std::alloc::System;
 
-fn main() {
-    // Run registered benchmarks.
-    divan::main();
-}
-
+/// Benchmark for the Tailwind CSS class parser in `use_sorted_classes` rule,
+/// ported from divan to criterion.
 const CLASS_STRING_FIXTURES: &[(&str, &str)] = &[
     (
         "simple_classes",
@@ -46,23 +39,28 @@ const CLASS_STRING_FIXTURES: &[(&str, &str)] = &[
     ),
 ];
 
-fn class_string_cases() -> impl Iterator<Item = &'static str> {
-    CLASS_STRING_FIXTURES.iter().map(|(name, _)| *name)
-}
+fn bench_use_sorted_classes_parser(c: &mut Criterion) {
+    let mut group = c.benchmark_group("use_sorted_classes_parser");
 
-#[divan::bench(name = "class_strings", args = class_string_cases(), sample_size=10)]
-fn bench_class_strings(bencher: Bencher, name: &str) {
-    bencher
-        .with_inputs(|| {
-            CLASS_STRING_FIXTURES
-                .iter()
-                .find_map(|(case_name, content)| (*case_name == name).then_some(*content))
-                .expect("cannot find test case")
-        })
-        .input_counter(BytesCount::of_str)
-        .bench_local_values(|content| {
-            for class in content.split_whitespace() {
-                divan::black_box(tokenize_class(divan::black_box(class)));
-            }
-        });
+    for (name, content) in CLASS_STRING_FIXTURES {
+        let len = content.len() as u64;
+        group.throughput(Throughput::Bytes(len));
+
+        group.bench_with_input(
+            BenchmarkId::new("class_strings", name),
+            content,
+            |b, input| {
+                b.iter(|| {
+                    for class in input.split_whitespace() {
+                        black_box(tokenize_class(black_box(class)));
+                    }
+                });
+            },
+        );
+    }
+
+    group.finish();
 }
+
+criterion_group!(use_sorted_classes_parser, bench_use_sorted_classes_parser);
+criterion_main!(use_sorted_classes_parser);

crates/biome_js_analyze/benches/use_sorted_classes_parser.rs

@@ -28,7 +28,7 @@ tracing                = { workspace = true }
 [dev-dependencies]
 biome_test_utils  = { workspace = true }
 camino            = { workspace = true }
-divan             = { package = "codspeed-divan-compat", version = "4.0.4" }
+criterion           = { package = "codspeed-criterion-compat", version = "=3.0.5" }
 insta             = { workspace = true }
 quickcheck        = { workspace = true }
 quickcheck_macros = { workspace = true }

crates/biome_tailwind_parser/Cargo.toml

@@ -1,7 +1,9 @@
+use std::fs;
+use std::path::Path;
+
 use biome_rowan::NodeCache;
 use biome_tailwind_parser::{parse_tailwind, parse_tailwind_with_cache};
-use divan::{Bencher, counter::BytesCount};
-use std::path::Path;
+use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 
 #[cfg(target_os = "windows")]
 #[global_allocator]
@@ -19,57 +21,57 @@ static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 #[global_allocator]
 static GLOBAL: std::alloc::System = std::alloc::System;
 
-fn main() {
-    divan::main();
-}
+/// Load fixture files from `benches/fixtures` returning (file_name, content).
+fn load_fixtures() -> Vec<(String, String)> {
+    let fixtures_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("benches/fixtures");
+    let mut fixtures = Vec::new();
 
-fn fixture_names() -> impl Iterator<Item = String> {
-    let fixtures_dir = Path::new("benches/fixtures");
-    let mut names = Vec::new();
-
-    if let Ok(entries) = std::fs::read_dir(fixtures_dir) {
+    if let Ok(entries) = fs::read_dir(&fixtures_dir) {
         for entry in entries.flatten() {
             let path = entry.path();
             if path.is_file()
-                && let Some(file_name) = path.file_name().and_then(|n| n.to_str()) {
-                    names.push(file_name.to_string());
-                }
+                && let Some(file_name) = path.file_name().and_then(|n| n.to_str())
+            {
+                let content = fs::read_to_string(&path).expect("Failed to read fixture file");
+                fixtures.push((file_name.to_string(), content));
+            }
         }
     }
 
-    names.into_iter()
+    fixtures
 }
 
-#[divan::bench(name = "uncached", args = fixture_names(), sample_size=10)]
-fn bench_uncached(bencher: Bencher, filename: &str) {
-    let fixtures_dir = Path::new("benches/fixtures");
-    let path = fixtures_dir.join(filename);
-    let code = std::fs::read_to_string(&path).unwrap_or_default();
+fn bench_tailwind(c: &mut Criterion) {
+    let fixtures = load_fixtures();
 
-    bencher
-        .with_inputs(|| code.clone())
-        .input_counter(BytesCount::of_str)
-        .bench_local_values(|code| {
-            let result = parse_tailwind(&code);
-            divan::black_box(result);
-        });
-}
+    let mut group = c.benchmark_group("tailwind_parser");
 
-#[divan::bench(name = "cached", args = fixture_names(), sample_size=10)]
-fn bench_cached(bencher: Bencher, filename: &str) {
-    let fixtures_dir = Path::new("benches/fixtures");
-    let path = fixtures_dir.join(filename);
-    let code = std::fs::read_to_string(&path).unwrap_or_default();
+    for (name, content) in &fixtures {
+        let len = content.len() as u64;
 
-    bencher
-        .with_inputs(|| {
+        group.throughput(Throughput::Bytes(len));
+        group.bench_with_input(BenchmarkId::new("uncached", name), content, |b, code| {
+            b.iter(|| {
+                let result = parse_tailwind(black_box(code));
+                black_box(result);
+            });
+        });
+
+        group.throughput(Throughput::Bytes(len));
+        group.bench_with_input(BenchmarkId::new("cached", name), content, |b, code| {
             let mut cache = NodeCache::default();
-            // Warm-up parse to populate cache.
-            let _ = parse_tailwind_with_cache(&code, &mut cache);
-            (cache, code.clone())
-        })
-        .input_counter(|(_cache, code)| BytesCount::of_str(code))
-        .bench_local_values(|(mut cache, code)| {
-            divan::black_box(parse_tailwind_with_cache(&code, &mut cache));
+            // Warm-up parse to populate cache (excluded from measurement).
+            let _ = parse_tailwind_with_cache(code, &mut cache);
+
+            b.iter(|| {
+                let result = parse_tailwind_with_cache(black_box(code), &mut cache);
+                black_box(result);
+            });
         });
+    }
+
+    group.finish();
 }
+
+criterion_group!(tailwind_parser, bench_tailwind);
+criterion_main!(tailwind_parser);