perf(storage-proofs): optimize sdr replication

* perf(storage-proofs): improve thread handling during sdr encoding
* feat(storage-proofs): implement updatable pedersen md hasher
* perf(storage-proofs): column commitments in the background
* feat(storage-proofs): improve memory usage
* perf(storage-proofs): reduce allocations for expander parents
* perf(storage-proofs): split column hashing
* perf: build tree_d during encoding

Author: dignifiedquire

storage-proofs/Cargo.toml

@@ -48,6 +48,7 @@ log = "0.4.7"
 pretty_env_logger = "0.3.0"
 pretty_assertions = "0.6.1"
 crossbeam = "0.7.2"
+num_cpus = "1.10.1"
 
 [features]
 default = []

storage-proofs/benches/encode.rs

@@ -15,7 +15,7 @@ use storage_proofs::util::{data_at_node_offset, NODE_SIZE};
 
 struct Pregenerated<H: 'static + Hasher> {
     data: Vec<u8>,
-    parents: Vec<usize>,
+    parents: Vec<u32>,
     replica_id: H::Domain,
     graph: StackedBucketGraph<H>,
 }
@@ -25,7 +25,7 @@ fn pregenerate_data<H: Hasher>(degree: usize) -> Pregenerated<H> {
     let data: Vec<u8> = (0..(degree + 1))
         .flat_map(|_| fr_into_bytes::<Bls12>(&rng.gen()))
         .collect();
-    let parents: Vec<usize> = (0..degree).map(|pos| pos).collect();
+    let parents: Vec<u32> = (0..degree as u32).map(|pos| pos).collect();
     let replica_id: H::Domain = rng.gen();
 
     let graph = StackedBucketGraph::<H>::new_stacked(degree + 1, degree, 0, new_seed());
@@ -40,7 +40,7 @@ fn pregenerate_data<H: Hasher>(degree: usize) -> Pregenerated<H> {
 
 fn encode_single_node<H: Hasher>(
     data: &mut [u8],
-    parents: &[usize],
+    parents: &[u32],
     replica_id: &H::Domain,
     node: usize,
     graph: &StackedBucketGraph<H>,

storage-proofs/benches/parents.rs

@@ -44,7 +44,7 @@ fn pregenerate_graph<H: Hasher>(size: usize) -> StackedBucketGraph<H> {
     StackedBucketGraph::<H>::new_stacked(size, BASE_DEGREE, EXP_DEGREE, seed)
 }
 
-fn parents_loop<H: Hasher, G: Graph<H>>(graph: &G, parents: &mut [usize]) {
+fn parents_loop<H: Hasher, G: Graph<H>>(graph: &G, parents: &mut [u32]) {
     (0..graph.size())
         .map(|node| graph.parents(node, parents))
         .collect()

storage-proofs/src/circuit/drgporep.rs

@@ -186,14 +186,14 @@ where
 
         let mut parents = vec![0; pub_params.graph.degree()];
         for challenge in challenges {
-            let mut por_nodes = vec![*challenge];
+            let mut por_nodes = vec![*challenge as u32];
             pub_params.graph.parents(*challenge, &mut parents);
             por_nodes.extend_from_slice(&parents);
 
             for node in por_nodes {
                 let por_pub_inputs = merklepor::PublicInputs {
                     commitment: comm_r,
-                    challenge: node,
+                    challenge: node as usize,
                 };
                 let por_inputs = PoRCompound::<H>::generate_public_inputs(
                     &por_pub_inputs,

storage-proofs/src/circuit/stacked/column.rs

@@ -9,7 +9,7 @@ use crate::stacked::{Column as VanillaColumn, PublicParams};
 
 #[derive(Debug, Clone)]
 pub struct Column {
-    index: Option<usize>,
+    index: Option<u32>,
     rows: Vec<Option<Fr>>,
 }
 

storage-proofs/src/circuit/stacked/proof.rs

@@ -247,11 +247,12 @@ impl<'a, H: 'static + Hasher>
                 graph.base_graph().parents(challenge, &mut drg_parents);
 
                 for parent in drg_parents.into_iter() {
-                    inputs.extend(generate_inclusion_inputs(parent));
+                    inputs.extend(generate_inclusion_inputs(parent as usize));
                 }
 
                 // exp parents
-                let exp_parents = graph.expanded_parents(challenge, |p| p.clone());
+                let mut exp_parents = vec![0; graph.expansion_degree()];
+                graph.expanded_parents(challenge, &mut exp_parents);
                 for parent in exp_parents.into_iter() {
                     inputs.extend(generate_inclusion_inputs(parent as usize));
                 }

storage-proofs/src/crypto/pedersen.rs

@@ -65,6 +65,44 @@ where
     x.into()
 }
 
+#[derive(Debug, Clone)]
+pub struct Hasher {
+    curr: [u8; 32],
+}
+
+impl Hasher {
+    pub fn new(data: &[u8]) -> Self {
+        assert_eq!(data.len(), 32);
+        let mut curr = [0u8; 32];
+        curr.copy_from_slice(data);
+
+        Hasher { curr }
+    }
+
+    pub fn update(&mut self, data: &[u8]) {
+        assert_eq!(data.len(), 32);
+
+        let parts = [&self.curr, data];
+        let data = Bits::new_many(parts.iter());
+        let x = pedersen_compression_bits(data);
+
+        x.write_le(std::io::Cursor::new(&mut self.curr[..]))
+            .expect("failed to write result");
+    }
+
+    pub fn finalize_bytes(self) -> [u8; 32] {
+        let Hasher { curr } = self;
+        curr
+    }
+
+    pub fn finalize(self) -> Fr {
+        let frs =
+            bytes_into_frs::<Bls12>(&self.curr).expect("pedersen must generate valid fr elements");
+        assert_eq!(frs.len(), 1);
+        frs[0]
+    }
+}
+
 /// Creates an iterator over the byte slices in little endian format.
 #[derive(Debug, Clone)]
 pub struct Bits<K: AsRef<[u8]>, S: Iterator<Item = K>> {
@@ -326,4 +364,26 @@ mod tests {
 
         assert_eq!(bits, bits_collected);
     }
+
+    #[test]
+    fn test_pedersen_hasher_update() {
+        let rng = &mut XorShiftRng::from_seed([0x3dbe6259, 0x8d313d76, 0x3237db17, 0xe5bc0654]);
+
+        for _ in 2..5 {
+            let x: Vec<Vec<u8>> = (0..5)
+                .map(|_| (0..32).map(|_| rng.gen()).collect())
+                .collect();
+            let flat: Vec<u8> = x.iter().flatten().copied().collect();
+            let hashed = pedersen_md_no_padding(&flat);
+
+            let mut hasher = Hasher::new(&x[0]);
+            for k in 1..5 {
+                hasher.update(&x[k]);
+            }
+
+            let hasher_final = hasher.finalize();
+
+            assert_eq!(hashed, hasher_final);
+        }
+    }
 }

storage-proofs/src/drgporep.rs

@@ -129,7 +129,7 @@ impl<H: Hasher> DataProof<H> {
     }
 }
 
-pub type ReplicaParents<H> = Vec<(usize, DataProof<H>)>;
+pub type ReplicaParents<H> = Vec<(u32, DataProof<H>)>;
 
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct Proof<H: Hasher> {
@@ -292,10 +292,10 @@ where
 
             for p in &parents {
                 replica_parentsi.push((*p, {
-                    let proof = tree_r.gen_proof(*p);
+                    let proof = tree_r.gen_proof(*p as usize);
                     DataProof {
                         proof: MerkleProof::new_from_proof(&proof),
-                        data: tree_r.read_at(*p),
+                        data: tree_r.read_at(*p as usize),
                     }
                 }));
             }
@@ -384,7 +384,7 @@ where
             }
 
             for (parent_node, p) in &proof.replica_parents[i] {
-                if !p.proof.validate(*parent_node) {
+                if !p.proof.validate(*parent_node as usize) {
                     return Ok(false);
                 }
             }
@@ -717,7 +717,7 @@ mod tests {
                         // Rotate the real parent proofs.
                         let x = (i + 1) % real_parents[0].len();
                         let j = real_parents[0][x].0;
-                        (*p, real_parents[0][j].1.clone())
+                        (*p, real_parents[0][j as usize].1.clone())
                     })
                     .collect::<Vec<_>>()];
 

storage-proofs/src/drgraph.rs

@@ -84,7 +84,7 @@ pub trait Graph<H: Hasher>: ::std::fmt::Debug + Clone + PartialEq + Eq {
     ///
     /// The `parents` parameter is used to store the result. This is done fore performance
     /// reasons, so that the vector can be allocated outside this call.
-    fn parents(&self, node: usize, parents: &mut [usize]);
+    fn parents(&self, node: usize, parents: &mut [u32]);
 
     /// Returns the size of the graph (number of nodes).
     fn size(&self) -> usize;
@@ -101,7 +101,7 @@ pub trait Graph<H: Hasher>: ::std::fmt::Debug + Clone + PartialEq + Eq {
         &self,
         id: &H::Domain,
         node: usize,
-        parents: &[usize],
+        parents: &[u32],
         parents_data: &[u8],
         exp_parents_data: Option<&[u8]>,
     ) -> Result<Self::Key>;
@@ -143,17 +143,17 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
         &self,
         id: &H::Domain,
         node: usize,
-        parents: &[usize],
+        parents: &[u32],
         base_parents_data: &[u8],
         _exp_parents_data: Option<&[u8]>,
     ) -> Result<Self::Key> {
         let mut hasher = Blake2s::new().hash_length(NODE_SIZE).to_state();
         hasher.update(AsRef::<[u8]>::as_ref(id));
 
         // The hash is about the parents, hence skip if a node doesn't have any parents
-        if node != parents[0] {
+        if node != parents[0] as usize {
             for parent in parents.iter() {
-                let offset = data_at_node_offset(*parent);
+                let offset = data_at_node_offset(*parent as usize);
                 hasher.update(&base_parents_data[offset..offset + NODE_SIZE]);
             }
         }
@@ -163,7 +163,7 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
     }
 
     #[inline]
-    fn parents(&self, node: usize, parents: &mut [usize]) {
+    fn parents(&self, node: usize, parents: &mut [u32]) {
         let m = self.degree();
 
         match node {
@@ -198,15 +198,15 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
 
                     // remove self references and replace with reference to previous node
                     if out == node {
-                        *parent = node - 1;
+                        *parent = (node - 1) as u32;
                     } else {
                         assert!(out <= node);
-                        *parent = out;
+                        *parent = out as u32;
                     }
                 }
 
                 // Add the immediate predecessor as a parent to ensure unique topological ordering.
-                parents[m_prime] = node - 1;
+                parents[m_prime] = (node - 1) as u32;
             }
         }
     }
@@ -297,7 +297,7 @@ mod tests {
 
                 for parent in p1 {
                     // TODO: fix me
-                    assert_ne!(i, parent, "self reference found");
+                    assert_ne!(i, parent as usize, "self reference found");
                 }
             }
         }

storage-proofs/src/stacked/column.rs

@@ -7,29 +7,29 @@ use crate::stacked::{column_proof::ColumnProof, hash::hash_single_column, params
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Column<H: Hasher> {
-    pub(crate) index: usize,
+    pub(crate) index: u32,
     pub(crate) rows: Vec<H::Domain>,
     _h: PhantomData<H>,
 }
 
 impl<H: Hasher> Column<H> {
-    pub fn new(index: usize, rows: Vec<H::Domain>) -> Self {
+    pub fn new(index: u32, rows: Vec<H::Domain>) -> Self {
         Column {
             index,
             rows,
             _h: PhantomData,
         }
     }
 
-    pub fn with_capacity(index: usize, capacity: usize) -> Self {
+    pub fn with_capacity(index: u32, capacity: usize) -> Self {
         Column::new(index, Vec::with_capacity(capacity))
     }
 
     pub fn rows(&self) -> &[H::Domain] {
         &self.rows
     }
 
-    pub fn index(&self) -> usize {
+    pub fn index(&self) -> u32 {
         self.index
     }
 
@@ -46,7 +46,7 @@ impl<H: Hasher> Column<H> {
 
     /// Create a column proof for this column.
     pub fn into_proof(self, tree_c: &Tree<H>) -> ColumnProof<H> {
-        let inclusion_proof = MerkleProof::new_from_proof(&tree_c.gen_proof(self.index()));
+        let inclusion_proof = MerkleProof::new_from_proof(&tree_c.gen_proof(self.index() as usize));
         ColumnProof::<H>::from_column(self, inclusion_proof)
     }
 }