Merge pull request #2 from nikomatsakis/persistent

introduce possibility of using persistent vectors

Author: nikomatsakis

.travis.yml

@@ -1,5 +1,9 @@
 language: rust
 rust:
+  - stable
   - nightly
 script:
-  - cargo test
+  - cargo test
+  - |
+    [ $TRAVIS_RUST_VERSION != nightly ] ||
+    cargo test --all-features

Cargo.toml

@@ -10,7 +10,9 @@ authors = ["Niko Matsakis <niko@alum.mit.edu>"]
 [features]
 congruence-closure = [ "petgraph" ]
 bench = [ ]
+persistent = [ "dogged" ]
 
 [dependencies]
+dogged = { version = "0.2.0", optional = true }
 log = "0.3"
 petgraph = { version = "0.4.5", optional = true }

src/cc/mod.rs

@@ -9,14 +9,14 @@ use petgraph::graph::{Graph, NodeIndex};
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::hash::Hash;
-use unify::{NoError, UnifyKey, UnifyValue, UnificationTable, UnionedKeys};
+use unify::{NoError, InPlace, InPlaceUnificationTable, UnifyKey, UnifyValue, UnionedKeys};
 
 #[cfg(test)]
 mod test;
 
 pub struct CongruenceClosure<K: Key> {
     map: HashMap<K, Token>,
-    table: UnificationTable<Token>,
+    table: InPlaceUnificationTable<Token>,
     graph: Graph<K, ()>,
 }
 
@@ -110,7 +110,7 @@ impl<K: Key> CongruenceClosure<K> {
     pub fn new() -> CongruenceClosure<K> {
         CongruenceClosure {
             map: HashMap::new(),
-            table: UnificationTable::new(),
+            table: InPlaceUnificationTable::new(),
             graph: Graph::new(),
         }
     }
@@ -276,7 +276,7 @@ impl<K: Key> CongruenceClosure<K> {
 
 pub struct MergedKeys<'cc, K: Key + 'cc> {
     graph: &'cc Graph<K, ()>,
-    iterator: UnionedKeys<'cc, Token>,
+    iterator: UnionedKeys<'cc, InPlace<Token>>,
 }
 
 impl<'cc, K: Key> Iterator for MergedKeys<'cc, K> {
@@ -293,7 +293,7 @@ impl<'cc, K: Key> Iterator for MergedKeys<'cc, K> {
 
 struct Algorithm<'a, K: Key + 'a> {
     graph: &'a Graph<K, ()>,
-    table: &'a mut UnificationTable<Token>,
+    table: &'a mut InPlaceUnificationTable<Token>,
 }
 
 impl<'a, K: Key> Algorithm<'a, K> {

src/lib.rs

@@ -20,6 +20,9 @@
 #[macro_use]
 extern crate log;
 
+#[cfg(feature = "persistent")]
+extern crate dogged;
+
 #[cfg(feature = "congruence-closure")]
 extern crate petgraph;
 

src/snapshot_vec.rs

@@ -67,6 +67,13 @@ impl<D: SnapshotVecDelegate> SnapshotVec<D> {
         }
     }
 
+    pub fn with_capacity(c: usize) -> SnapshotVec<D> {
+        SnapshotVec {
+            values: Vec::with_capacity(c),
+            undo_log: Vec::new(),
+        }
+    }
+
     fn in_snapshot(&self) -> bool {
         !self.undo_log.is_empty()
     }

src/unify/backing_vec.rs

@@ -0,0 +1,167 @@
+#[cfg(feature = "persistent")]
+use dogged::DVec;
+use snapshot_vec as sv;
+use std::ops;
+use std::marker::PhantomData;
+
+use super::{VarValue, UnifyKey, UnifyValue};
+
+#[allow(dead_code)] // rustc BUG
+type Key<S> = <S as UnificationStore>::Key;
+
+/// Largely internal trait implemented by the unification table
+/// backing store types. The most common such type is `InPlace`,
+/// which indicates a standard, mutable unification table.
+pub trait UnificationStore: ops::Index<usize, Output = VarValue<Key<Self>>> + Clone {
+    type Key: UnifyKey<Value = Self::Value>;
+    type Value: UnifyValue;
+    type Snapshot;
+
+    fn new() -> Self;
+
+    fn start_snapshot(&mut self) -> Self::Snapshot;
+
+    fn rollback_to(&mut self, snapshot: Self::Snapshot);
+
+    fn commit(&mut self, snapshot: Self::Snapshot);
+
+    fn len(&self) -> usize;
+
+    fn push(&mut self, value: VarValue<Self::Key>);
+
+    fn update<F>(&mut self, index: usize, op: F)
+        where F: FnOnce(&mut VarValue<Self::Key>);
+
+    fn tag() -> &'static str {
+        Self::Key::tag()
+    }
+}
+
+/// Backing store for an in-place unification table.
+/// Not typically used directly.
+#[derive(Clone)]
+pub struct InPlace<K: UnifyKey> {
+    values: sv::SnapshotVec<Delegate<K>>
+}
+
+impl<K: UnifyKey> UnificationStore for InPlace<K> {
+    type Key = K;
+    type Value = K::Value;
+    type Snapshot = sv::Snapshot;
+
+    #[inline]
+    fn new() -> Self {
+        InPlace { values: sv::SnapshotVec::new() }
+    }
+
+    #[inline]
+    fn start_snapshot(&mut self) -> Self::Snapshot {
+        self.values.start_snapshot()
+    }
+
+    #[inline]
+    fn rollback_to(&mut self, snapshot: Self::Snapshot) {
+        self.values.rollback_to(snapshot);
+    }
+
+    #[inline]
+    fn commit(&mut self, snapshot: Self::Snapshot) {
+        self.values.commit(snapshot);
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    #[inline]
+    fn push(&mut self, value: VarValue<Self::Key>) {
+        self.values.push(value);
+    }
+
+    #[inline]
+    fn update<F>(&mut self, index: usize, op: F)
+        where F: FnOnce(&mut VarValue<Self::Key>)
+    {
+        self.values.update(index, op)
+    }
+}
+
+impl<K> ops::Index<usize> for InPlace<K>
+    where K: UnifyKey
+{
+    type Output = VarValue<K>;
+    fn index(&self, index: usize) -> &VarValue<K> {
+        &self.values[index]
+    }
+}
+
+#[derive(Copy, Clone)]
+struct Delegate<K>(PhantomData<K>);
+
+impl<K: UnifyKey> sv::SnapshotVecDelegate for Delegate<K> {
+    type Value = VarValue<K>;
+    type Undo = ();
+
+    fn reverse(_: &mut Vec<VarValue<K>>, _: ()) {}
+}
+
+#[cfg(feature = "persistent")]
+#[derive(Clone)]
+pub struct Persistent<K: UnifyKey> {
+    values: DVec<VarValue<K>>
+}
+
+#[cfg(feature = "persistent")]
+impl<K: UnifyKey> UnificationStore for Persistent<K> {
+    type Key = K;
+    type Value = K::Value;
+    type Snapshot = Self;
+
+    #[inline]
+    fn new() -> Self {
+        Persistent { values: DVec::new() }
+    }
+
+    #[inline]
+    fn start_snapshot(&mut self) -> Self::Snapshot {
+        self.clone()
+    }
+
+    #[inline]
+    fn rollback_to(&mut self, snapshot: Self::Snapshot) {
+        *self = snapshot;
+    }
+
+    #[inline]
+    fn commit(&mut self, _snapshot: Self::Snapshot) {
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    #[inline]
+    fn push(&mut self, value: VarValue<Self::Key>) {
+        self.values.push(value);
+    }
+
+    #[inline]
+    fn update<F>(&mut self, index: usize, op: F)
+        where F: FnOnce(&mut VarValue<Self::Key>)
+    {
+        let p = &mut self.values[index];
+        op(p);
+    }
+}
+
+#[cfg(feature = "persistent")]
+impl<K> ops::Index<usize> for Persistent<K>
+    where K: UnifyKey
+{
+    type Output = VarValue<K>;
+    fn index(&self, index: usize) -> &VarValue<K> {
+        &self.values[index]
+    }
+}