perf: specialize range operations for better performances (#177)

* Use binary search for `Range::contains`

* Avoid cloning and dropping the term in prior_cause

* Simplify contains

* Specialize union code

* remove a redundant check and reuse helper

* Specialize is_disjoint

* simplify and add tests for is_disjoint

* Specialize subset_of

* simplify and add tests for subset_of

* Specialize range operations for better performance

* add tests and use in more places

* Fix clippy lints

* replace a complement with is_disjoint

* one fewer complement using intersection

* use the symmetry of set functions

---------

Co-authored-by: Jacob Finkelman <[email protected]>

src/internal/incompatibility.rs

@@ -173,8 +173,11 @@ impl<P: Package, VS: VersionSet> Incompatibility<P, VS> {
         incompatibility_store: &Arena<Self>,
     ) -> Self {
         let kind = Kind::DerivedFrom(incompat, satisfier_cause);
-        let mut package_terms = incompatibility_store[incompat].package_terms.clone();
-        let t1 = package_terms.remove(package).unwrap();
+        // Optimization to avoid cloning and dropping t1
+        let (t1, mut package_terms) = incompatibility_store[incompat]
+            .package_terms
+            .split_one(package)
+            .unwrap();
         let satisfier_cause_terms = &incompatibility_store[satisfier_cause].package_terms;
         package_terms.merge(
             satisfier_cause_terms.iter().filter(|(p, _)| p != &package),

src/internal/partial_solution.rs

@@ -501,7 +501,7 @@ impl<P: Package, VS: VersionSet> PackageAssignments<P, VS> {
         let idx = self
             .dated_derivations
             .as_slice()
-            .partition_point(|dd| dd.accumulated_intersection.intersection(start_term) != empty);
+            .partition_point(|dd| !dd.accumulated_intersection.is_disjoint(start_term));
         if let Some(dd) = self.dated_derivations.get(idx) {
             debug_assert_eq!(dd.accumulated_intersection.intersection(start_term), empty);
             return (Some(dd.cause), dd.global_index, dd.decision_level);

src/internal/small_map.rs

@@ -99,6 +99,49 @@ impl<K: PartialEq + Eq + Hash, V> SmallMap<K, V> {
             }
         };
     }
+
+    /// Returns a reference to the value for one key and a copy of the map without the key.
+    ///
+    /// This is an optimization over the following, where we only need a reference to `t1`. It
+    /// avoids cloning and then drop the ranges in each `prior_cause` call.
+    /// ```ignore
+    /// let mut package_terms = package_terms.clone();
+    //  let t1 = package_terms.remove(package).unwrap();
+    /// ```
+    pub fn split_one(&self, key: &K) -> Option<(&V, Self)>
+    where
+        K: Clone,
+        V: Clone,
+    {
+        match self {
+            Self::Empty => None,
+            Self::One([(k, v)]) => {
+                if k == key {
+                    Some((v, Self::Empty))
+                } else {
+                    None
+                }
+            }
+            Self::Two([(k1, v1), (k2, v2)]) => {
+                if k1 == key {
+                    Some((v1, Self::One([(k2.clone(), v2.clone())])))
+                } else if k2 == key {
+                    Some((v2, Self::One([(k1.clone(), v1.clone())])))
+                } else {
+                    None
+                }
+            }
+            Self::Flexible(map) => {
+                if let Some(value) = map.get(key) {
+                    let mut map = map.clone();
+                    map.remove(key).unwrap();
+                    Some((value, Self::Flexible(map)))
+                } else {
+                    None
+                }
+            }
+        }
+    }
 }
 
 impl<K: Clone + PartialEq + Eq + Hash, V: Clone> SmallMap<K, V> {