Add a cache to reduce DB operations

The address-value pair is stored in the cache when the are written and read in the DB. As cache added, we can find the value in the cache. Therefore, the overhead derived from DB operations will be reduced.

Author: SeungMin Lee

Cargo.toml

@@ -14,6 +14,7 @@ rand = "0.6.1"
 rlp = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.4" }
 rlp_derive = { git = "https://github.com/CodeChain-io/rlp.git", version = "0.2" }
 snap = "0.2"
+lru-cache = "0.1.2"
 
 [dev-dependencies]
 kvdb = "0.1"

src/triedb.rs

@@ -19,7 +19,9 @@ use crate::node::Node as RlpNode;
 use crate::{Trie, TrieError};
 use ccrypto::{blake256, BLAKE_NULL_RLP};
 use cdb::HashDB;
+use lru_cache::LruCache;
 use primitives::H256;
+use std::cell::RefCell;
 
 /// A `Trie` implementation using a generic `HashDB` backing database.
 ///
@@ -43,6 +45,7 @@ use primitives::H256;
 pub(crate) struct TrieDB<'db> {
     db: &'db dyn HashDB,
     root: &'db H256,
+    cache: RefCell<LruCache<H256, Vec<u8>>>,
 }
 
 /// Description of what kind of query will be made to the trie.
@@ -52,12 +55,14 @@ impl<'db> TrieDB<'db> {
     /// Create a new trie with the backing database `db` and `root`
     /// Returns an error if `root` does not exist
     pub fn try_new(db: &'db dyn HashDB, root: &'db H256) -> crate::Result<Self> {
+        let cache: RefCell<LruCache<H256, Vec<u8>>> = RefCell::new(LruCache::new(3000));
         if !db.contains(root) {
             Err(TrieError::InvalidStateRoot(*root))
         } else {
             Ok(TrieDB {
                 db,
                 root,
+                cache,
             })
         }
     }
@@ -71,9 +76,19 @@ impl<'db> TrieDB<'db> {
     ) -> crate::Result<Option<T>> {
         match cur_node_hash {
             Some(hash) => {
-                let node_rlp = self.db.get(&hash).ok_or_else(|| TrieError::IncompleteDatabase(hash))?;
-
-                match RlpNode::decoded(&node_rlp) {
+                // FIXME: Refactoring is required to reduce access to the cache.
+                //        the current code queries the cache twice when the data is cached.
+                let node_rlp;
+                let decoded_rlp = if self.cache.borrow_mut().contains_key(&hash) {
+                    node_rlp = self.cache.borrow_mut().get_mut(&hash).unwrap().to_vec();
+                    RlpNode::decoded(&node_rlp)
+                } else {
+                    node_rlp = self.db.get(&hash).ok_or_else(|| TrieError::IncompleteDatabase(hash))?;
+                    self.cache.borrow_mut().insert(hash, (&*node_rlp).to_vec());
+                    RlpNode::decoded(&node_rlp)
+                };
+
+                match decoded_rlp {
                     Some(RlpNode::Leaf(partial, value)) => {
                         if &partial == path {
                             Ok(Some(query(value)))

src/triedbmut.rs

@@ -20,6 +20,7 @@ use crate::triedb::TrieDB;
 use crate::{Trie, TrieError, TrieMut};
 use ccrypto::{blake256, BLAKE_NULL_RLP};
 use cdb::{DBValue, HashDB};
+use lru_cache::LruCache;
 use primitives::H256;
 use std::fmt;
 
@@ -31,16 +32,19 @@ pub(crate) struct TrieDBMut<'a> {
     db: &'a mut dyn HashDB,
     // When Trie is empty, root has None.
     root: &'a mut H256,
+    cache: LruCache<H256, Vec<u8>>,
 }
 
 impl<'a> TrieDBMut<'a> {
     /// Create a new trie with backing database `db` and empty `root`.
     pub fn new(db: &'a mut dyn HashDB, root: &'a mut H256) -> Self {
         *root = BLAKE_NULL_RLP;
 
+        let cache: LruCache<H256, Vec<u8>> = LruCache::new(3000);
         TrieDBMut {
             db,
             root,
+            cache,
         }
     }
 
@@ -51,9 +55,11 @@ impl<'a> TrieDBMut<'a> {
             return Err(TrieError::InvalidStateRoot(*root))
         }
 
+        let cache: LruCache<H256, Vec<u8>> = LruCache::new(3000);
         Ok(TrieDBMut {
             db,
             root,
+            cache,
         })
     }
 
@@ -67,16 +73,27 @@ impl<'a> TrieDBMut<'a> {
     ) -> crate::Result<H256> {
         match cur_node_hash {
             Some(hash) => {
-                let node_rlp = self.db.get(&hash).ok_or_else(|| TrieError::IncompleteDatabase(hash))?;
-
-                match RlpNode::decoded(&node_rlp) {
+                // FIXME: Refactoring is required to reduce access to the cache.
+                //        the current code queries the cache twice when the data is cached.
+                let node_rlp;
+                let decoded_rlp = if self.cache.contains_key(&hash) {
+                    node_rlp = self.cache.get_mut(&hash).unwrap().to_vec();
+                    RlpNode::decoded(&node_rlp)
+                } else {
+                    node_rlp = self.db.get(&hash).ok_or_else(|| TrieError::IncompleteDatabase(hash))?;
+                    self.cache.insert(hash, (&*node_rlp).to_vec());
+                    RlpNode::decoded(&node_rlp)
+                };
+
+                match decoded_rlp {
                     Some(RlpNode::Leaf(partial, value)) => {
                         // Renew the Leaf
                         if partial == path {
                             let node = RlpNode::Leaf(path, insert_value);
                             let node_rlp = RlpNode::encoded(node);
                             let hash = self.db.insert(&node_rlp);
 
+                            self.cache.insert(hash, node_rlp);
                             *old_val = Some(value.to_vec());
 
                             Ok(hash)
@@ -102,6 +119,7 @@ impl<'a> TrieDBMut<'a> {
 
                             let node_rlp = RlpNode::encoded_until(RlpNode::Branch(partial, new_child.into()), common);
                             let hash = self.db.insert(&node_rlp);
+                            self.cache.insert(hash, node_rlp);
 
                             Ok(hash)
                         }
@@ -118,6 +136,7 @@ impl<'a> TrieDBMut<'a> {
 
                             let mut node_rlp = RlpNode::encoded(o_branch);
                             let b_hash = self.db.insert(&node_rlp);
+                            self.cache.insert(b_hash, node_rlp);
 
                             new_child[new_partial.at(0) as usize] = Some(b_hash);
                             new_child[new_path.at(0) as usize] = Some(self.insert_aux(
@@ -129,6 +148,7 @@ impl<'a> TrieDBMut<'a> {
 
                             node_rlp = RlpNode::encoded_until(RlpNode::Branch(partial, new_child.into()), common);
                             let hash = self.db.insert(&node_rlp);
+                            self.cache.insert(hash, node_rlp);
 
                             Ok(hash)
                         } else {
@@ -145,6 +165,7 @@ impl<'a> TrieDBMut<'a> {
                             let new_branch = RlpNode::Branch(partial, children);
                             let node_rlp = RlpNode::encoded(new_branch);
                             let hash = self.db.insert(&node_rlp);
+                            self.cache.insert(hash, node_rlp);
 
                             Ok(hash)
                         }
@@ -153,6 +174,7 @@ impl<'a> TrieDBMut<'a> {
                         let node = RlpNode::Leaf(path, insert_value);
                         let node_rlp = RlpNode::encoded(node);
                         let hash = self.db.insert(&node_rlp);
+                        self.cache.insert(hash, node_rlp);
 
                         Ok(hash)
                     }
@@ -162,6 +184,7 @@ impl<'a> TrieDBMut<'a> {
                 let node = RlpNode::Leaf(path, insert_value);
                 let node_rlp = RlpNode::encoded(node);
                 let hash = self.db.insert(&node_rlp);
+                self.cache.insert(hash, node_rlp);
 
                 Ok(hash)
             }