Precompute DownstairsBlockContext as well

Author: mkeeter

downstairs/src/deferred.rs

@@ -1,4 +1,5 @@
 // Copyright 2023 Oxide Computer Company
+use crate::extent::DownstairsBlockContext;
 use crucible_common::{integrity_hash, CrucibleError};
 use crucible_protocol::Message;
 
@@ -16,24 +17,47 @@ pub(crate) enum DeferredMessage {
 pub(crate) struct PrecomputedWrite {
     /// Checks whether incoming hashes are valid
     pub validate_hashes_result: Result<(), CrucibleError>,
+    pub block_contexts: Vec<DownstairsBlockContext>,
 }
 
 impl PrecomputedWrite {
     #[cfg(test)]
     pub(crate) fn empty() -> Self {
         PrecomputedWrite {
             validate_hashes_result: Ok(()),
+            block_contexts: vec![],
         }
     }
 
     /// Precomputes relevant data from a set of writes
     pub(crate) fn from_writes(writes: &[crucible_protocol::Write]) -> Self {
         let validate_hashes_result = Self::validate_hashes(writes);
+        let block_contexts = Self::compute_block_contexts(writes);
         PrecomputedWrite {
             validate_hashes_result,
+            block_contexts,
         }
     }
 
+    fn compute_block_contexts(
+        writes: &[crucible_protocol::Write],
+    ) -> Vec<DownstairsBlockContext> {
+        writes
+            .iter()
+            .map(|write| {
+                // TODO it would be nice if we could profile what % of time we're
+                // spending on hashes locally vs writing to disk
+                let on_disk_hash = integrity_hash(&[&write.data[..]]);
+
+                DownstairsBlockContext {
+                    block_context: write.block_context,
+                    block: write.offset.value,
+                    on_disk_hash,
+                }
+            })
+            .collect()
+    }
+
     fn validate_hashes(
         writes: &[crucible_protocol::Write],
     ) -> Result<(), CrucibleError> {

downstairs/src/extent.rs

@@ -52,10 +52,29 @@ pub(crate) trait ExtentInner: Send + Sync + Debug {
         &mut self,
         job_id: JobId,
         writes: &[crucible_protocol::Write],
+        ctxs: &[DownstairsBlockContext],
         only_write_unwritten: bool,
         iov_max: usize,
     ) -> Result<(), CrucibleError>;
 
+    #[cfg(test)]
+    fn write_without_precomputed_contexts(
+        &mut self,
+        job_id: JobId,
+        writes: &[crucible_protocol::Write],
+        only_write_unwritten: bool,
+        iov_max: usize,
+    ) -> Result<(), CrucibleError> {
+        let pre = PrecomputedWrite::from_writes(writes);
+        self.write(
+            job_id,
+            writes,
+            &pre.block_contexts,
+            only_write_unwritten,
+            iov_max,
+        )
+    }
+
     #[cfg(test)]
     fn get_block_contexts(
         &mut self,
@@ -75,7 +94,7 @@ pub(crate) trait ExtentInner: Send + Sync + Debug {
 }
 
 /// BlockContext, with the addition of block index and on_disk_hash
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct DownstairsBlockContext {
     pub block_context: BlockContext,
 
@@ -536,6 +555,7 @@ impl Extent {
         &mut self,
         job_id: JobId,
         writes: &[crucible_protocol::Write],
+        ctxs: &[DownstairsBlockContext],
         only_write_unwritten: bool,
     ) -> Result<(), CrucibleError> {
         if self.read_only {
@@ -546,8 +566,13 @@ impl Extent {
             (job_id.0, self.number, writes.len() as u64)
         });
 
-        self.inner
-            .write(job_id, writes, only_write_unwritten, self.iov_max)?;
+        self.inner.write(
+            job_id,
+            writes,
+            ctxs,
+            only_write_unwritten,
+            self.iov_max,
+        )?;
 
         cdt::extent__write__done!(|| {
             (job_id.0, self.number, writes.len() as u64)