Skip to content

Commit adfebfd

Browse files
x-hgg-xx-hgg-x
committed
Use an arena for packages
1 parent 440fe3f commit adfebfd

21 files changed

+1049
-742
lines changed

‎benches/large_case.rs

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,18 @@
11
// SPDX-License-Identifier: MPL-2.0
2-
use std::collections::HashMap;
2+
use std::fmt::{Debug, Display};
3+
use std::hash::Hash;
34
use std::time::Duration;
45

56
use criterion::*;
67
use serde::de::Deserialize;
78

8-
use pubgrub::{resolve, OfflineDependencyProvider, Package, Range, SemanticVersion, VersionSet};
9+
use pubgrub::{resolve, Map, OfflineDependencyProvider, Range, SemanticVersion, VersionSet};
910

10-
fn bench<'a, P: Package + Deserialize<'a>, VS: VersionSet + Deserialize<'a>>(
11+
fn bench<
12+
'a,
13+
P: Debug + Display + Clone + Eq + Hash + Deserialize<'a>,
14+
VS: VersionSet + Deserialize<'a>,
15+
>(
1116
b: &mut Bencher,
1217
case: &'a str,
1318
) where
@@ -24,7 +29,7 @@ fn bench<'a, P: Package + Deserialize<'a>, VS: VersionSet + Deserialize<'a>>(
2429
dependency_provider.versions(p).unwrap().cloned().collect(),
2530
)
2631
})
27-
.collect::<HashMap<_, Vec<_>>>();
32+
.collect::<Map<_, Vec<_>>>();
2833

2934
b.iter(|| {
3035
for (p, versions) in &dependencies {

‎benches/sudoku.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -123,9 +123,9 @@ fn solve(board: Vec<(SudokuPackage, Ranges<u8>)>) -> SelectedDependencies<DP> {
123123
dependency_provider.add_dependencies(SudokuPackage::Root, 1, board);
124124
match resolve(&mut dependency_provider, SudokuPackage::Root, 1) {
125125
Ok(sol) => sol,
126-
Err(PubGrubError::NoSolution(mut derivation_tree)) => {
127-
derivation_tree.collapse_no_versions();
128-
eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
126+
Err(PubGrubError::NoSolution(mut error)) => {
127+
error.derivation_tree.collapse_no_versions();
128+
eprintln!("{}", DefaultStringReporter::report(&error));
129129
std::process::exit(1);
130130
}
131131
Err(err) => panic!("{:?}", err),

‎examples/branching_error_reporting.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -56,9 +56,9 @@ fn main() {
5656
// Run the algorithm.
5757
match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
5858
Ok(sol) => println!("{:?}", sol),
59-
Err(PubGrubError::NoSolution(mut derivation_tree)) => {
60-
derivation_tree.collapse_no_versions();
61-
eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
59+
Err(PubGrubError::NoSolution(mut error)) => {
60+
error.derivation_tree.collapse_no_versions();
61+
eprintln!("{}", DefaultStringReporter::report(&error));
6262
std::process::exit(1);
6363
}
6464
Err(err) => panic!("{:?}", err),

‎examples/caching_dependency_provider.rs

Lines changed: 55 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,68 +1,93 @@
11
// SPDX-License-Identifier: MPL-2.0
22

33
use std::cell::RefCell;
4+
use std::collections::BTreeMap;
5+
use std::fmt::{Debug, Display};
6+
use std::hash::Hash;
47

5-
use pubgrub::{resolve, Dependencies, DependencyProvider, OfflineDependencyProvider, Ranges};
8+
use pubgrub::{
9+
resolve, Dependencies, DependencyConstraints, DependencyProvider, Map,
10+
OfflineDependencyProvider, Package, PackageArena, Ranges,
11+
};
612

713
type NumVS = Ranges<u32>;
14+
type CachedDeps<V, VS> = RefCell<Map<Package, BTreeMap<V, DependencyConstraints<VS>>>>;
815

916
// An example implementing caching dependency provider that will
1017
// store queried dependencies in memory and check them before querying more from remote.
11-
struct CachingDependencyProvider<DP: DependencyProvider> {
18+
struct CachingDependencyProvider<DP: DependencyProvider>
19+
where
20+
DP::P: Debug + Display + Clone + Eq + Hash,
21+
{
1222
remote_dependencies: DP,
13-
cached_dependencies: RefCell<OfflineDependencyProvider<DP::P, DP::VS>>,
23+
cached_dependencies: CachedDeps<DP::V, DP::VS>,
1424
}
1525

16-
impl<DP: DependencyProvider> CachingDependencyProvider<DP> {
26+
impl<DP: DependencyProvider> CachingDependencyProvider<DP>
27+
where
28+
DP::P: Debug + Display + Clone + Eq + Hash,
29+
{
1730
pub fn new(remote_dependencies_provider: DP) -> Self {
1831
CachingDependencyProvider {
1932
remote_dependencies: remote_dependencies_provider,
20-
cached_dependencies: RefCell::new(OfflineDependencyProvider::new()),
33+
cached_dependencies: Default::default(),
2134
}
2235
}
2336
}
2437

25-
impl<DP: DependencyProvider<M = String>> DependencyProvider for CachingDependencyProvider<DP> {
26-
// Caches dependencies if they were already queried
38+
impl<DP: DependencyProvider<M = &'static str>> DependencyProvider for CachingDependencyProvider<DP>
39+
where
40+
DP::P: Debug + Display + Clone + Eq + Hash,
41+
{
42+
// Cache dependencies if they were already queried
2743
fn get_dependencies(
2844
&mut self,
29-
package: &DP::P,
45+
package: Package,
3046
version: &DP::V,
31-
) -> Result<Dependencies<DP::P, DP::VS, DP::M>, DP::Err> {
47+
package_store: &mut PackageArena<Self::P>,
48+
) -> Result<Dependencies<DP::VS, DP::M>, DP::Err> {
3249
let mut cache = self.cached_dependencies.borrow_mut();
33-
match cache.get_dependencies(package, version) {
34-
Ok(Dependencies::Unavailable(_)) => {
35-
let dependencies = self.remote_dependencies.get_dependencies(package, version);
36-
match dependencies {
37-
Ok(Dependencies::Available(dependencies)) => {
38-
cache.add_dependencies(
39-
package.clone(),
40-
version.clone(),
41-
dependencies.clone(),
42-
);
43-
Ok(Dependencies::Available(dependencies))
44-
}
45-
Ok(Dependencies::Unavailable(reason)) => Ok(Dependencies::Unavailable(reason)),
46-
error @ Err(_) => error,
47-
}
50+
if let Some(deps) = cache.get(&package).and_then(|vmap| vmap.get(version)) {
51+
return Ok(Dependencies::Available(deps.clone()));
52+
}
53+
54+
match self
55+
.remote_dependencies
56+
.get_dependencies(package, version, package_store)
57+
{
58+
Ok(Dependencies::Available(deps)) => {
59+
cache
60+
.entry(package)
61+
.or_default()
62+
.insert(version.clone(), deps.clone());
63+
Ok(Dependencies::Available(deps))
4864
}
49-
Ok(dependencies) => Ok(dependencies),
50-
Err(_) => unreachable!(),
65+
66+
Ok(Dependencies::Unavailable(reason)) => Ok(Dependencies::Unavailable(reason)),
67+
error @ Err(_) => error,
5168
}
5269
}
5370

5471
fn choose_version(
5572
&mut self,
56-
package: &DP::P,
73+
package: Package,
5774
ranges: &DP::VS,
75+
package_store: &PackageArena<Self::P>,
5876
) -> Result<Option<DP::V>, DP::Err> {
59-
self.remote_dependencies.choose_version(package, ranges)
77+
self.remote_dependencies
78+
.choose_version(package, ranges, package_store)
6079
}
6180

6281
type Priority = DP::Priority;
6382

64-
fn prioritize(&mut self, package: &DP::P, ranges: &DP::VS) -> Self::Priority {
65-
self.remote_dependencies.prioritize(package, ranges)
83+
fn prioritize(
84+
&mut self,
85+
package: Package,
86+
ranges: &DP::VS,
87+
package_store: &PackageArena<Self::P>,
88+
) -> Self::Priority {
89+
self.remote_dependencies
90+
.prioritize(package, ranges, package_store)
6691
}
6792

6893
type Err = DP::Err;

‎examples/doc_interface_error.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -73,9 +73,9 @@ fn main() {
7373
// Run the algorithm.
7474
match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
7575
Ok(sol) => println!("{:?}", sol),
76-
Err(PubGrubError::NoSolution(mut derivation_tree)) => {
77-
derivation_tree.collapse_no_versions();
78-
eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
76+
Err(PubGrubError::NoSolution(mut error)) => {
77+
error.derivation_tree.collapse_no_versions();
78+
eprintln!("{}", DefaultStringReporter::report(&error));
7979
}
8080
Err(err) => panic!("{:?}", err),
8181
};

‎examples/doc_interface_semantic.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -64,9 +64,9 @@ fn main() {
6464
// Run the algorithm.
6565
match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
6666
Ok(sol) => println!("{:?}", sol),
67-
Err(PubGrubError::NoSolution(mut derivation_tree)) => {
68-
derivation_tree.collapse_no_versions();
69-
eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
67+
Err(PubGrubError::NoSolution(mut error)) => {
68+
error.derivation_tree.collapse_no_versions();
69+
eprintln!("{}", DefaultStringReporter::report(&error));
7070
}
7171
Err(err) => panic!("{:?}", err),
7272
};

‎examples/linear_error_reporting.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -38,9 +38,9 @@ fn main() {
3838
// Run the algorithm.
3939
match resolve(&mut dependency_provider, "root", (1, 0, 0)) {
4040
Ok(sol) => println!("{:?}", sol),
41-
Err(PubGrubError::NoSolution(mut derivation_tree)) => {
42-
derivation_tree.collapse_no_versions();
43-
eprintln!("{}", DefaultStringReporter::report(&derivation_tree));
41+
Err(PubGrubError::NoSolution(mut error)) => {
42+
error.derivation_tree.collapse_no_versions();
43+
eprintln!("{}", DefaultStringReporter::report(&error));
4444
std::process::exit(1);
4545
}
4646
Err(err) => panic!("{:?}", err),

0 commit comments

Comments
 (0)