feat(filecoin-proofs): generate_post and seal both accept cache dir-path

Author: laser

fil-proofs-tooling/src/bin/benchy/rational_post.rs

@@ -82,11 +82,13 @@ pub fn run(sector_size: usize) -> Result<(), failure::Error> {
 
     // Replicate the staged sector, write the replica file to `sealed_path`.
     let porep_config = PoRepConfig(SectorSize(sector_size as u64), N_PARTITIONS);
+    let cache_dir = tempfile::tempdir().unwrap();
     let sector_id = SectorId::from(SECTOR_ID);
     let ticket = [0u8; 32];
 
     let seal_output = seal(
         porep_config,
+        cache_dir.path(),
         staged_file.path(),
         sealed_file.path(),
         PROVER_ID,
@@ -104,7 +106,12 @@ pub fn run(sector_size: usize) -> Result<(), failure::Error> {
 
     priv_replica_info.insert(
         sector_id,
-        PrivateReplicaInfo::new(sealed_path_string, seal_output.comm_r, seal_output.p_aux),
+        PrivateReplicaInfo::new(
+            sealed_path_string,
+            seal_output.comm_r,
+            seal_output.p_aux,
+            cache_dir.into_path(),
+        ),
     );
 
     // Measure PoSt generation and verification.

filecoin-proofs/src/api/mod.rs

@@ -150,22 +150,27 @@ fn generate_piece_specs_from_source(
 /// Seals the staged sector at `in_path` in place, saving the resulting replica
 /// to `out_path`.
 ///
+#[allow(clippy::too_many_arguments)]
 pub fn seal<T: AsRef<Path>>(
     porep_config: PoRepConfig,
-    in_path: T,
-    out_path: T,
+    _cache_dir: T,
+    staged_sector: T,
+    sealed_sector: T,
     prover_id: ProverId,
     sector_id: SectorId,
     ticket: Ticket,
     piece_lengths: &[UnpaddedBytesAmount],
 ) -> error::Result<SealOutput> {
     let sector_bytes = usize::from(PaddedBytesAmount::from(porep_config));
 
-    let mut cleanup = FileCleanup::new(&out_path);
+    let mut cleanup = FileCleanup::new(&sealed_sector);
 
     // Copy unsealed data to output location, where it will be sealed in place.
-    copy(&in_path, &out_path)?;
-    let f_data = OpenOptions::new().read(true).write(true).open(&out_path)?;
+    copy(&staged_sector, &sealed_sector)?;
+    let f_data = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .open(&sealed_sector)?;
 
     // Zero-pad the data to the requested size by extending the underlying file if needed.
     f_data.set_len(sector_bytes as u64)?;
@@ -202,7 +207,7 @@ pub fn seal<T: AsRef<Path>>(
         Some(data_tree),
     )?;
 
-    let mut in_data = OpenOptions::new().read(true).open(&in_path)?;
+    let mut in_data = OpenOptions::new().read(true).open(&staged_sector)?;
     let piece_specs = generate_piece_specs_from_source(&mut in_data, &piece_lengths)?;
     let piece_inclusion_proofs =
         piece_inclusion_proofs::<PedersenHasher>(&piece_specs, &t_aux.tree_d)?;
@@ -699,9 +704,11 @@ mod tests {
 
         let sealed_sector_file = NamedTempFile::new()?;
         let config = PoRepConfig(SectorSize(sector_size.clone()), PoRepProofPartitions(2));
+        let cache_dir = tempfile::tempdir().unwrap();
 
         let output = seal(
             config,
+            cache_dir.path(),
             &staged_sector_file.path(),
             &sealed_sector_file.path(),
             [0; 32],

filecoin-proofs/src/api/post.rs

@@ -19,6 +19,7 @@ use crate::caches::{get_post_params, get_post_verifying_key};
 use crate::error;
 use crate::parameters::{post_setup_params, public_params};
 use crate::types::{PaddedBytesAmount, PoStConfig};
+use std::path::PathBuf;
 
 /// The minimal information required about a replica, in order to be able to generate
 /// a PoSt over it.
@@ -32,6 +33,8 @@ pub struct PrivateReplicaInfo {
     aux: PersistentAux,
     /// Is this sector marked as a fault?
     is_fault: bool,
+    /// Contains sector-specific (e.g. merkle trees) assets
+    cache_dir: PathBuf,
 }
 
 impl std::cmp::Ord for PrivateReplicaInfo {
@@ -47,21 +50,28 @@ impl std::cmp::PartialOrd for PrivateReplicaInfo {
 }
 
 impl PrivateReplicaInfo {
-    pub fn new(access: String, comm_r: Commitment, aux: PersistentAux) -> Self {
+    pub fn new(access: String, comm_r: Commitment, aux: PersistentAux, cache_dir: PathBuf) -> Self {
         PrivateReplicaInfo {
             access,
             comm_r,
             aux,
             is_fault: false,
+            cache_dir,
         }
     }
 
-    pub fn new_faulty(access: String, comm_r: Commitment, aux: PersistentAux) -> Self {
+    pub fn new_faulty(
+        access: String,
+        comm_r: Commitment,
+        aux: PersistentAux,
+        cache_dir: PathBuf,
+    ) -> Self {
         PrivateReplicaInfo {
             access,
             comm_r,
             aux,
             is_fault: true,
+            cache_dir,
         }
     }