Make DB store metadata

Author: Seulgi Kim

core/src/state/backend.rs

@@ -40,7 +40,9 @@
 use ctypes::Address;
 use hashdb::{AsHashDB, HashDB};
 
-use super::{Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Shard, ShardAddress};
+use super::{
+    Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, Metadata, MetadataAddress, Shard, ShardAddress,
+};
 
 /// State backend. See module docs for more details.
 pub trait Backend: Send {
@@ -54,11 +56,13 @@ pub trait Backend: Send {
 pub trait TopBackend: Send {
     /// Add an account entry to the cache.
     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);
 
     /// 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>>;
 
     /// Get value from a cached account.
@@ -100,12 +104,18 @@ impl<H: AsHashDB + Send + Sync> Backend for Basic<H> {
 impl<H: AsHashDB + Send + Sync> TopBackend for Basic<H> {
     fn add_to_account_cache(&mut self, _: Address, _: Option<Account>, _: bool) {}
 
+    fn add_to_metadata_cache(&mut self, _: MetadataAddress, _: Option<Metadata>, _: bool) {}
+
     fn add_to_shard_cache(&mut self, _: ShardAddress, _: Option<Shard>, _modified: bool) {}
 
     fn get_cached_account(&self, _: &Address) -> Option<Option<Account>> {
         None
     }
 
+    fn get_cached_metadata(&self, _: &MetadataAddress) -> Option<Option<Metadata>> {
+        None
+    }
+
     fn get_cached_shard(&self, _: &ShardAddress) -> Option<Option<Shard>> {
         None
     }

core/src/state/top_level.rs

@@ -54,6 +54,7 @@ use super::asset_scheme::{AssetScheme, AssetSchemeAddress};
 use super::backend::{Backend, ShardBackend, TopBackend};
 use super::cache::{Cache, CacheableItem};
 use super::info::{ShardStateInfo, TopStateInfo};
+use super::metadata::{Metadata, MetadataAddress};
 use super::shard::{Shard, ShardAddress};
 use super::shard_level::ShardLevelState;
 use super::shard_state::{ShardState, TransactionOutcome};
@@ -118,6 +119,7 @@ pub struct TopLevelState<B> {
     db: B,
     root: H256,
     account: Cache<Account>,
+    metadata: Cache<Metadata>,
     shard: Cache<Shard>,
     id_of_checkpoints: Vec<CheckpointId>,
     trie_factory: TrieFactory,
@@ -175,6 +177,7 @@ impl<B: Backend + TopBackend> StateWithCheckpoint for TopLevelState<B> {
     fn create_checkpoint(&mut self, id: CheckpointId) {
         self.id_of_checkpoints.push(id);
         self.account.checkpoint();
+        self.metadata.checkpoint();
         self.shard.checkpoint();
     }
 
@@ -183,6 +186,7 @@ impl<B: Backend + TopBackend> StateWithCheckpoint for TopLevelState<B> {
         assert_eq!(expected, id);
 
         self.account.discard_checkpoint();
+        self.metadata.discard_checkpoint();
         self.shard.discard_checkpoint();
     }
 
@@ -191,6 +195,7 @@ impl<B: Backend + TopBackend> StateWithCheckpoint for TopLevelState<B> {
         assert_eq!(expected, id);
 
         self.account.revert_to_checkpoint();
+        self.metadata.revert_to_checkpoint();
         self.shard.revert_to_checkpoint();
     }
 }
@@ -199,6 +204,7 @@ impl<B: Backend + TopBackend + ShardBackend> StateWithCache for TopLevelState<B>
     fn commit(&mut self) -> TrieResult<()> {
         let mut trie = self.trie_factory.from_existing(self.db.as_hashdb_mut(), &mut self.root)?;
         self.account.commit(&mut trie)?;
+        self.metadata.commit(&mut trie)?;
         self.shard.commit(&mut trie)?;
         Ok(())
     }
@@ -208,13 +214,17 @@ impl<B: Backend + TopBackend + ShardBackend> StateWithCache for TopLevelState<B>
         self.account.propagate_to_global_cache(|address, item, modified| {
             db.add_to_account_cache(address, item, modified);
         });
+        self.metadata.propagate_to_global_cache(|address, item, modified| {
+            db.add_to_metadata_cache(address, item, modified);
+        });
         self.shard.propagate_to_global_cache(|address, item, modified| {
             db.add_to_shard_cache(address, item, modified);
         });
     }
 
     fn clear(&mut self) {
         self.account.clear();
+        self.metadata.clear();
         self.shard.clear();
     }
 }
@@ -233,6 +243,7 @@ impl<B: Backend + TopBackend + ShardBackend + Clone> TopLevelState<B> {
             db,
             root,
             account: Cache::new(),
+            metadata: Cache::new(),
             shard: Cache::new(),
             id_of_checkpoints: Default::default(),
             trie_factory,
@@ -249,6 +260,7 @@ impl<B: Backend + TopBackend + ShardBackend + Clone> TopLevelState<B> {
             db,
             root,
             account: Cache::new(),
+            metadata: Cache::new(),
             shard: Cache::new(),
             id_of_checkpoints: Default::default(),
             trie_factory,
@@ -400,6 +412,8 @@ trait TopStateInternal<B: Backend + TopBackend> {
     /// Populates local cache if nothing found.
     fn require_account<'a>(&'a self, a: &Address) -> TrieResult<RefMut<'a, Account>>;
 
+    fn require_metadata<'a>(&'a self) -> TrieResult<RefMut<'a, Metadata>>;
+
     fn require_shard<'a>(&'a self, shard_id: u32) -> TrieResult<RefMut<'a, Shard>>;
 }
 
@@ -422,6 +436,14 @@ impl<B: Backend + TopBackend> TopStateInternal<B> for TopLevelState<B> {
         self.account.require_item_or_from(a, default, db, from_db)
     }
 
+    fn require_metadata<'a>(&'a self) -> TrieResult<RefMut<'a, Metadata>> {
+        let default = || Metadata::new(0);
+        let db = self.trie_factory.readonly(self.db.as_hashdb(), &self.root)?;
+        let address = MetadataAddress::new();
+        let from_db = || self.db.get_cached_metadata(&address);
+        self.metadata.require_item_or_from(&address, default, db, from_db)
+    }
+
     fn require_shard<'a>(&'a self, shard_id: u32) -> TrieResult<RefMut<'a, Shard>> {
         let default = || Shard::new(BLAKE_NULL_RLP);
         let db = self.trie_factory.readonly(self.db.as_hashdb(), &self.root)?;
@@ -433,7 +455,10 @@ impl<B: Backend + TopBackend> TopStateInternal<B> for TopLevelState<B> {
 
 impl<B: TopBackend + ShardBackend> fmt::Debug for TopLevelState<B> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "account: {:?} shard: {:?}", self.account, self.shard)
+        writeln!(f, "account: {:?}", self.account)?;
+        writeln!(f, "metadata: {:?}", self.metadata)?;
+        writeln!(f, "shard: {:?}", self.shard)?;
+        Ok(())
     }
 }
 
@@ -446,6 +471,7 @@ impl Clone for TopLevelState<StateDB> {
             root: self.root.clone(),
             id_of_checkpoints: self.id_of_checkpoints.clone(),
             account: self.account.clone(),
+            metadata: self.metadata.clone(),
             shard: self.shard.clone(),
             trie_factory: self.trie_factory.clone(),
         }

core/src/state_db.rs

@@ -28,15 +28,17 @@ use parking_lot::Mutex;
 use util_error::UtilError;
 
 use super::state::{
-    self, Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, CacheableItem, Shard, ShardAddress,
+    self, Account, Asset, AssetAddress, AssetScheme, AssetSchemeAddress, CacheableItem, Metadata, MetadataAddress,
+    Shard, ShardAddress,
 };
 use super::types::BlockNumber;
 
 const STATE_CACHE_BLOCKS: usize = 12;
 
 // The percentage of supplied cache size to go to accounts.
 const ACCOUNT_CACHE_RATIO: usize = 40;
-const SHARD_CACHE_RATIO: usize = 10;
+const METADATA_CACHE_RATIO: usize = 1;
+const SHARD_CACHE_RATIO: usize = 9;
 const ASSET_SCHEME_CACHE_RATIO: usize = 10;
 const ASSET_CACHE_RATIO: usize = 40;
 
@@ -100,12 +102,14 @@ pub struct StateDB {
     db: Box<JournalDB>,
     /// Shared canonical state cache.
     account_cache: Arc<Mutex<Cache<Account>>>,
+    metadata_cache: Arc<Mutex<Cache<Metadata>>>,
     shard_cache: Arc<Mutex<Cache<Shard>>>,
     asset_scheme_cache: Arc<Mutex<Cache<AssetScheme>>>,
     asset_cache: Arc<Mutex<Cache<Asset>>>,
 
     /// 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>>,
@@ -124,11 +128,18 @@ impl StateDB {
     // TODO: make the cache size actually accurate by moving the account storage cache
     // into the `AccountCache` structure as its own `LruCache<(Address, H256), H256>`.
     pub fn new(db: Box<JournalDB>, cache_size: usize) -> StateDB {
-        assert_eq!(100, ACCOUNT_CACHE_RATIO + SHARD_CACHE_RATIO + ASSET_SCHEME_CACHE_RATIO + ASSET_CACHE_RATIO);
+        assert_eq!(
+            100,
+            ACCOUNT_CACHE_RATIO + METADATA_CACHE_RATIO + SHARD_CACHE_RATIO + ASSET_SCHEME_CACHE_RATIO
+                + ASSET_CACHE_RATIO
+        );
 
         let account_cache_size = cache_size * ACCOUNT_CACHE_RATIO / 100;
         let account_cache_items = account_cache_size / ::std::mem::size_of::<Option<Account>>();
 
+        let metadata_cache_size = cache_size * METADATA_CACHE_RATIO / 100;
+        let metadata_cache_items = metadata_cache_size / ::std::mem::size_of::<Option<Metadata>>();
+
         let shard_cache_size = cache_size * SHARD_CACHE_RATIO / 100;
         let shard_cache_items = shard_cache_size / ::std::mem::size_of::<Option<Shard>>();
 
@@ -144,6 +155,10 @@ impl StateDB {
                 cache: LruCache::new(account_cache_items),
                 modifications: VecDeque::new(),
             })),
+            metadata_cache: Arc::new(Mutex::new(Cache {
+                cache: LruCache::new(metadata_cache_items),
+                modifications: VecDeque::new(),
+            })),
             shard_cache: Arc::new(Mutex::new(Cache {
                 cache: LruCache::new(shard_cache_items),
                 modifications: VecDeque::new(),
@@ -158,6 +173,7 @@ impl StateDB {
             })),
 
             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(),
@@ -362,11 +378,13 @@ impl StateDB {
         StateDB {
             db: self.db.boxed_clone(),
             account_cache: self.account_cache.clone(),
+            metadata_cache: self.metadata_cache.clone(),
             shard_cache: self.shard_cache.clone(),
             asset_scheme_cache: self.asset_scheme_cache.clone(),
             asset_cache: self.asset_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(),
@@ -470,11 +488,13 @@ impl Clone for StateDB {
         Self {
             db: self.db.boxed_clone(),
             account_cache: self.account_cache.clone(),
+            metadata_cache: self.metadata_cache.clone(),
             shard_cache: self.shard_cache.clone(),
             asset_scheme_cache: self.asset_scheme_cache.clone(),
             asset_cache: self.asset_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(),
@@ -505,6 +525,14 @@ impl state::TopBackend for StateDB {
         })
     }
 
+    fn add_to_metadata_cache(&mut self, address: MetadataAddress, item: Option<Metadata>, modified: bool) {
+        self.local_metadata_cache.push(CacheQueueItem {
+            address,
+            item,
+            modified,
+        })
+    }
+
     fn add_to_shard_cache(&mut self, address: ShardAddress, item: Option<Shard>, modified: bool) {
         self.local_shard_cache.push(CacheQueueItem {
             address,
@@ -517,6 +545,10 @@ impl state::TopBackend for StateDB {
         self.get_cached(addr, &self.account_cache)
     }
 
+    fn get_cached_metadata(&self, addr: &MetadataAddress) -> Option<Option<Metadata>> {
+        self.get_cached(addr, &self.metadata_cache)
+    }
+
     fn get_cached_shard(&self, addr: &ShardAddress) -> Option<Option<Shard>> {
         self.get_cached(addr, &self.shard_cache)
     }