From 91b10e67e72ae467198178dcec7b854326a3f0a6 Mon Sep 17 00:00:00 2001 From: Mac L Date: Tue, 11 Jul 2023 13:33:43 +1000 Subject: [PATCH 1/2] Compute hash on demand --- src/packed_leaf.rs | 41 +++++++++++++---------------------------- src/tests/size_of.rs | 14 +++++++------- src/tree.rs | 10 ++++------ 3 files changed, 24 insertions(+), 41 deletions(-) diff --git a/src/packed_leaf.rs b/src/packed_leaf.rs index b0f3770..735942d 100644 --- a/src/packed_leaf.rs +++ b/src/packed_leaf.rs @@ -1,16 +1,12 @@ -use crate::{utils::arb_rwlock, Error, UpdateMap}; +use crate::{Error, UpdateMap}; use arbitrary::Arbitrary; use derivative::Derivative; -use parking_lot::RwLock; use std::ops::ControlFlow; use tree_hash::{Hash256, TreeHash, BYTES_PER_CHUNK}; #[derive(Debug, Derivative, Arbitrary)] #[derivative(PartialEq, Hash)] pub struct PackedLeaf { - #[derivative(PartialEq = "ignore", Hash = "ignore")] - #[arbitrary(with = arb_rwlock)] - pub hash: RwLock, pub(crate) values: Vec, } @@ -20,7 +16,6 @@ where { fn clone(&self) -> Self { Self { - hash: RwLock::new(*self.hash.read()), values: self.values.clone(), } } @@ -28,13 +23,15 @@ where impl PackedLeaf { pub fn tree_hash(&self) -> Hash256 { - let read_lock = self.hash.read(); - let mut hash = *read_lock; - drop(read_lock); + //let read_lock = self.hash.read(); + //let mut hash = *read_lock; + //drop(read_lock); - if !hash.is_zero() { - return hash; - } + //if !hash.is_zero() { + // return hash; + //} + + let mut hash = Hash256::zero(); let hash_bytes = hash.as_bytes_mut(); @@ -44,13 +41,11 @@ impl PackedLeaf { .copy_from_slice(&value.tree_hash_packed_encoding()); } - *self.hash.write() = hash; hash } pub fn empty() -> Self { PackedLeaf { - hash: RwLock::new(Hash256::zero()), values: Vec::with_capacity(T::tree_hash_packing_factor()), } } @@ -59,23 +54,18 @@ impl PackedLeaf { let mut values = Vec::with_capacity(T::tree_hash_packing_factor()); values.push(value); - PackedLeaf { - hash: RwLock::new(Hash256::zero()), - values, - } + PackedLeaf { values } } pub fn repeat(value: T, n: usize) -> Self { assert!(n <= T::tree_hash_packing_factor()); PackedLeaf { - hash: RwLock::new(Hash256::zero()), values: vec![value; n], } } pub fn insert_at_index(&self, index: usize, value: T) -> Result { let mut updated = PackedLeaf { - hash: RwLock::new(Hash256::zero()), values: self.values.clone(), }; let sub_index = index % T::tree_hash_packing_factor(); @@ -83,14 +73,8 @@ impl PackedLeaf { Ok(updated) } - pub fn update>( - &self, - prefix: usize, - hash: Hash256, - updates: &U, - ) -> Result { + pub fn update>(&self, prefix: usize, updates: &U) -> Result { let mut updated = PackedLeaf { - hash: RwLock::new(hash), values: self.values.clone(), }; @@ -105,7 +89,8 @@ impl PackedLeaf { pub fn insert_mut(&mut self, sub_index: usize, value: T) -> Result<(), Error> { // Ensure hash is 0. - *self.hash.get_mut() = Hash256::zero(); + //*self.hash.get_mut() = Hash256::zero(); + // TODO(mac) might need another check here if sub_index == self.values.len() { self.values.push(value); diff --git a/src/tests/size_of.rs b/src/tests/size_of.rs index 00e0b9d..048960a 100644 --- a/src/tests/size_of.rs +++ b/src/tests/size_of.rs @@ -6,9 +6,9 @@ use tree_hash::Hash256; /// It's important that the Tree nodes have a predictable size. #[test] fn size_of_hash256() { - assert_eq!(size_of::>(), 72); + assert_eq!(size_of::>(), 64); assert_eq!(size_of::>(), 48); - assert_eq!(size_of::>(), 64); + assert_eq!(size_of::>(), 24); let rw_lock_size = size_of::>(); assert_eq!(rw_lock_size, 40); @@ -18,19 +18,19 @@ fn size_of_hash256() { assert_eq!( size_of::>(), - size_of::>() + 8 + size_of::>() + 40 ); } /// It's important that the Tree nodes have a predictable size. #[test] fn size_of_u8() { - assert_eq!(size_of::>(), 72); + assert_eq!(size_of::>(), 64); assert_eq!(size_of::>(), 48); - assert_eq!(size_of::>(), 64); + assert_eq!(size_of::>(), 24); assert_eq!( size_of::>(), - size_of::>() + size_of::>() + size_of::>() ); let rw_lock_size = size_of::>(); @@ -39,5 +39,5 @@ fn size_of_u8() { let arc_size = size_of::>>(); assert_eq!(arc_size, 8); - assert_eq!(size_of::>(), size_of::>() + 8); + assert_eq!(size_of::>(), size_of::>() + 40); } diff --git a/src/tree.rs b/src/tree.rs index e900289..8567b4e 100644 --- a/src/tree.rs +++ b/src/tree.rs @@ -176,7 +176,7 @@ impl Tree { Ok(Self::leaf_with_hash(value, hash)) } Self::PackedLeaf(packed_leaf) if depth == 0 => Ok(Arc::new(Self::PackedLeaf( - packed_leaf.update(prefix, hash, updates)?, + packed_leaf.update(prefix, updates)?, ))), Self::Node { left, right, .. } if depth > 0 => { let packing_depth = opt_packing_depth::().unwrap_or(0); @@ -217,7 +217,7 @@ impl Tree { Self::Zero(zero_depth) if *zero_depth == depth => { if depth == 0 { if opt_packing_factor::().is_some() { - let packed_leaf = PackedLeaf::empty().update(prefix, hash, updates)?; + let packed_leaf = PackedLeaf::empty().update(prefix, updates)?; Ok(Arc::new(Self::PackedLeaf(packed_leaf))) } else { let index = prefix; @@ -270,8 +270,7 @@ impl Tree { } } if !equal { - let hash = *l2.hash.read(); - diff.hashes.insert((depth, prefix), hash); + diff.hashes.insert((depth, prefix), l2.tree_hash()); } Ok(()) } @@ -342,8 +341,7 @@ impl Tree { Ok(()) } Self::PackedLeaf(packed_leaf) if depth == 0 => { - diff.hashes - .insert((depth, prefix), *packed_leaf.hash.read()); + diff.hashes.insert((depth, prefix), packed_leaf.tree_hash()); for (i, value) in packed_leaf.values.iter().enumerate() { diff.leaves.insert(prefix | i, value.clone()); } From d8c068d370cea1da762ff1478400e3b4a4c16263 Mon Sep 17 00:00:00 2001 From: Mac L Date: Tue, 11 Jul 2023 13:38:17 +1000 Subject: [PATCH 2/2] Formatting --- src/packed_leaf.rs | 12 ------------ src/tests/size_of.rs | 5 +---- 2 files changed, 1 insertion(+), 16 deletions(-) diff --git a/src/packed_leaf.rs b/src/packed_leaf.rs index 735942d..ddfc0ed 100644 --- a/src/packed_leaf.rs +++ b/src/packed_leaf.rs @@ -23,14 +23,6 @@ where impl PackedLeaf { pub fn tree_hash(&self) -> Hash256 { - //let read_lock = self.hash.read(); - //let mut hash = *read_lock; - //drop(read_lock); - - //if !hash.is_zero() { - // return hash; - //} - let mut hash = Hash256::zero(); let hash_bytes = hash.as_bytes_mut(); @@ -88,10 +80,6 @@ impl PackedLeaf { } pub fn insert_mut(&mut self, sub_index: usize, value: T) -> Result<(), Error> { - // Ensure hash is 0. - //*self.hash.get_mut() = Hash256::zero(); - // TODO(mac) might need another check here - if sub_index == self.values.len() { self.values.push(value); } else if sub_index < self.values.len() { diff --git a/src/tests/size_of.rs b/src/tests/size_of.rs index 048960a..1cdbea9 100644 --- a/src/tests/size_of.rs +++ b/src/tests/size_of.rs @@ -28,10 +28,7 @@ fn size_of_u8() { assert_eq!(size_of::>(), 64); assert_eq!(size_of::>(), 48); assert_eq!(size_of::>(), 24); - assert_eq!( - size_of::>(), - size_of::>() - ); + assert_eq!(size_of::>(), size_of::>()); let rw_lock_size = size_of::>(); assert_eq!(rw_lock_size, 16);