Dynamic trie pruning

cmake/Hunter/hunter-gate-url.cmake

@@ -1,5 +1,5 @@
 HunterGate(
-  URL  "https://github.com/soramitsu/soramitsu-hunter/archive/refs/tags/v0.23.257-soramitsu49.zip"
-  SHA1 "a03391d0018024284a360d9e05594d7fa4e42851"
+  URL  "https://github.com/soramitsu/soramitsu-hunter/archive/refs/tags/v0.23.257-soramitsu51.zip"
+  SHA1 "1839ed95f13509c4767216ee17b9793798e08a6f"
   LOCAL
 )

core/api/service/child_state/impl/child_state_api_impl.cpp

@@ -129,7 +129,8 @@ namespace kagome::api {
                 storage_->getEphemeralBatchAt(child_root_hash));
     auto res = child_storage_trie_reader->tryGet(key);
     return common::map_result_optional(
-        std::move(res), [](common::BufferOrView &&r) { return r.into(); });
+        std::move(res),
+        [](common::BufferOrView &&r) { return r.into_buffer(); });
   }
 
   outcome::result<std::optional<primitives::BlockHash>>

core/api/service/state/impl/state_api_impl.cpp

@@ -122,7 +122,7 @@ namespace kagome::api {
     OUTCOME_TRY(trie_reader, storage_->getEphemeralBatchAt(header.state_root));
     auto res = trie_reader->tryGet(key);
     return common::map_result_optional(
-        std::move(res), [](common::BufferOrView &&r) { return r.into(); });
+        std::move(res), [](common::BufferOrView &&r) { return r.into_buffer(); });
   }
 
   outcome::result<std::vector<StateApiImpl::StorageChangeSet>>
@@ -164,7 +164,7 @@ namespace kagome::api {
         OUTCOME_TRY(opt_get, batch->tryGet(key));
         auto opt_value = common::map_optional(
             std::move(opt_get),
-            [](common::BufferOrView &&r) { return r.into(); });
+            [](common::BufferOrView &&r) { return r.into_buffer(); });
         auto it = last_values.find(key);
         if (it == last_values.end() || it->second != opt_value) {
           change.changes.push_back(StorageChangeSet::Change{key, opt_value});

core/application/impl/app_configuration_impl.cpp

@@ -244,6 +244,7 @@ namespace kagome::application {
         offchain_worker_mode_{def_offchain_worker_mode},
         enable_offchain_indexing_{def_enable_offchain_indexing},
         recovery_state_{def_block_to_recover},
+        db_cache_size_{def_db_cache_size},
         state_pruning_depth_{} {
     SL_INFO(logger_, "Soramitsu Kagome started. Version: {} ", buildVersion());
   }

core/authority_discovery/query/query_impl.cpp

@@ -122,7 +122,7 @@ namespace kagome::authority_discovery {
       auto authority = queue_.back();
       queue_.pop_back();
 
-      common::Buffer hash = crypto::sha256(authority);
+      common::Buffer hash {crypto::sha256(authority)};
       scheduler_->schedule([=, wp = weak_from_this()] {
         if (auto self = wp.lock()) {
           std::ignore = kademlia_->getValue(

core/blockchain/impl/block_tree_impl.cpp

@@ -768,8 +768,7 @@ namespace kagome::blockchain {
         node->has_justification = true;
 
         OUTCOME_TRY(pruneNoLock(p, node));
-        OUTCOME_TRY(pruneTrie(
-            p, last_finalized_block_info.number, node->getBlockInfo().number));
+        OUTCOME_TRY(pruneTrie(p, node->getBlockInfo().number));
 
         p.tree_->updateTreeRoot(node);
 
@@ -1420,55 +1419,37 @@ namespace kagome::blockchain {
 
   outcome::result<void> BlockTreeImpl::pruneTrie(
       const BlockTreeData &block_tree_data,
-      primitives::BlockNumber old_finalized,
       primitives::BlockNumber new_finalized) {
     // pruning is disabled
     if (!block_tree_data.state_pruner_->getPruningDepth().has_value()) {
       return outcome::success();
     }
     auto *root_node = &block_tree_data.tree_->getRoot();
-    BOOST_ASSERT(root_node->depth == old_finalized);
     auto last_pruned = block_tree_data.state_pruner_->getLastPrunedBlock();
+
     BOOST_ASSERT(!last_pruned.has_value()
                  || last_pruned.value().number <= root_node->depth);
     auto next_pruned_number = last_pruned ? last_pruned->number + 1 : 0;
+
     OUTCOME_TRY(hash_opt, getBlockHash(next_pruned_number));
     BOOST_ASSERT(hash_opt.has_value());
     primitives::BlockHash hash = std::move(*hash_opt);
-    auto last_to_prune =
-        new_finalized
-        - block_tree_data.state_pruner_->getPruningDepth().value_or(0);
-    for (auto n = next_pruned_number;
-         n < std::min(old_finalized, last_to_prune);
-         n++) {
+    auto pruning_depth =
+        block_tree_data.state_pruner_->getPruningDepth().value_or(0);
+    if (new_finalized < pruning_depth) {
+      return outcome::success();
+    }
+
+    auto last_to_prune = new_finalized - pruning_depth;
+    for (auto n = next_pruned_number; n < last_to_prune; n++) {
       OUTCOME_TRY(next_hash_opt, getBlockHash(n + 1));
       BOOST_ASSERT(next_hash_opt.has_value());
       auto &next_hash = *next_hash_opt;
       OUTCOME_TRY(header, getBlockHeader(hash));
       OUTCOME_TRY(block_tree_data.state_pruner_->pruneFinalized(header));
       hash = std::move(next_hash);
     }
-    BOOST_ASSERT(
-        block_tree_data.state_pruner_->getLastPrunedBlock().has_value()
-        && block_tree_data.state_pruner_->getLastPrunedBlock().value().number
-               == root_node->depth);
-
-    auto *current_node = root_node;
-    for (auto n = block_tree_data.state_pruner_->getLastPrunedBlock()->number;
-         n < last_to_prune;
-         n++) {
-      BOOST_ASSERT(current_node->children.size() == 1);
-      auto next_node = current_node->children[0].get();
-      OUTCOME_TRY(
-          header_opt,
-          block_tree_data.storage_->getBlockHeader(current_node->block_hash));
-      if (!header_opt.has_value()) {
-        return BlockTreeError::HEADER_NOT_FOUND;
-      }
-      auto &header = header_opt.value();
-      OUTCOME_TRY(block_tree_data.state_pruner_->pruneFinalized(header));
-      current_node = next_node;
-    }
+
     return outcome::success();
   }
 

core/blockchain/impl/block_tree_impl.hpp

@@ -201,7 +201,6 @@ namespace kagome::blockchain {
         const BlockTreeData &p, const primitives::BlockHash &block_hash) const;
 
     outcome::result<void> pruneTrie(const BlockTreeData &block_tree_data,
-                                    primitives::BlockNumber old_finalized,
                                     primitives::BlockNumber new_finalized);
 
     outcome::result<void> reorganizeNoLock(BlockTreeData &p);

core/common/buffer.hpp

@@ -50,7 +50,7 @@ namespace kagome::common {
     SLBuffer(const BufferView &s) : Base(s.begin(), s.end()) {}
 
     template <size_t N>
-    SLBuffer(const std::array<typename Base::value_type, N> &other)
+    explicit SLBuffer(const std::array<typename Base::value_type, N> &other)
         : Base(other.begin(), other.end()) {}
 
     SLBuffer(const uint8_t *begin, const uint8_t *end) : Base(begin, end){};

core/common/buffer_or_view.hpp

@@ -16,6 +16,7 @@ namespace kagome::common {
   /// Moved owned buffer or readonly view.
   class BufferOrView {
     using Span = gsl::span<const uint8_t>;
+
     template <typename T>
     using AsSpan = std::enable_if_t<std::is_convertible_v<T, Span>>;
 
@@ -41,7 +42,7 @@ namespace kagome::common {
     BufferOrView &operator=(BufferOrView &&) = default;
 
     /// Is buffer owned.
-    bool owned() const {
+    bool is_owned() const {
       if (variant.which() == 2) {
         throw std::logic_error{"Tried to use moved BufferOrView"};
       }
@@ -50,7 +51,7 @@ namespace kagome::common {
 
     /// Get view.
     BufferView view() const {
-      if (!owned()) {
+      if (!is_owned()) {
         return boost::get<BufferView>(variant);
       }
       return BufferView{boost::get<Buffer>(variant)};
@@ -68,15 +69,15 @@ namespace kagome::common {
 
     /// Get mutable buffer reference. Copy once if view.
     Buffer &mut() {
-      if (!owned()) {
+      if (!is_owned()) {
         auto view = boost::get<BufferView>(variant);
         variant = Buffer{view};
       }
       return boost::get<Buffer>(variant);
     }
 
     /// Move buffer away. Copy once if view.
-    Buffer into() {
+    Buffer into_buffer() {
       auto buffer = std::move(mut());
       variant = Moved{};
       return buffer;

core/common/size_limited_containers.hpp

@@ -50,7 +50,7 @@ namespace kagome::common {
 
     SizeLimitedContainer() = default;
 
-    SizeLimitedContainer(size_t size)
+    explicit SizeLimitedContainer(size_t size)
         : Base([&] {
             if constexpr (size_check_is_enabled) {
               if (unlikely(size > max_size())) {

core/consensus/babe/impl/babe_config_repository_impl.cpp

@@ -842,25 +842,21 @@ namespace kagome::consensus::babe {
 
   void BabeConfigRepositoryImpl::readFromState(
       const primitives::BlockInfo &block) {
-    auto check_res = [this, &block](const auto &res, const auto &msg) {
-      if (!res) {
-        logger_->error("readFromState {}, error: {}", block, msg);
-        return false;
-      }
-      return true;
-    };
     auto hash1_opt_res = block_tree_->getBlockHash(1);
-    if (!check_res(hash1_opt_res, hash1_opt_res.error())) {
+    if (!hash1_opt_res) {
+      logger_->error(
+          "readFromState {}, error: {}", block, hash1_opt_res.error());
       return;
     }
-    if (!check_res(hash1_opt_res.value().has_value(),
-                   "Block #1 not present in the storage")) {
+    if (!hash1_opt_res.value().has_value()) {
+      logger_->error(
+          "readFromState {}, error: \"Block #1 not present in the storage\"",
+          block);
       return;
     }
-
     auto header1_res = block_tree_->getBlockHeader(*hash1_opt_res.value());
-    if (!check_res(header1_res,
-                   header1_res.error())) {
+    if (!header1_res) {
+      logger_->error("readFromState {}, error: {}", block, header1_res.error());
       return;
     }
 

core/consensus/babe/impl/babe_impl.cpp

@@ -1088,8 +1088,7 @@ namespace kagome::consensus::babe {
                 return common::Buffer{scale::encode(ext).value()};
               }));
           return ext_root_res.has_value()
-             and (ext_root_res.value()
-                  == common::Buffer(block.header.extrinsics_root));
+             and (ext_root_res.value() == block.header.extrinsics_root);
         }(),
         "Extrinsics root does not match extrinsics in the block");
 

core/host_api/impl/storage_extension.cpp

@@ -354,12 +354,12 @@ namespace kagome::host_api {
       auto res = memory.storeBuffer(storage::trie::kEmptyRootHash);
       return runtime::PtrSize(res).ptr;
     }
-    storage::trie::PolkadotTrieImpl trie;
+    auto trie = storage::trie::PolkadotTrieImpl::createEmpty();
     for (auto &&p : pv) {
       auto &&key = p.first;
       common::BufferView value = p.second;
       // already scale-encoded
-      auto put_res = trie.put(key, value);
+      auto put_res = trie->put(key, value);
       if (not put_res) {
         logger_->error(
             "Insertion of value {} with key {} into the trie failed due to "
@@ -370,7 +370,7 @@ namespace kagome::host_api {
       }
     }
     const auto &enc =
-        codec.encodeNode(*trie.getRoot(), storage::trie::StateVersion::V0, {});
+        codec.encodeNode(*trie->getRoot(), storage::trie::StateVersion::V0, {});
     if (!enc) {
       logger_->error("failed to encode trie root: {}", enc.error());
       throw std::runtime_error(enc.error().message());

core/injector/calculate_genesis_state.hpp

@@ -19,14 +19,14 @@ namespace kagome::injector {
       const runtime::ModuleFactory &module_factory,
       storage::trie::TrieSerializer &trie_serializer) {
     auto trie_from = [](const application::GenesisRawData &kv) {
-      storage::trie::PolkadotTrieImpl trie;
+      auto trie = storage::trie::PolkadotTrieImpl::createEmpty();
       for (auto &[k, v] : kv) {
-        trie.put(k, common::BufferView{v}).value();
+        trie->put(k, common::BufferView{v}).value();
       }
       return trie;
     };
     auto top_trie = trie_from(chain_spec.getGenesisTopSection());
-    OUTCOME_TRY(code, top_trie.get(storage::kRuntimeCodeKey));
+    OUTCOME_TRY(code, top_trie->get(storage::kRuntimeCodeKey));
     OUTCOME_TRY(env,
                 runtime::RuntimeEnvironment::fromCode(module_factory, code));
     runtime::CoreImpl core_api{
@@ -35,18 +35,19 @@ namespace kagome::injector {
     };
     OUTCOME_TRY(runtime_version, core_api.version(env));
     auto version = storage::trie::StateVersion{runtime_version.state_version};
-    std::vector<storage::trie::PolkadotTrieImpl> child_tries;
+    std::vector<std::shared_ptr<storage::trie::PolkadotTrie>> child_tries;
     for (auto &[child, kv] : chain_spec.getGenesisChildrenDefaultSection()) {
       child_tries.emplace_back(trie_from(kv));
-      OUTCOME_TRY(root, trie_serializer.storeTrie(child_tries.back(), version));
+      OUTCOME_TRY(root, trie_serializer.storeTrie(*child_tries.back(), version));
 
       common::Buffer child2;
       child2 += storage::kChildStorageDefaultPrefix;
       child2 += child;
-      top_trie.put(child2, common::BufferView{root}).value();
+      top_trie->put(child2, common::BufferView{root}).value();
     }
 
-    OUTCOME_TRY(trie_hash, trie_serializer.storeTrie(top_trie, version));
+    OUTCOME_TRY(code_, top_trie->get(storage::kRuntimeCodeKey));
+    OUTCOME_TRY(trie_hash, trie_serializer.storeTrie(*top_trie, version));
 
     return trie_hash;
   }

core/network/impl/state_sync_request_flow.cpp

@@ -29,7 +29,7 @@ namespace kagome::network {
       const primitives::BlockHeader &block)
       : state_pruner_{state_pruner}, block_info_{block_info}, block_{block} {
     BOOST_ASSERT(state_pruner_ != nullptr);
-    roots_.insert({std::nullopt, Root{storage::trie::PolkadotTrieImpl{}, {}}});
+    roots_.insert({std::nullopt, Root{storage::trie::PolkadotTrieImpl::createEmpty(), {}}});
   }
 
   bool StateSyncRequestFlow::complete() const {
@@ -74,7 +74,7 @@ namespace kagome::network {
           OUTCOME_TRY(hash, RootHash::fromSpan(value));
           roots_[hash].children.emplace_back(key);
         } else {
-          root.trie.put(key, common::BufferView{value}).value();
+          root.trie->put(key, common::BufferView{value}).value();
         }
       }
       if (entry.complete) {
@@ -90,7 +90,7 @@ namespace kagome::network {
       storage::trie::TrieSerializer &trie_serializer) {
     assert(complete());
     auto &top = roots_[std::nullopt];
-    OUTCOME_TRY(code, top.trie.get(storage::kRuntimeCodeKey));
+    OUTCOME_TRY(code, top.trie->get(storage::kRuntimeCodeKey));
     OUTCOME_TRY(env,
                 runtime::RuntimeEnvironment::fromCode(module_factory, code));
     OUTCOME_TRY(runtime_version, core_api.version(env));
@@ -101,27 +101,21 @@ namespace kagome::network {
       if (not expected) {
         continue;
       }
-      OUTCOME_TRY(actual, trie_serializer.storeTrie(root.trie, version));
-      OUTCOME_TRY(state_pruner_->addNewState(root.trie, version));
+      OUTCOME_TRY(actual, trie_serializer.storeTrie(*root.trie, version));
+      OUTCOME_TRY(state_pruner_->addNewState(*root.trie, version));
       if (actual != expected) {
         return Error::HASH_MISMATCH;
       }
       for (auto &child : root.children) {
         child_hashes.emplace_back(child, actual);
-        top.trie.put(child, common::BufferView{actual}).value();
+        top.trie->put(child, common::BufferView{actual}).value();
       }
     }
-    OUTCOME_TRY(actual, trie_serializer.storeTrie(top.trie, version));
-    OUTCOME_TRY(state_pruner_->addNewState(top.trie, version));
+    OUTCOME_TRY(actual, trie_serializer.storeTrie(*top.trie, version));
+    OUTCOME_TRY(state_pruner_->addNewState(*top.trie, version));
     if (actual != block_.state_root) {
       return Error::HASH_MISMATCH;
     }
-    for (auto &[child_key, child_hash] : child_hashes) {
-      using Parent = storage::trie_pruner::TriePruner::Parent;
-      using Child = storage::trie_pruner::TriePruner::Child;
-      OUTCOME_TRY(state_pruner_->markAsChild(
-          Parent{actual}, child_key, Child{child_hash}));
-    }
     return outcome::success();
   }
 }  // namespace kagome::network

core/network/impl/state_sync_request_flow.hpp

@@ -38,7 +38,8 @@ namespace kagome::network {
   class StateSyncRequestFlow {
     using RootHash = storage::trie::RootHash;
     struct Root {
-      storage::trie::PolkadotTrieImpl trie;
+      std::shared_ptr<storage::trie::PolkadotTrie> trie =
+          storage::trie::PolkadotTrieImpl::createEmpty();
       std::vector<common::Buffer> children;
     };
 

core/offchain/impl/offchain_local_storage.cpp

@@ -88,6 +88,6 @@ namespace kagome::offchain {
 
     auto iKey = internalKey(key);
     OUTCOME_TRY(value, storage_->get(iKey));
-    return value.into();
+    return value.into_buffer();
   }
 }  // namespace kagome::offchain

core/offchain/impl/offchain_persistent_storage.cpp

@@ -67,7 +67,7 @@ namespace kagome::offchain {
       const common::BufferView &key) {
     auto iKey = internalKey(key);
     OUTCOME_TRY(value, storage_->get(iKey));
-    return value.into();
+    return value.into_buffer();
   }
 
 }  // namespace kagome::offchain