Bug fix in nibble slice.

Trie.
This commit is contained in:
Gav Wood 2015-11-30 02:57:02 +01:00
parent a67abd8e99
commit c91bc6b419
5 changed files with 119 additions and 18 deletions

View File

@ -1,4 +1,5 @@
use hash::*; use hash::*;
use bytes::*;
pub trait HashDB { pub trait HashDB {
/// Look up a given hash into the bytes that hash to it, returning None if the /// Look up a given hash into the bytes that hash to it, returning None if the
@ -56,6 +57,9 @@ pub trait HashDB {
/// ``` /// ```
fn insert(&mut self, value: &[u8]) -> H256; fn insert(&mut self, value: &[u8]) -> H256;
/// Like `insert()` , except you provide the key and the data is all moved.
fn emplace(&mut self, key: H256, value: Bytes);
/// Remove a datum previously inserted. Insertions can be "owed" such that the same number of `insert()`s may /// Remove a datum previously inserted. Insertions can be "owed" such that the same number of `insert()`s may
/// happen without the data being eventually being inserted into the DB. /// happen without the data being eventually being inserted into the DB.
/// ///

View File

@ -37,6 +37,12 @@ use std::collections::HashMap;
/// m.kill(&k); /// m.kill(&k);
/// assert!(!m.exists(&k)); /// assert!(!m.exists(&k));
/// ///
/// m.kill(&k);
/// assert!(!m.exists(&k));
///
/// m.insert(d);
/// assert!(!m.exists(&k));
/// m.insert(d); /// m.insert(d);
/// assert!(m.exists(&k)); /// assert!(m.exists(&k));
/// assert_eq!(m.lookup(&k).unwrap(), d); /// assert_eq!(m.lookup(&k).unwrap(), d);
@ -130,9 +136,9 @@ impl HashDB for MemoryDB {
fn insert(&mut self, value: &[u8]) -> H256 { fn insert(&mut self, value: &[u8]) -> H256 {
let key = value.sha3(); let key = value.sha3();
if match self.data.get_mut(&key) { if match self.data.get_mut(&key) {
Some(&mut (ref mut old_value, ref mut rc @ 0)) => { Some(&mut (ref mut old_value, ref mut rc @ -0x80000000i32 ... 0)) => {
*old_value = From::from(value.bytes()); *old_value = From::from(value.bytes());
*rc = 1; *rc += 1;
false false
}, },
Some(&mut (_, ref mut x)) => { *x += 1; false } , Some(&mut (_, ref mut x)) => { *x += 1; false } ,
@ -143,6 +149,20 @@ impl HashDB for MemoryDB {
key key
} }
fn emplace(&mut self, key: H256, value: Bytes) {
match self.data.get_mut(&key) {
Some(&mut (ref mut old_value, ref mut rc @ -0x80000000i32 ... 0)) => {
*old_value = value;
*rc += 1;
return;
},
Some(&mut (_, ref mut x)) => { *x += 1; return; } ,
None => {},
}
// ... None falls through into...
self.data.insert(key, (value, 1));
}
fn kill(&mut self, key: &H256) { fn kill(&mut self, key: &H256) {
if match self.data.get_mut(key) { if match self.data.get_mut(key) {
Some(&mut (_, ref mut x)) => { *x -= 1; false } Some(&mut (_, ref mut x)) => { *x -= 1; false }

View File

@ -1,5 +1,6 @@
//! Nibble-orientated view onto byte-slice, allowing nibble-precision offsets. //! Nibble-orientated view onto byte-slice, allowing nibble-precision offsets.
use std::cmp::*; use std::cmp::*;
use bytes::*;
/// Nibble-orientated view onto byte-slice, allowing nibble-precision offsets. /// Nibble-orientated view onto byte-slice, allowing nibble-precision offsets.
/// ///
@ -69,6 +70,18 @@ impl<'a> NibbleSlice<'a> {
} }
i i
} }
pub fn encoded(&self, is_leaf: bool) -> Bytes {
let l = self.len();
let mut r = Bytes::with_capacity(l / 2 + 1);
let mut i = l % 2;
r.push(if i == 1 {0x10 + self.at(0)} else {0} + if is_leaf {0x20} else {0});
while i < l {
r.push(self.at(i) * 16 + self.at(i + 1));
i += 2;
}
r
}
} }
impl<'a> PartialEq for NibbleSlice<'a> { impl<'a> PartialEq for NibbleSlice<'a> {
@ -126,6 +139,15 @@ mod tests {
} }
} }
#[test]
fn encoded() {
let n = NibbleSlice::new(D);
assert_eq!(n.encoded(false), &[0x00, 0x01, 0x23, 0x45]);
assert_eq!(n.encoded(true), &[0x20, 0x01, 0x23, 0x45]);
assert_eq!(n.mid(1).encoded(false), &[0x11, 0x23, 0x45]);
assert_eq!(n.mid(1).encoded(true), &[0x31, 0x23, 0x45]);
}
#[test] #[test]
fn shared() { fn shared() {
let n = NibbleSlice::new(D); let n = NibbleSlice::new(D);

View File

@ -186,6 +186,7 @@ impl HashDB for OverlayDB {
} }
} }
fn insert(&mut self, value: &[u8]) -> H256 { self.overlay.insert(value) } fn insert(&mut self, value: &[u8]) -> H256 { self.overlay.insert(value) }
fn emplace(&mut self, key: H256, value: Bytes) { self.overlay.emplace(key, value); }
fn kill(&mut self, key: &H256) { self.overlay.kill(key); } fn kill(&mut self, key: &H256) { self.overlay.kill(key); }
} }

View File

@ -1,8 +1,9 @@
use memorydb::*; use memorydb::*;
use hashdb::*; use hashdb::*;
use hash::*; use hash::*;
//use rlp::*; use nibbleslice::*;
//use bytes::*; use bytes::*;
use rlp::*;
pub const NULL_RLP: [u8; 1] = [0x80; 1]; pub const NULL_RLP: [u8; 1] = [0x80; 1];
pub const SHA3_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] ); pub const SHA3_NULL_RLP: H256 = H256( [0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x01, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21] );
@ -17,10 +18,10 @@ pub trait Trie {
fn is_empty(&self) -> bool { *self.root() == SHA3_NULL_RLP } fn is_empty(&self) -> bool { *self.root() == SHA3_NULL_RLP }
// TODO: consider returning &[u8]... // TODO: consider returning &[u8]...
fn contains(key: &[u8]) -> bool; fn contains(&self, key: &[u8]) -> bool;
fn at(key: &[u8]) -> Option<&[u8]>; fn at(&self, key: &[u8]) -> Option<&[u8]>;
fn insert(key: &[u8], value: &[u8]); fn insert(&mut self, key: &[u8], value: &[u8]);
fn remove(key: &[u8]); fn remove(&mut self, key: &[u8]);
} }
pub struct TrieDB { pub struct TrieDB {
@ -28,6 +29,11 @@ pub struct TrieDB {
root: H256, root: H256,
} }
struct Diff {
new: Vec<(H256, Bytes)>,
old: Vec<H256>,
}
impl TrieDB { impl TrieDB {
pub fn new<T>(db: T) -> Self where T: HashDB + 'static { TrieDB{ db: Box::new(db), root: H256::new() } } pub fn new<T>(db: T) -> Self where T: HashDB + 'static { TrieDB{ db: Box::new(db), root: H256::new() } }
@ -35,36 +41,85 @@ impl TrieDB {
pub fn new_memory() -> Self { TrieDB{ db: Box::new(MemoryDB::new()), root: H256::new() } } pub fn new_memory() -> Self { TrieDB{ db: Box::new(MemoryDB::new()), root: H256::new() } }
pub fn init(&mut self) { self.insert_root(&NULL_RLP); } pub fn init(&mut self) { self.set_root_rlp(&NULL_RLP); }
pub fn db(&self) -> &HashDB { self.db.as_ref() } pub fn db(&self) -> &HashDB { self.db.as_ref() }
fn insert_root(&mut self, root_data: &[u8]) { self.root = self.db.insert(root_data); } fn set_root_rlp(&mut self, root_data: &[u8]) {
self.root = self.db.insert(root_data);
}
fn insert(&mut self, key: &NibbleSlice, value: &[u8]) {
// determine what the new root is, insert new nodes and remove old as necessary.
let mut todo: (Bytes, Diff);
{
let root_rlp = self.db.lookup(&self.root).unwrap();
todo = self.merge(root_rlp, key, value);
}
self.apply(todo.1);
self.set_root_rlp(&todo.0);
}
fn apply(&mut self, diff: Diff) {
for d in diff.old.iter() {
self.db.kill(&d);
}
for d in diff.new.into_iter() {
self.db.emplace(d.0, d.1);
}
}
/// Determine the RLP of the node, assuming we're inserting `partial_key` into the
/// node at `old`. This will *not* delete the old mode; it will just return the new RLP
/// that includes the new node.
///
/// The database will be updated so as to make the returned RLP valid through inserting
/// and deleting nodes as necessary.
fn merge(&self, old: &[u8], partial_key: &NibbleSlice, value: &[u8]) -> (Bytes, Diff) {
let o = Rlp::new(old);
match (o.type()) {
List(17) => {
// already have a branch. route and merge.
},
List(2) => {
// already have an extension. either fast_forward, cleve or transmute_to_branch.
},
Data(0) => compose_extension(partial_key),
_ -> panic!("Invalid RLP for node."),
}
}
fn compose_extension(partial_key: &NibbleSlice, value: &[u8], is_leaf: bool) -> Bytes {
let mut s = RlpStream::new_list(2);
s.append(&partial_key.encoded(is_leaf));
s.append(&value.to_vec()); // WTF?!?!
//s.append(value); // <-- should be.
s.out().unwrap()
}
} }
impl Trie for TrieDB { impl Trie for TrieDB {
fn root(&self) -> &H256 { &self.root } fn root(&self) -> &H256 { &self.root }
fn contains(_key: &[u8]) -> bool { fn contains(&self, _key: &[u8]) -> bool {
unimplemented!(); unimplemented!();
} }
fn at(_key: &[u8]) -> Option<&[u8]> { fn at(&self, _key: &[u8]) -> Option<&[u8]> {
unimplemented!(); unimplemented!();
} }
fn insert(_key: &[u8], _value: &[u8]) { fn insert(&mut self, key: &[u8], value: &[u8]) {
unimplemented!(); (self as &mut TrieDB).insert(&NibbleSlice::new(key), value);
} }
fn remove(_key: &[u8]) { fn remove(&mut self, _key: &[u8]) {
unimplemented!(); unimplemented!();
} }
} }
#[test] #[test]
fn it_works() { fn playpen() {
use overlaydb::*; use overlaydb::*;
(&[1, 2, 3]).starts_with(&[1, 2]); (&[1, 2, 3]).starts_with(&[1, 2]);
@ -73,6 +128,5 @@ fn it_works() {
t.init(); t.init();
assert_eq!(*t.root(), SHA3_NULL_RLP); assert_eq!(*t.root(), SHA3_NULL_RLP);
assert!(t.is_empty()); assert!(t.is_empty());
// TODO: make work: t.insert(&[0x01u8, 0x23], &[0x01u8, 0x23]);
//assert_eq!(t.root(), SHA3_NULL_RLP);
} }