perf: use smallvec for unit propagation buffer (#90)

Author: mpizenberg

src/internal/core.rs

@@ -11,6 +11,7 @@ use crate::internal::assignment::Assignment::{Decision, Derivation};
 use crate::internal::incompatibility::IncompId;
 use crate::internal::incompatibility::{Incompatibility, Relation};
 use crate::internal::partial_solution::{DecisionLevel, PartialSolution};
+use crate::internal::small_vec::SmallVec;
 use crate::package::Package;
 use crate::report::DerivationTree;
 use crate::solver::DependencyConstraints;
@@ -39,7 +40,7 @@ pub struct State<P: Package, V: Version> {
     /// This is a stack of work to be done in `unit_propagation`.
     /// It can definitely be a local variable to that method, but
     /// this way we can reuse the same allocation for better performance.
-    unit_propagation_buffer: Vec<P>,
+    unit_propagation_buffer: SmallVec<P>,
 }
 
 impl<P: Package, V: Version> State<P, V> {
@@ -59,7 +60,7 @@ impl<P: Package, V: Version> State<P, V> {
             contradicted_incompatibilities: rustc_hash::FxHashSet::default(),
             partial_solution: PartialSolution::empty(),
             incompatibility_store,
-            unit_propagation_buffer: vec![],
+            unit_propagation_buffer: SmallVec::Empty,
         }
     }
 

src/internal/small_vec.rs

@@ -39,6 +39,32 @@ impl<T> SmallVec<T> {
         }
     }
 
+    pub fn pop(&mut self) -> Option<T> {
+        match std::mem::take(self) {
+            Self::Empty => None,
+            Self::One([v1]) => {
+                *self = Self::Empty;
+                Some(v1)
+            }
+            Self::Two([v1, v2]) => {
+                *self = Self::One([v1]);
+                Some(v2)
+            }
+            Self::Flexible(mut v) => {
+                let out = v.pop();
+                *self = Self::Flexible(v);
+                out
+            }
+        }
+    }
+
+    pub fn clear(&mut self) {
+        if let Self::Flexible(mut v) = std::mem::take(self) {
+            v.clear();
+            *self = Self::Flexible(v);
+        } // else: self already eq Empty from the take
+    }
+
     pub fn iter(&self) -> std::slice::Iter<'_, T> {
         self.as_slice().iter()
     }
@@ -101,3 +127,31 @@ impl<'de, T: serde::Deserialize<'de>> serde::Deserialize<'de> for SmallVec<T> {
         Ok(v)
     }
 }
+
+// TESTS #######################################################################
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn push_and_pop(comands: Vec<Option<u8>>) {
+            let mut v = vec![];
+            let mut sv = SmallVec::Empty;
+            for comand in comands {
+                match comand {
+                    Some(i) => {
+                        v.push(i);
+                        sv.push(i);
+                    }
+                    None => {
+                        assert_eq!(v.pop(), sv.pop());
+                    }
+                }
+                assert_eq!(v.as_slice(), sv.as_slice());
+            }
+        }
+    }
+}