From 048c27237a5a8d733b3d0d51fc0b73906991efdb Mon Sep 17 00:00:00 2001 From: arkpar Date: Thu, 4 Feb 2016 21:33:30 +0100 Subject: [PATCH] Counters in JournalDB --- ethcore/res/ethereum/tests | 2 +- ethcore/src/client.rs | 15 ++--- util/src/journaldb.rs | 128 +++++++++++++++++++++++++++++-------- 3 files changed, 107 insertions(+), 38 deletions(-) diff --git a/ethcore/res/ethereum/tests b/ethcore/res/ethereum/tests index c670b1d8c..3116f85a4 160000 --- a/ethcore/res/ethereum/tests +++ b/ethcore/res/ethereum/tests @@ -1 +1 @@ -Subproject commit c670b1d8c9f09593a6758ab2c099360e16c7c25b +Subproject commit 3116f85a499ceaf4dfdc46726060fc056e2d7829 diff --git a/ethcore/src/client.rs b/ethcore/src/client.rs index 71c27502b..088db8cd3 100644 --- a/ethcore/src/client.rs +++ b/ethcore/src/client.rs @@ -140,13 +140,13 @@ pub struct Client { chain: Arc>, engine: Arc>, state_db: Arc, + state_journal: Mutex, block_queue: RwLock, report: RwLock, - uncommited_states: RwLock>, import_lock: Mutex<()> } -const HISTORY: u64 = 1; +const HISTORY: u64 = 1000; impl Client { /// Create a new client with given spec and DB path. @@ -185,10 +185,10 @@ impl Client { Ok(Arc::new(Client { chain: chain, engine: engine.clone(), - state_db: db, + state_db: db.clone(), + state_journal: Mutex::new(JournalDB::new_with_arc(db)), block_queue: RwLock::new(BlockQueue::new(engine, message_channel)), report: RwLock::new(Default::default()), - uncommited_states: RwLock::new(HashMap::new()), import_lock: Mutex::new(()), })) } @@ -241,7 +241,7 @@ impl Client { } } - let db = JournalDB::new_with_arc(self.state_db.clone()); + let db = self.state_journal.lock().unwrap().clone(); let result = match enact_verified(&block, self.engine.deref().deref(), db, &parent, &last_hashes) { Ok(b) => b, Err(e) => { @@ -276,11 +276,6 @@ impl Client { ret } - /// Clear cached state overlay - pub fn clear_state(&self, hash: &H256) { - self.uncommited_states.write().unwrap().remove(hash); - } - /// Get a copy of the best block's state. pub fn state(&self) -> State { State::from_existing(JournalDB::new_with_arc(self.state_db.clone()), HeaderView::new(&self.best_block_header()).state_root(), self.engine.account_start_nonce()) diff --git a/util/src/journaldb.rs b/util/src/journaldb.rs index a07a9537d..d4dfc0d6c 100644 --- a/util/src/journaldb.rs +++ b/util/src/journaldb.rs @@ -4,7 +4,7 @@ use common::*; use rlp::*; use hashdb::*; use memorydb::*; -use rocksdb::{DB, Writable, IteratorMode}; +use rocksdb::{DB, Writable, IteratorMode, WriteBatch}; #[cfg(test)] use std::env; @@ -18,23 +18,35 @@ use std::env; pub struct JournalDB { overlay: MemoryDB, backing: Arc, + counters: Arc>>, } +impl Clone for JournalDB { + fn clone(&self) -> JournalDB { + JournalDB { + overlay: MemoryDB::new(), + backing: self.backing.clone(), + counters: self.counters.clone(), + } + } +} + +const LAST_ERA_KEY : [u8; 4] = [ b'l', b'a', b's', b't' ]; + impl JournalDB { /// Create a new instance given a `backing` database. pub fn new(backing: DB) -> JournalDB { let db = Arc::new(backing); - JournalDB { - overlay: MemoryDB::new(), - backing: db, - } + JournalDB::new_with_arc(db) } /// Create a new instance given a shared `backing` database. pub fn new_with_arc(backing: Arc) -> JournalDB { + let counters = JournalDB::read_counters(&backing); JournalDB { overlay: MemoryDB::new(), backing: backing, + counters: Arc::new(RwLock::new(counters)), } } @@ -49,6 +61,7 @@ impl JournalDB { /// Commit all recent insert operations and historical removals from the old era /// to the backing database. + #[allow(cyclomatic_complexity)] pub fn commit(&mut self, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { // journal format: // [era, 0] => [ id, [insert_0, ...], [remove_0, ...] ] @@ -63,6 +76,8 @@ impl JournalDB { // of its inserts otherwise. // record new commit's details. + let batch = WriteBatch::new(); + let mut counters = self.counters.write().unwrap(); { let mut index = 0usize; let mut last; @@ -79,11 +94,14 @@ impl JournalDB { let mut r = RlpStream::new_list(3); let inserts: Vec = self.overlay.keys().iter().filter(|&(_, &c)| c > 0).map(|(key, _)| key.clone()).collect(); + for i in &inserts { + *counters.entry(i.clone()).or_insert(0) += 1; + } let removes: Vec = self.overlay.keys().iter().filter(|&(_, &c)| c < 0).map(|(key, _)| key.clone()).collect(); r.append(id); r.append(&inserts); r.append(&removes); - try!(self.backing.put(&last, r.as_raw())); + try!(batch.put(&last, r.as_raw())); } // apply old commits' details @@ -98,14 +116,35 @@ impl JournalDB { &last })) { let rlp = Rlp::new(&rlp_data); + { + let to_add: Vec = rlp.val_at(1); + for i in &to_add { + let delete_counter = { + if let Some(mut cnt) = counters.get_mut(i) { + *cnt -= 1; + *cnt == 0 + } + else { false } + + }; + if delete_counter { + counters.remove(i); + } + } + } let to_remove: Vec = rlp.val_at(if canon_id == rlp.val_at(0) {2} else {1}); for i in &to_remove { - self.backing.delete(&i).expect("Low-level database error. Some issue with your hard disk?"); + if !counters.contains_key(i) { + batch.delete(&i).expect("Low-level database error. Some issue with your hard disk?"); + } } - try!(self.backing.delete(&last)); + + try!(batch.delete(&last)); trace!("JournalDB: delete journal for time #{}.{}, (canon was {}): {} entries", end_era, index, canon_id, to_remove.len()); index += 1; } + + try!(batch.put(&LAST_ERA_KEY, &encode(&end_era))); } let mut ret = 0u32; @@ -114,11 +153,7 @@ impl JournalDB { let (key, (value, rc)) = i; if rc > 0 { assert!(rc == 1); - if !self.backing.get(&key.bytes()).unwrap().is_none() { - info!("Exist: {:?}", key); - key.clone(); - } - self.backing.put(&key.bytes(), &value).expect("Low-level database error. Some issue with your hard disk?"); + batch.put(&key.bytes(), &value).expect("Low-level database error. Some issue with your hard disk?"); ret += 1; } if rc < 0 { @@ -127,6 +162,8 @@ impl JournalDB { deletes += 1; } } + + try!(self.backing.write(batch)); trace!("JournalDB::commit() deleted {} nodes", deletes); Ok(ret) } @@ -134,6 +171,35 @@ impl JournalDB { fn payload(&self, key: &H256) -> Option { self.backing.get(&key.bytes()).expect("Low-level database error. Some issue with your hard disk?").map(|v| v.to_vec()) } + + fn read_counters(db: &DB) -> HashMap { + let mut res = HashMap::new(); + if let Some(val) = db.get(&LAST_ERA_KEY).expect("Low-level database error.") { + let mut era = decode::(&val) + 1; + loop { + let mut index = 0usize; + while let Some(rlp_data) = db.get({ + let mut r = RlpStream::new_list(2); + r.append(&era); + r.append(&index); + &r.drain() + }).expect("Low-level database error.") { + let rlp = Rlp::new(&rlp_data); + let to_add: Vec = rlp.val_at(1); + for h in to_add { + *res.entry(h).or_insert(0) += 1; + } + index += 1; + }; + if index == 0 { + break; + } + era += 1; + } + } + info!("Recovered {} counters", res.len()); + res + } } impl HashDB for JournalDB { @@ -171,25 +237,14 @@ impl HashDB for JournalDB { } fn insert(&mut self, value: &[u8]) -> H256 { - if value.sha3() == h256_from_hex("3567da57862169b0dc409933ec10da8113ef3810fd225ad81d4fc23c36ffa5d4") { - info!("GOTCHA"); - value.to_vec(); - } - self.overlay.insert(value) + self.overlay.insert(value) } fn emplace(&mut self, key: H256, value: Bytes) { - if key == h256_from_hex("3567da57862169b0dc409933ec10da8113ef3810fd225ad81d4fc23c36ffa5d4") { - info!("GOTCHA"); - value.to_vec(); - } self.overlay.emplace(key, value); } fn kill(&mut self, key: &H256) { - if key == &h256_from_hex("3567da57862169b0dc409933ec10da8113ef3810fd225ad81d4fc23c36ffa5d4") { - info!("DELETING"); - key.clone(); - } - self.overlay.kill(key); } + self.overlay.kill(key); + } } #[cfg(test)] @@ -281,4 +336,23 @@ mod tests { assert!(!jdb.exists(&baz)); assert!(!jdb.exists(&bar)); } + + #[test] + fn overwrite() { + // history is 1 + let mut jdb = JournalDB::new_temp(); + + let foo = jdb.insert(b"foo"); + jdb.commit(0, &b"0".sha3(), None).unwrap(); + assert!(jdb.exists(&foo)); + + jdb.remove(&foo); + jdb.commit(1, &b"1".sha3(), Some((0, b"0".sha3()))).unwrap(); + jdb.insert(b"foo"); + assert!(jdb.exists(&foo)); + jdb.commit(2, &b"2".sha3(), Some((1, b"1".sha3()))).unwrap(); + assert!(jdb.exists(&foo)); + jdb.commit(3, &b"2".sha3(), Some((0, b"2".sha3()))).unwrap(); + assert!(jdb.exists(&foo)); + } }