[WIP] experiment: use cached packages

crates/rattler_solve/src/lib.rs

@@ -9,10 +9,10 @@ pub mod libsolv_c;
 #[cfg(feature = "resolvo")]
 pub mod resolvo;
 
-use std::fmt;
+use std::{collections::HashMap, fmt};
 
 use chrono::{DateTime, Utc};
-use rattler_conda_types::{GenericVirtualPackage, MatchSpec, RepoDataRecord};
+use rattler_conda_types::{GenericVirtualPackage, MatchSpec, PackageName, RepoDataRecord, Version};
 
 /// Represents a solver implementation, capable of solving [`SolverTask`]s
 pub trait SolverImpl {
@@ -149,6 +149,9 @@ pub struct SolverTask<TAvailablePackagesIterator> {
 
     /// The solve strategy.
     pub strategy: SolveStrategy,
+
+    /// Cached packages.
+    pub cached_packages: HashMap<PackageName, Version>,
 }
 
 impl<'r, I: IntoIterator<Item = &'r RepoDataRecord>> FromIterator<I>
@@ -166,6 +169,7 @@ impl<'r, I: IntoIterator<Item = &'r RepoDataRecord>> FromIterator<I>
             channel_priority: ChannelPriority::default(),
             exclude_newer: None,
             strategy: SolveStrategy::default(),
+            cached_packages: Default::default(),
         }
     }
 }

crates/rattler_solve/src/resolvo/conda_util.rs

@@ -1,7 +1,7 @@
 use std::{cmp::Ordering, collections::HashMap};
 
 use futures::future::FutureExt;
-use rattler_conda_types::Version;
+use rattler_conda_types::{PackageName, Version};
 use resolvo::{Dependencies, SolvableId, SolverCache, VersionSetId};
 
 use crate::resolvo::CondaDependencyProvider;
@@ -20,9 +20,10 @@
     solver: &SolverCache<CondaDependencyProvider<'_>>,
     match_spec_highest_version: &mut HashMap<
         VersionSetId,
         Option<(rattler_conda_types::Version, bool)>,
     >,
     strategy: CompareStrategy,
+    cached_versions: HashMap<PackageName, Version>
 ) -> Ordering {
     let pool = &solver.provider().pool;
 
@@ -42,6 +43,24 @@
         Ordering::Equal => {}
     };
 
+    // Check if either version is in the cached versions set
+    let some_cached_version = cached_versions.get(a_record.name());
+    tracing::error!("cached_version: {:?}", cached_versions);
+    if let Some(cc) = some_cached_version{
+        tracing::error!("cached_version: {:?}", cc);
+    }
+    if let Some(cached_version) = some_cached_version{
+        let a_is_cached = cached_version == a_record.version();
+        let b_is_cached = cached_version == b_record.version();
+        match a_is_cached.cmp(&b_is_cached) {
+            Ordering::Greater => return Ordering::Less,
+            Ordering::Less => return Ordering::Greater,
+            Ordering::Equal => {}
+        }
+
+    } 
+
+
     // Otherwise, select the variant with the highest version
     match (strategy, a_record.version().cmp(b_record.version())) {
         (CompareStrategy::Default, Ordering::Greater)

crates/rattler_solve/src/resolvo/mod.rs

@@ -3,10 +3,10 @@
 use std::{
     cell::RefCell,
     cmp::Ordering,
     collections::{HashMap, HashSet},
     fmt::{Display, Formatter},
     marker::PhantomData,
-    ops::Deref,
+    ops::Deref, str::FromStr,
 };
 
 use chrono::{DateTime, Utc};
@@ -172,8 +172,10 @@
     stop_time: Option<std::time::SystemTime>,
 
     strategy: SolveStrategy,
 
     direct_dependencies: HashSet<NameId>,
+
+    cached_versions: HashMap<PackageName, rattler_conda_types::Version>
 }
 
 impl<'a> CondaDependencyProvider<'a> {
@@ -189,6 +191,7 @@
         channel_priority: ChannelPriority,
         exclude_newer: Option<DateTime<Utc>>,
         strategy: SolveStrategy,
+        cached_versions: HashMap<PackageName, rattler_conda_types::Version>,
     ) -> Result<Self, SolveError> {
         let pool = Pool::default();
         let mut records: HashMap<NameId, Candidates> = HashMap::default();
@@ -387,9 +390,13 @@
             let solvable = pool.intern_solvable(name, SolverPackageRecord::Record(locked_record));
             let candidates = records.entry(name).or_default();
             candidates.candidates.push(solvable);
             candidates.locked = Some(solvable);
         }
 
+        let cached_versions = HashMap::from([
+            (PackageName::try_from("boltons").unwrap(), rattler_conda_types::Version::from_str("21.0.0").unwrap()),
+        ]);
+
         Ok(Self {
             pool,
             records,
@@ -398,6 +405,7 @@
             stop_time,
             strategy,
             direct_dependencies,
+            cached_versions,
         })
     }
 
@@ -475,10 +483,10 @@
                 } else {
                     CompareStrategy::Default
                 }
             }
         };
         solvables.sort_by(|&p1, &p2| {
-            conda_util::compare_candidates(p1, p2, solver, &mut highest_version_spec, strategy)
+            conda_util::compare_candidates(p1, p2, solver, &mut highest_version_spec, strategy, self.cached_versions.clone())
         });
     }
 
@@ -608,6 +616,7 @@
             task.channel_priority,
             task.exclude_newer,
             task.strategy,
+            task.cached_packages.clone(),
         )?;
 
         // Construct the requirements that the solver needs to satisfy.