reduce conversions in encode

storage-proofs-porep/src/encode.rs

@@ -2,13 +2,17 @@ use blstrs::Scalar as Fr;
 use filecoin_hashers::Domain;
 
 pub fn encode<T: Domain>(key: T, value: T) -> T {
-    let mut result: Fr = value.into();
-    let key: Fr = key.into();
+    let value: Fr = value.into();
+    let mut result: Fr = key.into();
 
-    result += key;
+    encode_fr(&mut result, value);
     result.into()
 }
 
+pub fn encode_fr(key: &mut Fr, value: Fr) {
+    *key += value;
+}
+
 pub fn decode<T: Domain>(key: T, value: T) -> T {
     let mut result: Fr = value.into();
     let key: Fr = key.into();

storage-proofs-porep/src/stacked/vanilla/proof.rs

@@ -9,6 +9,7 @@ use anyhow::Context;
 use bincode::deserialize;
 use blstrs::Scalar as Fr;
 use fdlimit::raise_fd_limit;
+use ff::PrimeField;
 use filecoin_hashers::{poseidon::PoseidonHasher, Domain, HashFunction, Hasher, PoseidonArity};
 use generic_array::typenum::{Unsigned, U0, U11, U2, U8};
 use lazy_static::lazy_static;
@@ -37,7 +38,7 @@ use storage_proofs_core::{
 use yastl::Pool;
 
 use crate::{
-    encode::{decode, encode},
+    encode::{decode, encode_fr},
     stacked::vanilla::{
         challenges::LayerChallenges,
         column::Column,
@@ -851,14 +852,18 @@ impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> StackedDrg<'a, Tr
                                 <Tree::Hasher as Hasher>::Domain::try_from_bytes(data_node_bytes)
                                     .expect("try_from_bytes failed");
 
-                            let encoded_node =
-                                encode::<<Tree::Hasher as Hasher>::Domain>(key.into(), data_node);
-                            data_node_bytes.copy_from_slice(AsRef::<[u8]>::as_ref(&encoded_node));
+                            let mut encoded_fr: Fr = key.into();
+                            let data_node_fr: Fr = data_node.into();
+                            encode_fr(&mut encoded_fr, data_node_fr);
+                            let encoded_fr_repr = encoded_fr.to_repr();
+                            data_node_bytes
+                                .copy_from_slice(AsRef::<[u8]>::as_ref(&encoded_fr_repr));
 
-                            encoded_node
-                        });
+                            encoded_fr
+                        })
+                        .collect();
 
-                    Ok(encoded_data.into_par_iter().map(|x| x.into()).collect())
+                    Ok(encoded_data)
                 },
             };
 
@@ -891,14 +896,19 @@ impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> StackedDrg<'a, Tr
                             let data_node =
                                 <Tree::Hasher as Hasher>::Domain::try_from_bytes(data_node_bytes)
                                     .expect("try from bytes failed");
-                            let encoded_node =
-                                encode::<<Tree::Hasher as Hasher>::Domain>(key, data_node);
-                            data_node_bytes.copy_from_slice(AsRef::<[u8]>::as_ref(&encoded_node));
 
-                            encoded_node
-                        });
+                            let mut encoded_fr: Fr = key.into();
+                            let data_node_fr: Fr = data_node.into();
+                            encode_fr(&mut encoded_fr, data_node_fr);
+                            let encoded_fr_repr = encoded_fr.to_repr();
+                            data_node_bytes
+                                .copy_from_slice(AsRef::<[u8]>::as_ref(&encoded_fr_repr));
+
+                            encoded_fr
+                        })
+                        .collect();
 
-                    Ok(encoded_data.into_par_iter().map(|x| x.into()).collect())
+                    Ok(encoded_data)
                 },
             };
 
@@ -946,14 +956,18 @@ impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> StackedDrg<'a, Tr
                         let data_node =
                             <Tree::Hasher as Hasher>::Domain::try_from_bytes(data_node_bytes)
                                 .expect("try from bytes failed");
-                        let encoded_node =
-                            encode::<<Tree::Hasher as Hasher>::Domain>(key, data_node);
-                        data_node_bytes.copy_from_slice(AsRef::<[u8]>::as_ref(&encoded_node));
 
-                        encoded_node
-                    });
+                        let mut encoded_fr: Fr = key.into();
+                        let data_node_fr: Fr = data_node.into();
+                        encode_fr(&mut encoded_fr, data_node_fr);
+                        let encoded_fr_repr = encoded_fr.to_repr();
+                        data_node_bytes.copy_from_slice(AsRef::<[u8]>::as_ref(&encoded_fr_repr));
+
+                        encoded_fr
+                    })
+                    .collect();
 
-                Ok(encoded_data.into_par_iter().map(|x| x.into()).collect())
+                Ok(encoded_data)
             },
         };
 
@@ -1170,8 +1184,6 @@ impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> StackedDrg<'a, Tr
             let encoded_data = callback(&source, Some(data), start, end)
                 .expect("failed to prepare tree_r_last data");
 
-            let encoded_data: Vec<_> = encoded_data.into_par_iter().map(|x| x.into()).collect();
-
             info!(
                 "building base tree_r_last with CPU {}/{}",
                 i + 1,
@@ -1192,7 +1204,7 @@ impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> StackedDrg<'a, Tr
             }
 
             LCTree::<Tree::Hasher, Tree::Arity, U0, U0>::from_par_iter_with_config(
-                encoded_data,
+                encoded_data.into_par_iter().map(Into::into),
                 config.clone(),
             )
             .with_context(|| format!("failed tree_r_last CPU {}/{}", i + 1, tree_count))?;