remove a few todos and fix bench (except memdb).

memory-db/benches/bench.rs

@@ -24,12 +24,13 @@ extern crate memory_db;
 extern crate keccak_hasher;
 
 use memory_db::MemoryDB;
+use memory_db::HashKey;
 use keccak_hasher::KeccakHasher;
-use hash_db::{HashDB, Hasher};
+use hash_db::{HashDB, Hasher, EMPTY_PREFIX};
 
 fn instantiation(b: &mut Criterion) {
 	b.bench_function("instantiation", |b| b.iter(|| {
-		MemoryDB::<KeccakHasher, Vec<u8>>::default();
+		MemoryDB::<KeccakHasher, HashKey<KeccakHasher>, Vec<u8>>::default();
 	}));
 }
 
@@ -52,19 +53,19 @@ fn compare_to_null_in_const(b: &mut Criterion) {
 }
 
 fn contains_with_non_null_key(b: &mut Criterion) {
-	let mut m = MemoryDB::<KeccakHasher, Vec<u8>>::default();
+	let mut m = MemoryDB::<KeccakHasher, HashKey<KeccakHasher>, Vec<u8>>::default();
 	let key = KeccakHasher::hash(b"abc");
-	m.insert(b"abcefghijklmnopqrstuvxyz");
+	m.insert(EMPTY_PREFIX, b"abcefghijklmnopqrstuvxyz");
 	b.bench_function("contains_with_non_null_key", |b| b.iter(|| {
-		m.contains(&key);
+		m.contains(&key, EMPTY_PREFIX);
 	}));
 }
 
 fn contains_with_null_key(b: &mut Criterion) {
-	let mut m = MemoryDB::<KeccakHasher, Vec<u8>>::default();
+	let mut m = MemoryDB::<KeccakHasher, HashKey<KeccakHasher>, Vec<u8>>::default();
 	let null_key = KeccakHasher::hash(&[0u8][..]);
-	m.insert(b"abcefghijklmnopqrstuvxyz");
+	m.insert(EMPTY_PREFIX, b"abcefghijklmnopqrstuvxyz");
 	b.bench_function("contains_with_null_key", |b| b.iter(|| {
-		m.contains(&null_key);
+		m.contains(&null_key, EMPTY_PREFIX);
 	}));
 }

test-support/reference-trie/benches/bench.rs

@@ -24,8 +24,7 @@ extern crate trie_bench;
 
 fn benchmark(c: &mut Criterion) {
 	trie_bench::standard_benchmark::<
-		keccak_hasher::KeccakHasher,
-		reference_trie::ReferenceNodeCodec,
+		reference_trie::LayoutOri,
 		reference_trie::ReferenceTrieStream,
 	>(c, "ref");
 }

test-support/reference-trie/src/lib.rs

@@ -1005,16 +1005,17 @@ pub fn compare_impl_no_ext_q(
 
 	if root != root_new {
 		{
-			let db : &dyn hash_db::HashDB<_,_> = &memdb;
-			let t = RefTrieDBNoExtQ::new(&db, &root).unwrap();
+			let db : &dyn hash_db::HashDB<_,_> = &hashdb;
+			let t = RefTrieDBNoExtQ::new(&db, &root_new).unwrap();
 			println!("{:?}", t);
 			for a in t.iter().unwrap() {
 				println!("a:{:?}", a);
 			}
 		}
+
 		{
-			let db : &dyn hash_db::HashDB<_,_> = &hashdb;
-			let t = RefTrieDBNoExtQ::new(&db, &root_new).unwrap();
+			let db : &dyn hash_db::HashDB<_,_> = &memdb;
+			let t = RefTrieDBNoExtQ::new(&db, &root).unwrap();
 			println!("{:?}", t);
 			for a in t.iter().unwrap() {
 				println!("a:{:?}", a);

trie-db/benches/bench.rs

@@ -26,7 +26,7 @@ extern crate trie_standardmap;
 extern crate trie_db;
 extern crate rand;
 use trie_standardmap::{Alphabet, StandardMap, ValueMode};
-use trie_db::NibbleSlice;
+use trie_db::{NibbleSlice, NibbleHalf};
 
 fn nibble_common_prefix(b: &mut Criterion) {
 	let st = StandardMap {
@@ -39,7 +39,7 @@ fn nibble_common_prefix(b: &mut Criterion) {
 	let (keys, values): (Vec<_>, Vec<_>) = st.make().into_iter().unzip();
 	b.bench_function("nibble_common_prefix", move |b| {
 		let mixed: Vec<_> = keys.iter().zip(values.iter().rev()).map(|pair| {
-			(NibbleSlice::new(pair.0), NibbleSlice::new(pair.1))
+			(NibbleSlice::<NibbleHalf>::new(pair.0), NibbleSlice::<NibbleHalf>::new(pair.1))
 		}).collect();
 
 		b.iter(&mut ||{

trie-db/src/iter_build.rs

@@ -21,28 +21,6 @@ use crate::nibble::NibbleSlice;
 use crate::nibble::NibbleOps;
 use node_codec::NodeCodec;
 
-// TODO EMCH use L instead of HC (aka TrieLayout)
-// TODO EMCH move to NibbleOps to use right constants
-fn biggest_depth<N: NibbleOps>(v1: &[u8], v2: &[u8]) -> usize {
-	// sorted assertion preventing out of bound
-	for a in 0..v1.len() {
-		if v1[a] == v2[a] {
-		} else {
-			return a * N::NIBBLE_PER_BYTE + N::left_common(v1[a], v2[a]);
-		}
-	}
-	return v1.len() * N::NIBBLE_PER_BYTE;
-}
-
-// warn! start at 0 // TODO change biggest_depth??
-// warn! slow don't loop on that when possible
-#[inline(always)]
-fn nibble_at<N: NibbleOps>(v1: &[u8], ix: usize) -> u8 {
-	N::at_left(
-		(ix % N::NIBBLE_PER_BYTE) as u8,
-		v1[ix / N::NIBBLE_PER_BYTE]
-	)
-}
 
 /*
 // TODO remove for nibbleslice api TODO can be variable size
@@ -138,7 +116,7 @@ where
 		target_depth: usize, 
 		(k2, v2): &(impl AsRef<[u8]>,impl AsRef<[u8]>), 
 	) {
-		let nibble_value = nibble_at::<N>(&k2.as_ref()[..], target_depth);
+		let nibble_value = N::left_nibble_at(&k2.as_ref()[..], target_depth);
 		// is it a branch value (two candidate same ix)
 		let nkey = NibbleSlice::<N>::new_offset(&k2.as_ref()[..],target_depth+1);
 		// Note: fwiu, having fixed key size, all values are in leaf (no value in
@@ -199,7 +177,7 @@ where
 					self.standard_ext(&ref_branch.as_ref()[..], cb_ext, branch_d, is_root, nkey)
 				};
 				// put hash in parent
-				let nibble: u8 = nibble_at::<N>(&ref_branch.as_ref()[..],d);
+				let nibble: u8 = N::left_nibble_at(&ref_branch.as_ref()[..],d);
 				self.set_node(d, nibble as usize, Some(h));
 			}
 			}
@@ -322,16 +300,14 @@ fn trie_visit_inner<H, C, N, I, A, B, F>(input: I, cb_ext: &mut F, no_ext: bool)
 
 		for (k, v) in iter_input {
 			//println!("!{:?},{:?}",&k.as_ref(),&v.as_ref());
-			let common_depth = biggest_depth::<N>(&prev_val.0.as_ref()[..], &k.as_ref()[..]);
+			let common_depth = N::biggest_depth(&prev_val.0.as_ref()[..], &k.as_ref()[..]);
 			// 0 is a reserved value : could use option
 			let depth_item = common_depth;
 			if common_depth == prev_val.0.as_ref().len() * N::NIBBLE_PER_BYTE {
 				//println!("stack {} ", common_depth);
 				// the new key include the previous one : branch value case
 				// just stored value at branch depth
-				// TODO EMCH bound check and extend depth queue
 				depth_queue.set_elt(common_depth, Some(prev_val.1));
-
 			} else if depth_item >= prev_depth {
 				//println!("fv {}", depth_item);
 				// put prev with next (common branch prev val can be flush)

trie-db/src/nibble/mod.rs

@@ -38,7 +38,6 @@ pub trait NibbleOps: Default + Clone + PartialEq + Eq + PartialOrd + Ord + Copy
 	const NIBBLE_LEN : usize = TWO_EXP[8 / Self::NIBBLE_PER_BYTE]; //2usize.pow(8 as u32 / Self::NIBBLE_PER_BYTE as u32);
 	/// padding bitmasks (could be calculated with a constant function).
 	/// First is bit mask to apply, second is right shift needed.
-	/// TODO EMCH check that array acts as constant
 	const PADDING_BITMASK: &'static [(u8, usize)];
 	/// las ix for nible
 	const LAST_N_IX: usize = Self::NIBBLE_PER_BYTE - 1;
@@ -59,13 +58,21 @@ pub trait NibbleOps: Default + Clone + PartialEq + Eq + PartialOrd + Ord + Copy
 		b & Self::PADDING_BITMASK[ix as usize].0
 	}
 	/// get value at ix from a right first byte
-	/// TODO EMCH here left or right does not make lot of sense
 	#[inline(always)]
 	fn at_left(ix: u8, b: u8) -> u8 {
 		(b & Self::PADDING_BITMASK[ix as usize].0)
 			>> Self::PADDING_BITMASK[ix as usize].1
 	}
 
+  /// get nibble for left aligned array
+  #[inline(always)]
+  fn left_nibble_at(v1: &[u8], ix: usize) -> u8 {
+    Self::at_left(
+      (ix % Self::NIBBLE_PER_BYTE) as u8,
+      v1[ix / Self::NIBBLE_PER_BYTE]
+    )
+  }
+
 	/// push u8 nib value at ix into a existing byte 
 	#[inline(always)]
 	fn push_at_left(ix: u8, v: u8, into: u8) -> u8 {
@@ -95,6 +102,18 @@ pub trait NibbleOps: Default + Clone + PartialEq + Eq + PartialOrd + Ord + Copy
 		(s1, s2)
 	}
 
+  /// get biggest common depth between two left aligned packed nibble arrays
+  fn biggest_depth(v1: &[u8], v2: &[u8]) -> usize {
+    // sorted assertion preventing out of bound
+    for a in 0..v1.len() {
+      if v1[a] == v2[a] {
+      } else {
+        return a * Self::NIBBLE_PER_BYTE + Self::left_common(v1[a], v2[a]);
+      }
+    }
+    return v1.len() * Self::NIBBLE_PER_BYTE;
+  }
+
 	/// number of common bit between two left pad byte
 	#[inline(always)]
 	fn left_common(a: u8, b: u8) -> usize {

trie-db/src/nibble/nibblevec.rs

@@ -111,6 +111,24 @@ impl<N: NibbleOps> NibbleVec<N> {
 		}
 	}
 
+  /// push a full partial.
+	pub fn append(&mut self, v: &NibbleVec<N>) {
+
+    if v.len == 0 { return; }
+		let offset = self.len % N::NIBBLE_PER_BYTE;
+		let last_ix = self.len / N::NIBBLE_PER_BYTE;
+    if offset > 0 {
+      let (s1, s2) = N::split_shifts(offset);
+      self.inner[last_ix] = N::masked_left(offset as u8, self.inner[last_ix]) | (v.inner[0] >> s2);
+			(0..v.len() - 1).for_each(|i|self.inner.push(v.inner[i] << s1 | v.inner[i+1] >> s2));
+    } else {
+      (0..v.inner.len()).for_each(|i|self.inner.push(v.inner[i]));
+    }
+    self.len += v.len;
+	}
+
+
+
 	/// push a full partial.
 	pub fn append_partial(&mut self, (o_n, sl): Partial) {
 		for i in (1..=o_n.0).rev() {
@@ -133,6 +151,35 @@ impl<N: NibbleOps> NibbleVec<N> {
 		self.len += sl.len() * N::NIBBLE_PER_BYTE;
 	}
 
+  /// append slice or nibble
+  pub fn append_slice_nibble(
+    &mut self,
+    o_sl: Option<&NibbleSlice<N>>,
+    o_ix: Option<u8>
+  ) -> usize {
+    let mut res = 0;
+    if let Some(sl) = o_sl { 
+      self.append_partial(sl.right());
+      res += sl.len();
+    }
+    if let Some(ix) = o_ix { 
+      self.push(ix);
+      res += 1;
+    }
+    res
+  }
+  /// clone then append slice or nibble
+  pub fn clone_append_slice_nibble(
+    &self,
+    o_sl: Option<&NibbleSlice<N>>,
+    o_ix: Option<u8>
+  ) -> Self {
+    let mut p = self.clone();
+    p.append_slice_nibble(o_sl, o_ix);
+    p
+  }
+
+
 	/// Get the underlying byte slice.
 	pub fn inner(&self) -> &[u8] {
 		&self.inner[..]

trie-db/src/node_codec.rs

@@ -48,9 +48,6 @@ pub trait NodeCodec<H: Hasher, N: NibbleOps>: Sized {
 	/// Codec error type
 	type Error: Error;
 
-	// TODO EMCH since refact to use nibble ops: use of this method is super awkward
-	// -> making reference code implement statically other nibble could be the simpler
-	// way of fixing that
 	/// Get the hashed null node.
 	fn hashed_null_node() -> H::Out;
 

trie-db/src/triedb.rs

@@ -19,7 +19,6 @@ use super::node::{Node, OwnedNode};
 use node_codec::NodeCodec;
 use super::lookup::Lookup;
 use super::{Result, DBValue, Trie, TrieItem, TrieError, TrieIterator, Query, TrieLayOut, CError, TrieHash};
-use triedbmut::{concat_key_clone};
 use super::nibble::NibbleVec;
 #[cfg(feature = "std")]
 use ::std::fmt;
@@ -175,7 +174,7 @@ where
 						.field("item", &TrieAwareDebugNode{
 							trie: self.trie,
 							node_key: item,
-							partial_key: concat_key_clone(&self.partial_key, Some(&slice), None),
+							partial_key: self.partial_key.clone_append_slice_nibble(Some(&slice), None),
 							index: None,
 						})
 						.finish(),
@@ -187,7 +186,7 @@ where
 							trie: self.trie,
 							index: Some(i as u8),
 							node_key: n,
-							partial_key: concat_key_clone(&self.partial_key, None, Some(i as u8)),
+							partial_key: self.partial_key.clone_append_slice_nibble(None, Some(i as u8)),
 						})
 						.collect();
 					match (f.debug_struct("Node::Branch"), self.index) {
@@ -206,7 +205,7 @@ where
 							trie: self.trie,
 							index: Some(i as u8),
 							node_key: n,
-							partial_key: concat_key_clone(&self.partial_key, Some(&slice), Some(i as u8)),
+							partial_key: self.partial_key.clone_append_slice_nibble(Some(&slice), Some(i as u8)),
 						}).collect();
 					match (f.debug_struct("Node::NibbledBranch"), self.index) {
 						(ref mut d, Some(ref i)) => d.field("index", i),
@@ -421,14 +420,7 @@ impl<'a, L: TrieLayOut> TrieDBIterator<'a, L> {
 			&OwnedNode::Leaf(ref n, _)
 				| &OwnedNode::Extension(ref n, _)
 				| &OwnedNode::NibbledBranch(ref n, _)
-				=> {
-        if let Some(part) = n.as_nibbleslice() {
-			    key_nibbles.append_partial(part.right());
-        } else {
-          // TODO EMCH range_iter on nibble vec or simply cat of two nibblevec
-          (0..n.len()).for_each(|i|key_nibbles.push(n.at(i)));
-        }
-			},
+				=> key_nibbles.append(n),
 			_ => {}
 		}
 	}