Improve performance of BlockSet<T>

CHANGES.md

@@ -257,6 +257,8 @@ To be released.
  -  `BlockChain<T>` instead of `BlockPolicy<T>` became to validate `Block<T>`s to append
     so that even if an empty implementation of `IBlockPolicy<T>` is used `Block<T>`s are
     unable to be appended to `BlockChain<T>`.  [[#1010]]
+ -  Improved performance of `BlockSet<T>[HashDigest<SHA256>]` and `BlockChain<T>.Genesis`
+    by caching.  [[#1013]]
 
 ### Bug fixes
 
@@ -359,6 +361,7 @@ To be released.
 [#1004]: https://github.com/planetarium/libplanet/pull/1004
 [#1010]: https://github.com/planetarium/libplanet/pull/1010
 [#1012]: https://github.com/planetarium/libplanet/pull/1012
+[#1013]: https://github.com/planetarium/libplanet/pull/1013
 [sleep mode]: https://en.wikipedia.org/wiki/Sleep_mode
 
 

Libplanet/Blockchain/BlockChain.cs

@@ -62,6 +62,11 @@ public class BlockChain<T>
         /// </summary>
         private IDictionary<TxId, Transaction<T>> _transactions;
 
+        /// <summary>
+        /// Cached genesis block.
+        /// </summary>
+        private Block<T> _genesis;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="BlockChain{T}"/> class.
         /// </summary>
@@ -235,7 +240,7 @@ public Block<T> Tip
         /// <summary>
         /// The first <see cref="Block{T}"/> in the <see cref="BlockChain{T}"/>.
         /// </summary>
-        public Block<T> Genesis => this[0];
+        public Block<T> Genesis => _genesis ??= this[0];
 
         public Guid Id { get; private set; }
 

Libplanet/Store/BlockSet.cs

@@ -4,23 +4,29 @@
 using System.Security.Cryptography;
 using Libplanet.Action;
 using Libplanet.Blocks;
+using LruCacheNet;
 
 namespace Libplanet.Store
 {
     public class BlockSet<T> : BaseIndex<HashDigest<SHA256>, Block<T>>
         where T : IAction, new()
     {
+        // FIXME it should be configurable
+        private const int DefaultCacheSize = 4096;
+        private readonly LruCache<HashDigest<SHA256>, Block<T>> _cache;
+
         public BlockSet(IStore store)
             : base(store)
         {
+            _cache = new LruCache<HashDigest<SHA256>, Block<T>>(DefaultCacheSize);
         }
 
         public override ICollection<HashDigest<SHA256>> Keys =>
             Store.IterateBlockHashes().ToList();
 
         public override ICollection<Block<T>> Values =>
             Store.IterateBlockHashes()
-                .Select(Store.GetBlock<T>)
+                .Select(GetBlock)
                 .ToList();
 
         public override int Count => (int)Store.CountBlocks();
@@ -31,7 +37,7 @@ public override Block<T> this[HashDigest<SHA256> key]
         {
             get
             {
-                Block<T> block = Store.GetBlock<T>(key);
+                Block<T> block = GetBlock(key);
                 if (block is null)
                 {
                     throw new KeyNotFoundException(
@@ -58,6 +64,7 @@ public override Block<T> this[HashDigest<SHA256> key]
 
                 value.Validate(DateTimeOffset.UtcNow);
                 Store.PutBlock(value);
+                _cache.Add(value.Hash, value);
             }
         }
 
@@ -74,7 +81,30 @@ public override bool ContainsKey(HashDigest<SHA256> key)
 
         public override bool Remove(HashDigest<SHA256> key)
         {
-            return Store.DeleteBlock(key);
+            bool deleted = Store.DeleteBlock(key);
+
+            if (deleted)
+            {
+                _cache.Remove(key);
+            }
+
+            return deleted;
+        }
+
+        private Block<T> GetBlock(HashDigest<SHA256> key)
+        {
+            if (_cache.TryGetValue(key, out Block<T> cached))
+            {
+                return cached;
+            }
+
+            Block<T> fetched = Store.GetBlock<T>(key);
+            if (!(fetched is null))
+            {
+                _cache.Add(key, fetched);
+            }
+
+            return fetched;
         }
     }
 }