Add bench for backtracking

Cargo.toml

@@ -24,7 +24,8 @@ include = ["Cargo.toml", "LICENSE", "README.md", "src/**", "tests/**", "examples
 
 [dependencies]
 indexmap = "2.6.0"
-log = "0.4.22" # for debug logs in tests
+# for debug logs in tests
+log = "0.4.22"
 priority-queue = "2.1.1"
 rustc-hash = ">=1.0.0, <3.0.0"
 serde = { version = "1.0", features = ["derive"], optional = true }
@@ -42,6 +43,10 @@ version-ranges = { version = "0.1.0", path = "version-ranges", features = ["prop
 [features]
 serde = ["dep:serde", "version-ranges/serde"]
 
+[[bench]]
+name = "backtracking"
+harness = false
+
 [[bench]]
 name = "large_case"
 harness = false

benches/backtracking.rs

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MPL-2.0
+
+//! This bench monitors the performance of backtracking and term intersection.
+//!
+//! Dependencies are constructed in a way that all versions need to be tested before
+//! pubgrub can determine that no solution exists.
+
+use criterion::*;
+use pubgrub::OfflineDependencyProvider;
+use version_ranges::Ranges;
+
+fn bench(c: &mut Criterion, case: &str, package_count: u32, version_count: u32) {
+    let mut dependency_provider = OfflineDependencyProvider::<u32, Ranges<u32>>::new();
+    let r = Ranges::strictly_lower_than(version_count);
+    dependency_provider.add_dependencies(0u32, 0u32, [(1u32, r)]);
+
+    for n in 1..package_count {
+        for v in 0..version_count {
+            let r = Ranges::strictly_lower_than(v);
+            dependency_provider.add_dependencies(n, v, [(n + 1, r)]);
+        }
+    }
+
+    c.bench_function(case, |b| {
+        b.iter(|| {
+            let _ = pubgrub::resolve(&dependency_provider, 0u32, 0u32);
+        })
+    });
+}
+
+fn bench_group(c: &mut Criterion) {
+    bench(c, "backtracking_small", 5, 60);
+    bench(c, "backtracking_medium", 5, 200);
+    bench(c, "backtracking_large", 5, 500);
+}
+
+criterion_group!(benches, bench_group);
+criterion_main!(benches);

benches/large_case.rs

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: MPL-2.0
+
 use std::time::Duration;
 
 use criterion::*;

benches/sudoku.rs

@@ -56,8 +56,8 @@ fn from_board(b: &str) -> Vec<(SudokuPackage, Range<Arc<usize>>)> {
             if let Some(val) = val.chars().next().unwrap().to_digit(10) {
                 out.push((
                     SudokuPackage::Cell {
-                        row: (row + 1).try_into().unwrap(),
-                        col: (col + 1).try_into().unwrap(),
+                        row: row + 1,
+                        col: col + 1,
                     },
                     Range::singleton(val as usize),
                 ));

test-examples/large_case_u16_NumberVersion.ron

@@ -5521,4 +5521,4 @@
         18: {},
         19: {},
     },
-}
+}