[WIP] Implement Eq and Clone for ZigZagGraph

Author: schomatis

Diff for: storage-proofs/src/zigzag_graph.rs

@@ -10,7 +10,7 @@ use crate::parameter_cache::ParameterSetIdentifier;
 
 pub const DEFAULT_EXPANSION_DEGREE: usize = 8;
 
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug)]
 pub struct ZigZagGraph<H, G>
 where
     H: Hasher,
@@ -87,7 +87,7 @@ pub trait ZigZag: ::std::fmt::Debug + Clone + PartialEq + Eq {
     fn reversed(&self) -> bool;
     fn expanded_parents(&self, node: usize) -> Vec<usize>;
     fn real_index(&self, i: usize) -> usize;
-    fn parents_cache(&self) -> RwLock<HashMap<usize, Vec<usize>>>;
+    fn parents_cache(&self) -> &RwLock<HashMap<usize, Vec<usize>>>;
     fn new_zigzag(
         nodes: usize,
         base_degree: usize,
@@ -155,6 +155,7 @@ impl<Z: ZigZag> Graph<Z::BaseHasher> for Z {
     fn forward(&self) -> bool {
         !self.reversed()
     }
+
 }
 
 impl<'a, H, G> ZigZagGraph<H, G>
@@ -183,6 +184,7 @@ where
         };
         transformed as usize / self.expansion_degree
     }
+
 }
 
 impl<'a, H, G> ZigZag for ZigZagGraph<H, G>
@@ -230,10 +232,16 @@ where
     #[inline]
     fn expanded_parents(&self, node: usize) -> Vec<usize> {
 
-//        let parents_cache = self.parents_cache().read().unwrap();
-//        if (*parents_cache).contains_key(&node) {
-//            return (*parents_cache)[&node].clone();
-//        }
+        {
+            let parents_cache = self.parents_cache().read().unwrap();
+            if (*parents_cache).contains_key(&node) {
+                return (*parents_cache)[&node].clone();
+                // TODO(dig): We should change the signature to return a &[]u8 instead,
+                // cloning vectors is expensive, and reduces teh usefullness of the cache.
+            }
+            // Release the read lock (a write one will be taken later).
+            // TODO: Is this necessary? Can we keep a single write lock across the entire function?
+        }
 
         let parents: Vec<usize> = (0..self.expansion_degree)
             .filter_map(|i| {
@@ -252,8 +260,8 @@ where
             })
             .collect();
 
-//        let mut parents_cache = self.parents_cache().write().unwrap();
-//        (*parents_cache).insert(node, parents.clone());
+        let mut parents_cache = self.parents_cache().write().unwrap();
+        (*parents_cache).insert(node, parents.clone());
 
         parents
     }
@@ -267,11 +275,46 @@ where
         }
     }
 
-    fn parents_cache(&self) -> RwLock<HashMap<usize, Vec<usize>>> {
-        self.parents_cache
+    fn parents_cache(&self) -> &RwLock<HashMap<usize, Vec<usize>>> {
+        &self.parents_cache
+    }
+}
+
+impl<H, G> Clone for ZigZagGraph<H, G>
+    where
+        H: Hasher,
+        G: Graph<H>,
+{
+    fn clone(&self) -> ZigZagGraph<H, G> {
+        ZigZagGraph {
+            base_graph: self.base_graph.clone(),
+            expansion_degree: self.expansion_degree,
+            reversed: self.reversed,
+            feistel_precomputed: feistel::precompute((self.expansion_degree * self.size()) as u32),
+            parents_cache: RwLock::new(HashMap::new()),
+            _h: PhantomData,
+        }
+    }
+}
+
+impl<H, G> PartialEq for ZigZagGraph<H, G>
+    where
+        H: Hasher,
+        G: Graph<H>,
+{
+    fn eq(&self, other: &ZigZagGraph<H, G>) -> bool {
+        self.base_graph == other.base_graph &&
+            self.expansion_degree == other.expansion_degree &&
+            self.reversed == other.reversed
     }
 }
 
+impl<H, G> Eq for ZigZagGraph<H, G>
+    where
+        H: Hasher,
+        G: Graph<H>,
+{}
+
 #[cfg(test)]
 mod tests {
     use super::*;