Try the async version of resolvo

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = ["crates/*"]
+resolver = "2"
 
 # See: https://docs.rs/insta/latest/insta/#optional-faster-runs
 [profile.dev.package.insta]
@@ -144,3 +145,6 @@ walkdir = "2.4.0"
 windows-sys = { version = "0.52.0", default-features = false }
 zip = { version = "0.6.6", default-features = false }
 zstd = { version = "0.13.0", default-features = false }
+
+[patch.crates-io]
+resolvo = { git = "https://github.com/baszalmstra/resolvo.git", branch = "refactor/concurrent-metadata-fetch" }

crates/rattler_solve/Cargo.toml

@@ -25,6 +25,8 @@ hex = { workspace = true }
 tempfile = { workspace = true }
 rattler_libsolv_c = { workspace = true, optional = true }
 resolvo = { workspace = true, optional = true }
+tokio = { workspace = true, optional = true }
+futures = { workspace = true, optional = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
@@ -41,6 +43,7 @@ url = { workspace = true }
 [features]
 default = ["libsolv_c"]
 libsolv_c = ["rattler_libsolv_c", "libc"]
+resolvo = ["dep:resolvo", "dep:tokio", "dep:futures"]
 
 [[bench]]
 name = "bench"

crates/rattler_solve/src/resolvo/conda_util.rs

@@ -1,9 +1,9 @@
 use crate::resolvo::{CondaDependencyProvider, SolverMatchSpec};
+use futures::future::FutureExt;
 use rattler_conda_types::Version;
 use resolvo::{Dependencies, SolvableId, SolverCache, VersionSetId};
 use std::cmp::Ordering;
 use std::collections::HashMap;
-
 /// Returns the order of two candidates based on the order used by conda.
 #[allow(clippy::too_many_arguments)]
 pub(super) fn compare_candidates<'a>(
@@ -47,11 +47,19 @@
         Ordering::Equal => {}
     };
 
+    // return Ordering::Equal;
+
     // Otherwise, compare the dependencies of the variants. If there are similar
     // dependencies select the variant that selects the highest version of the dependency.
     let (a_dependencies, b_dependencies) = match (
-        solver.get_or_cache_dependencies(a),
-        solver.get_or_cache_dependencies(b),
+        solver
+            .get_or_cache_dependencies(a)
+            .now_or_never()
+            .expect("get_or_cache_dependencies failed"),
+        solver
+            .get_or_cache_dependencies(b)
+            .now_or_never()
+            .expect("get_or_cache_dependencies failed"),
     ) {
         (Ok(a_deps), Ok(b_deps)) => (a_deps, b_deps),
         // If either call fails, it's likely due to solver cancellation; thus, we can't compare dependencies
@@ -147,7 +155,10 @@
     match_spec_highest_version
         .entry(match_spec_id)
         .or_insert_with(|| {
-            let candidates = solver.get_or_cache_matching_candidates(match_spec_id);
+            let candidates = solver
+                .get_or_cache_matching_candidates(match_spec_id)
+                .now_or_never()
+                .expect("get_or_cache_matching_candidates failed");
 
             // Err only happens on cancellation, so we will not continue anyways
             let candidates = if let Ok(candidates) = candidates {
@@ -156,9 +167,11 @@
                 return None;
             };
 
+            let pool = solver.pool();
+
             candidates
                 .iter()
-                .map(|id| solver.pool().resolve_solvable(*id).inner())
+                .map(|id| pool.resolve_solvable(*id).inner())
                 .fold(None, |init, record| {
                     Some(init.map_or_else(
                         || {

crates/rattler_solve/src/resolvo/mod.rs

@@ -11,6 +11,7 @@
     SolvableId, Solver as LibSolvRsSolver, SolverCache, UnsolvableOrCancelled, VersionSet,
     VersionSetId,
 };
+use std::rc::Rc;
 use std::{
     cell::RefCell,
     cmp::Ordering,
@@ -157,7 +158,7 @@
 /// Dependency provider for conda
 #[derive(Default)]
 pub(crate) struct CondaDependencyProvider<'a> {
-    pool: Pool<SolverMatchSpec<'a>, String>,
+    pool: Rc<Pool<SolverMatchSpec<'a>, String>>,
 
     records: HashMap<NameId, Candidates>,
 
@@ -178,7 +179,7 @@
         match_specs: &[MatchSpec],
         stop_time: Option<std::time::SystemTime>,
     ) -> Self {
-        let pool = Pool::default();
+        let pool = Rc::new(Pool::default());
         let mut records: HashMap<NameId, Candidates> = HashMap::default();
 
         // Add virtual packages to the records
@@ -348,11 +349,11 @@
 }
 
 impl<'a> DependencyProvider<SolverMatchSpec<'a>> for CondaDependencyProvider<'a> {
-    fn pool(&self) -> &Pool<SolverMatchSpec<'a>, String> {
-        &self.pool
+    fn pool(&self) -> Rc<Pool<SolverMatchSpec<'a>, String>> {
+        self.pool.clone()
     }
 
-    fn sort_candidates(
+    async fn sort_candidates(
         &self,
         solver: &SolverCache<SolverMatchSpec<'a>, String, Self>,
         solvables: &mut [SolvableId],
@@ -363,11 +364,11 @@
         });
     }
 
-    fn get_candidates(&self, name: NameId) -> Option<Candidates> {
+    async fn get_candidates(&self, name: NameId) -> Option<Candidates> {
         self.records.get(&name).cloned()
     }
 
-    fn get_dependencies(&self, solvable: SolvableId) -> Dependencies {
+    async fn get_dependencies(&self, solvable: SolvableId) -> Dependencies {
         let mut dependencies = KnownDependencies::default();
         let SolverPackageRecord::Record(rec) = self.pool.resolve_solvable(solvable).inner() else {
             return Dependencies::Known(dependencies);
@@ -433,6 +434,9 @@
         &mut self,
         task: SolverTask<TAvailablePackagesIterator>,
     ) -> Result<Vec<RepoDataRecord>, SolveError> {
+        let runtime = tokio::runtime::Builder::new_current_thread()
+            .build()
+            .unwrap();
         let stop_time = task
             .timeout
             .map(|timeout| std::time::SystemTime::now() + timeout);
@@ -446,6 +450,7 @@
             task.specs.clone().as_ref(),
             stop_time,
         );
+        let pool = provider.pool.clone();
 
         // Construct the requirements that the solver needs to satisfy.
         let root_requirements = task
@@ -460,14 +465,14 @@
             .collect();
 
         // Construct a solver and solve the problems in the queue
-        let mut solver = LibSolvRsSolver::new(provider);
+        let mut solver = LibSolvRsSolver::new(provider, runtime);
         let solvables = solver
             .solve(root_requirements)
             .map_err(|unsolvable_or_cancelled| {
                 match unsolvable_or_cancelled {
                     UnsolvableOrCancelled::Unsolvable(problem) => {
                         SolveError::Unsolvable(vec![problem
-                            .display_user_friendly(&solver, &CondaSolvableDisplay)
+                            .display_user_friendly(&solver, pool, &CondaSolvableDisplay)
                             .to_string()])
                     }
                     // We are not doing this as of yet
@@ -479,7 +484,7 @@
         // Get the resulting packages from the solver.
         let required_records = solvables
             .into_iter()
-            .filter_map(|id| match *solver.pool().resolve_solvable(id).inner() {
+            .filter_map(|id| match *solver.pool.resolve_solvable(id).inner() {
                 SolverPackageRecord::Record(rec) => Some(rec.clone()),
                 SolverPackageRecord::VirtualPackage(_) => None,
             })

rust-toolchain

@@ -1 +1 @@
-1.70.0
+1.75.0