Add bench for backtracking

Author: x-hgg-x

Cargo.toml

@@ -42,6 +42,10 @@ version-ranges = { version = "0.1.0", path = "version-ranges", features = ["prop
 [features]
 serde = ["dep:serde", "version-ranges/serde"]
 
+[[bench]]
+name = "bench"
+harness = false
+
 [[bench]]
 name = "large_case"
 harness = false

benches/bench.rs

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MPL-2.0
+use std::collections::BTreeMap;
+
+use criterion::*;
+use pubgrub::OfflineDependencyProvider;
+use version_ranges::Ranges;
+
+type Deps = BTreeMap<u32, BTreeMap<u8, BTreeMap<u32, Vec<(u8, u8)>>>>;
+
+fn bench(b: &mut Bencher, data: &str) {
+    let dependencies = ron::de::from_str::<Deps>(data).unwrap();
+
+    let mut dependency_provider = OfflineDependencyProvider::<u32, Ranges<u8>>::new();
+
+    for (&p, vmap) in &dependencies {
+        for (&v, dmap) in vmap {
+            let deps_iter = dmap.iter().map(|(&d, intervals)| {
+                let mut r = Ranges::empty();
+                for &(start, end) in intervals {
+                    r = r.r#union(&Ranges::from_range_bounds(start..=end));
+                }
+                (d, r)
+            });
+            dependency_provider.add_dependencies(p, v, deps_iter);
+        }
+    }
+
+    if let Some((p, v)) = dependencies
+        .first_key_value()
+        .and_then(|(&p, vmap)| vmap.first_key_value().map(|(&v, _)| (p, v)))
+    {
+        b.iter(|| pubgrub::resolve(&mut dependency_provider, p, v).unwrap());
+    }
+}
+
+fn bench_group(c: &mut Criterion) {
+    let mut group = c.benchmark_group("bench");
+    group.sample_size(10);
+
+    let name = "backtracking";
+    let data = std::fs::read_to_string(format!("test-examples/bench_{name}.ron")).unwrap();
+
+    group.bench_function(name, |b| {
+        bench(b, &data);
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_group);
+criterion_main!(benches);

src/provider.rs

@@ -99,20 +99,20 @@ impl<P: Debug + Display + Clone + Eq + Hash, VS: VersionSet> DependencyProvider
             .and_then(|versions| versions.keys().rev().find(|v| range.contains(v)).cloned()))
     }
 
-    type Priority = Reverse<usize>;
+    type Priority = Reverse<u64>;
     fn prioritize(
         &mut self,
         package: Package,
         range: &VS,
         package_store: &PackageArena<Self::P>,
     ) -> Self::Priority {
-        Reverse(
-            package_store
-                .pkg(package)
-                .and_then(|pkg| self.dependencies.get(pkg))
-                .map(|versions| versions.keys().filter(|v| range.contains(v)).count())
-                .unwrap_or(0),
-        )
+        let count = package_store
+            .pkg(package)
+            .and_then(|pkg| self.dependencies.get(pkg))
+            .map(|versions| versions.keys().filter(|v| range.contains(v)).count())
+            .unwrap_or(0);
+
+        Reverse(((count as u64) << 32) + package.0 as u64)
     }
 
     fn get_dependencies(