Add action data cache in top level state

Joon-Mo Yang · Joon-Mo Yang · commit 371ff69633df · 2018-07-26T14:59:17.000+09:00
diff --git a/state/src/action_handler/mod.rs b/state/src/action_handler/mod.rs
@@ -0,0 +1,27 @@
+// Copyright 2018 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use ctypes::parcel::Outcome;
+use primitives::Bytes;
+use trie::TrieMut;
+
+use super::{StateResult, TopLevelState};
+
+pub trait ActionHandler: Send + Sync {
+    fn init(&self, state: &mut TrieMut) -> StateResult<()>;
+    fn is_target(&self, bytes: &Bytes) -> bool;
+    fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> StateResult<Outcome>;
+}
diff --git a/state/src/backend.rs b/state/src/backend.rs
@@ -39,6 +39,7 @@
 
 use ckey::Address;
 use hashdb::HashDB;
+use primitives::{Bytes, H256};
 
 use super::{
     Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Metadata, MetadataAddress, Shard, ShardAddress,
@@ -59,12 +60,14 @@ pub trait TopBackend: Send {
     fn add_to_account_cache(&mut self, addr: Address, data: Option<Account>, modified: bool);
     fn add_to_metadata_cache(&mut self, address: MetadataAddress, item: Option<Metadata>, modified: bool);
     fn add_to_shard_cache(&mut self, address: ShardAddress, item: Option<Shard>, modified: bool);
+    fn add_to_action_data_cache(&mut self, address: H256, item: Option<Bytes>, modified: bool);
 
     /// Get basic copy of the cached account. Not required to include storage.
     /// Returns 'None' if cache is disabled or if the account is not cached.
     fn get_cached_account(&self, addr: &Address) -> Option<Option<Account>>;
     fn get_cached_metadata(&self, addr: &MetadataAddress) -> Option<Option<Metadata>>;
     fn get_cached_shard(&self, addr: &ShardAddress) -> Option<Option<Shard>>;
+    fn get_cached_action_data(&self, key: &H256) -> Option<Option<Bytes>>;
 
     /// Get value from a cached account.
     /// `None` is passed to the closure if the account entry cached
diff --git a/state/src/db.rs b/state/src/db.rs
@@ -27,7 +27,7 @@ use kvdb::DBTransaction;
 use kvdb_memorydb;
 use lru_cache::LruCache;
 use parking_lot::Mutex;
-use primitives::H256;
+use primitives::{Bytes, H256};
 use util_error::UtilError;
 
 use super::{
@@ -40,9 +40,10 @@ const STATE_CACHE_BLOCKS: usize = 12;
 // The percentage of supplied cache size to go to accounts.
 const ACCOUNT_CACHE_RATIO: usize = 40;
 const METADATA_CACHE_RATIO: usize = 1;
-const SHARD_CACHE_RATIO: usize = 9;
+const SHARD_CACHE_RATIO: usize = 8;
 const ASSET_SCHEME_CACHE_RATIO: usize = 10;
 const ASSET_CACHE_RATIO: usize = 40;
+const ACTION_DATA_CACHE_RATIO: usize = 1;
 
 /// Shared canonical state cache.
 struct Cache<Item>
@@ -108,13 +109,15 @@ pub struct StateDB {
     shard_cache: Arc<Mutex<Cache<Shard>>>,
     asset_scheme_cache: Arc<Mutex<Cache<AssetScheme>>>,
     asset_cache: Arc<Mutex<Cache<Asset>>>,
+    action_data_cache: Arc<Mutex<Cache<Bytes>>>,
 
     /// Local dirty cache.
     local_account_cache: Vec<CacheQueueItem<Account>>,
     local_metadata_cache: Vec<CacheQueueItem<Metadata>>,
     local_shard_cache: Vec<CacheQueueItem<Shard>>,
     local_asset_scheme_cache: Vec<CacheQueueItem<AssetScheme>>,
     local_asset_cache: Vec<CacheQueueItem<Asset>>,
+    local_action_data_cache: Vec<CacheQueueItem<Bytes>>,
     /// Hash of the block on top of which this instance was created or
     /// `None` if cache is disabled
     parent_hash: Option<H256>,
@@ -137,6 +140,7 @@ impl StateDB {
                 + SHARD_CACHE_RATIO
                 + ASSET_SCHEME_CACHE_RATIO
                 + ASSET_CACHE_RATIO
+                + ACTION_DATA_CACHE_RATIO
         );
 
         let account_cache_size = cache_size * ACCOUNT_CACHE_RATIO / 100;
@@ -154,6 +158,9 @@ impl StateDB {
         let asset_cache_size = cache_size * ASSET_CACHE_RATIO / 100;
         let asset_cache_items = asset_cache_size / ::std::mem::size_of::<Option<Asset>>();
 
+        let action_data_cache_size = cache_size * ACTION_DATA_CACHE_RATIO / 100;
+        let action_data_cache_items = action_data_cache_size / ::std::mem::size_of::<Option<Bytes>>();
+
         StateDB {
             db,
             account_cache: Arc::new(Mutex::new(Cache {
@@ -176,12 +183,17 @@ impl StateDB {
                 cache: LruCache::new(asset_cache_items),
                 modifications: VecDeque::new(),
             })),
+            action_data_cache: Arc::new(Mutex::new(Cache {
+                cache: LruCache::new(action_data_cache_items),
+                modifications: VecDeque::new(),
+            })),
 
             local_account_cache: Vec::new(),
             local_metadata_cache: Vec::new(),
             local_shard_cache: Vec::new(),
             local_asset_scheme_cache: Vec::new(),
             local_asset_cache: Vec::new(),
+            local_action_data_cache: Vec::new(),
             parent_hash: None,
             commit_hash: None,
             commit_number: None,
@@ -271,6 +283,17 @@ impl StateDB {
             &self.commit_hash,
             &self.commit_number,
         );
+
+        Self::sync_cache_impl(
+            enacted,
+            retracted,
+            is_best,
+            &mut self.action_data_cache,
+            &mut self.local_action_data_cache,
+            &self.parent_hash,
+            &self.commit_hash,
+            &self.commit_number,
+        );
     }
 
     fn sync_cache_impl<Item>(
@@ -392,12 +415,14 @@ impl StateDB {
             shard_cache: self.shard_cache.clone(),
             asset_scheme_cache: self.asset_scheme_cache.clone(),
             asset_cache: self.asset_cache.clone(),
+            action_data_cache: self.action_data_cache.clone(),
 
             local_account_cache: Vec::new(),
             local_metadata_cache: Vec::new(),
             local_shard_cache: Vec::new(),
             local_asset_scheme_cache: Vec::new(),
             local_asset_cache: Vec::new(),
+            local_action_data_cache: Vec::new(),
 
             parent_hash: Some(parent.clone()),
             commit_hash: None,
@@ -425,6 +450,7 @@ impl StateDB {
             + Self::mem_used_impl(&self.shard_cache.lock())
             + Self::mem_used_impl(&self.asset_scheme_cache.lock())
             + Self::mem_used_impl(&self.asset_cache.lock())
+            + Self::mem_used_impl(&self.action_data_cache.lock())
     }
 
     /// Returns underlying `JournalDB`.
@@ -503,12 +529,14 @@ impl Clone for StateDB {
             shard_cache: self.shard_cache.clone(),
             asset_scheme_cache: self.asset_scheme_cache.clone(),
             asset_cache: self.asset_cache.clone(),
+            action_data_cache: self.action_data_cache.clone(),
 
             local_account_cache: Vec::new(),
             local_metadata_cache: Vec::new(),
             local_shard_cache: Vec::new(),
             local_asset_scheme_cache: Vec::new(),
             local_asset_cache: Vec::new(),
+            local_action_data_cache: Vec::new(),
 
             parent_hash: None,
             commit_hash: None,
@@ -552,6 +580,14 @@ impl TopBackend for StateDB {
         })
     }
 
+    fn add_to_action_data_cache(&mut self, address: H256, item: Option<Bytes>, modified: bool) {
+        self.local_action_data_cache.push(CacheQueueItem {
+            address,
+            item,
+            modified,
+        })
+    }
+
     fn get_cached_account(&self, addr: &Address) -> Option<Option<Account>> {
         self.get_cached(addr, &self.account_cache)
     }
@@ -564,6 +600,10 @@ impl TopBackend for StateDB {
         self.get_cached(addr, &self.shard_cache)
     }
 
+    fn get_cached_action_data(&self, key: &H256) -> Option<Option<Bytes>> {
+        self.get_cached(key, &self.action_data_cache)
+    }
+
     fn get_cached_account_with<F, U>(&self, a: &Address, f: F) -> Option<U>
     where
         F: FnOnce(Option<&mut Account>) -> U, {
diff --git a/state/src/impls/top_level.rs b/state/src/impls/top_level.rs
@@ -44,7 +44,8 @@ use ctypes::invoice::Invoice;
 use ctypes::parcel::{Action, ChangeShard, Error as ParcelError, Outcome as ParcelOutcome, Parcel};
 use ctypes::transaction::{Error as TransactionError, Outcome as TransactionOutcome, Transaction};
 use ctypes::ShardId;
-use primitives::{H256, U256};
+use primitives::{Bytes, H256, U256};
+use rlp::NULL_RLP;
 use trie::{Result as TrieResult, Trie, TrieError, TrieFactory};
 use unexpected::Mismatch;
 
@@ -108,6 +109,7 @@ pub struct TopLevelState {
     account: Cache<Account>,
     metadata: Cache<Metadata>,
     shard: Cache<Shard>,
+    action_data: Cache<Bytes>,
     id_of_checkpoints: Vec<CheckpointId>,
     trie_factory: TrieFactory,
 }
@@ -161,6 +163,11 @@ impl TopStateInfo for TopLevelState {
             ShardLevelState::from_existing(shard_id, self.db.clone(), shard_root, self.trie_factory)?;
         shard_level_state.asset(asset_address)
     }
+
+    fn action_data(&self, key: &H256) -> TrieResult<Bytes> {
+        let action_data = self.require_action_data(key)?;
+        Ok(action_data.clone())
+    }
 }
 
 const PARCEL_FEE_CHECKPOINT: CheckpointId = 123;
@@ -172,6 +179,7 @@ impl StateWithCheckpoint for TopLevelState {
         self.account.checkpoint();
         self.metadata.checkpoint();
         self.shard.checkpoint();
+        self.action_data.checkpoint();
     }
 
     fn discard_checkpoint(&mut self, id: CheckpointId) {
@@ -181,6 +189,7 @@ impl StateWithCheckpoint for TopLevelState {
         self.account.discard_checkpoint();
         self.metadata.discard_checkpoint();
         self.shard.discard_checkpoint();
+        self.action_data.discard_checkpoint();
     }
 
     fn revert_to_checkpoint(&mut self, id: CheckpointId) {
@@ -190,6 +199,7 @@ impl StateWithCheckpoint for TopLevelState {
         self.account.revert_to_checkpoint();
         self.metadata.revert_to_checkpoint();
         self.shard.revert_to_checkpoint();
+        self.action_data.revert_to_checkpoint();
     }
 }
 
@@ -199,6 +209,7 @@ impl StateWithCache for TopLevelState {
         self.account.commit(&mut trie)?;
         self.metadata.commit(&mut trie)?;
         self.shard.commit(&mut trie)?;
+        self.action_data.commit(&mut trie)?;
         Ok(())
     }
 
@@ -213,12 +224,16 @@ impl StateWithCache for TopLevelState {
         self.shard.propagate_to_global_cache(|address, item, modified| {
             db.add_to_shard_cache(address, item, modified);
         });
+        self.action_data.propagate_to_global_cache(|address, item, modified| {
+            db.add_to_action_data_cache(address, item, modified);
+        });
     }
 
     fn clear(&mut self) {
         self.account.clear();
         self.metadata.clear();
         self.shard.clear();
+        self.action_data.clear();
     }
 }
 
@@ -238,6 +253,7 @@ impl TopLevelState {
             account: Cache::new(),
             metadata: Cache::new(),
             shard: Cache::new(),
+            action_data: Cache::new(),
             id_of_checkpoints: Default::default(),
             trie_factory,
         }
@@ -255,6 +271,7 @@ impl TopLevelState {
             account: Cache::new(),
             metadata: Cache::new(),
             shard: Cache::new(),
+            action_data: Cache::new(),
             id_of_checkpoints: Default::default(),
             trie_factory,
         };
@@ -511,13 +528,21 @@ impl TopLevelState {
         let from_db = || self.db.get_cached_shard(&shard_address);
         self.shard.require_item_or_from(&shard_address, default, db, from_db)
     }
+
+    fn require_action_data<'a>(&'a self, key: &H256) -> TrieResult<RefMut<'a, Bytes>> {
+        let default = || NULL_RLP.to_vec();
+        let db = self.trie_factory.readonly(self.db.as_hashdb(), &self.root)?;
+        let from_db = || self.db.get_cached_action_data(key);
+        self.action_data.require_item_or_from(key, default, db, from_db)
+    }
 }
 
 impl fmt::Debug for TopLevelState {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(f, "account: {:?}", self.account)?;
         writeln!(f, "metadata: {:?}", self.metadata)?;
         writeln!(f, "shard: {:?}", self.shard)?;
+        writeln!(f, "action_data: {:?}", self.action_data)?;
         Ok(())
     }
 }
@@ -533,6 +558,7 @@ impl Clone for TopLevelState {
             account: self.account.clone(),
             metadata: self.metadata.clone(),
             shard: self.shard.clone(),
+            action_data: self.action_data.clone(),
             trie_factory: self.trie_factory.clone(),
         }
     }
@@ -620,6 +646,12 @@ impl TopState<StateDB> for TopLevelState {
         shard.set_root(*new_root);
         Ok(())
     }
+
+    fn update_action_data(&mut self, key: &H256, data: Bytes) -> StateResult<()> {
+        let mut action_data = self.require_action_data(key)?;
+        *action_data = data;
+        Ok(())
+    }
 }
 
 #[cfg(test)]
diff --git a/state/src/item/cache.rs b/state/src/item/cache.rs
@@ -22,6 +22,7 @@ use std::fmt;
 use std::hash::Hash;
 use std::vec::Vec;
 
+use primitives::{Bytes, H256};
 use rlp::{Decodable, Encodable};
 use trie::{self, Result as TrieResult, Trie, TrieKinds, TrieMut};
 
@@ -30,6 +31,13 @@ pub trait CacheableItem: Clone + fmt::Debug + Decodable + Encodable {
     fn is_null(&self) -> bool;
 }
 
+impl CacheableItem for Bytes {
+    type Address = H256;
+    fn is_null(&self) -> bool {
+        self.is_empty()
+    }
+}
+
 #[derive(Eq, PartialEq, Clone, Copy, Debug)]
 /// Account modification state. Used to check if the account was
 /// Modified in between commits and overall.
diff --git a/state/src/lib.rs b/state/src/lib.rs
@@ -39,6 +39,7 @@ extern crate serde_derive;
 extern crate unexpected;
 extern crate util_error;
 
+mod action_handler;
 mod backend;
 mod checkpoint;
 mod db;
diff --git a/state/src/traits.rs b/state/src/traits.rs
