try async resolvo

Co-Authored-By: Tim de Jager <tim@prefix.dev>

Author: wolfv

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/aochagavia/resolvo.git", branch = "concurrent-metadata-fetching" }

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 @@ pub(super) fn compare_candidates<'a>(
         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 @@ pub(super) fn find_highest_version<'a>(
     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 @@ pub(super) fn find_highest_version<'a>(
                 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(
                         || {

rust-toolchain

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