Storage stat cache for accelerator

Author: SpyCheese

crypto/block/account-storage-stat.cpp

@@ -36,8 +36,7 @@ AccountStorageStat::AccountStorageStat(const AccountStorageStat* parent)
   CHECK(parent_->parent_ == nullptr);
 }
 
-td::Status AccountStorageStat::replace_roots(std::vector<Ref<vm::Cell>> new_roots, bool check_merkle_depth,
-                                             td::HashSet<vm::CellHash>* store_added) {
+td::Status AccountStorageStat::replace_roots(std::vector<Ref<vm::Cell>> new_roots, bool check_merkle_depth) {
   std::erase_if(new_roots, [](const Ref<vm::Cell>& c) { return c.is_null(); });
   if (new_roots.empty()) {
     roots_.clear();
@@ -74,9 +73,6 @@ td::Status AccountStorageStat::replace_roots(std::vector<Ref<vm::Cell>> new_root
   roots_ = std::move(new_roots);
   dict_up_to_date_ = false;
   for (auto& [_, e] : cache_) {
-    if (store_added && !e.exists && e.refcnt_diff > 0) {
-      store_added->insert(e.hash);
-    }
     TRY_STATUS(finalize_entry(e));
   }
   return td::Status::OK();

crypto/block/account-storage-stat.h

@@ -39,8 +39,7 @@ class AccountStorageStat {
   AccountStorageStat &operator=(const AccountStorageStat &other) = delete;
   AccountStorageStat &operator=(AccountStorageStat &&other) = default;
 
-  td::Status replace_roots(std::vector<Ref<vm::Cell>> new_roots, bool check_merkle_depth = false,
-                           td::HashSet<vm::CellHash> *store_added = nullptr);
+  td::Status replace_roots(std::vector<Ref<vm::Cell>> new_roots, bool check_merkle_depth = false);
   void add_hint(const td::HashSet<vm::CellHash> &visited);
 
   td::uint64 get_total_cells() const {

crypto/block/transaction.cpp

@@ -602,11 +602,9 @@ static td::Ref<vm::CellSlice> storage_without_extra_currencies(td::Ref<vm::CellS
  * This requires storage_dict_hash to be set, as it guarantees that the stored storage_used was computed recently
  * (in older versions it included extra currency balance, in newer versions it does not).
  *
- * @param storage_cells If not null, store all hashes of cells in storage to storage_cells.
- *
  * @returns Root of the dictionary, or Error
  */
-td::Result<Ref<vm::Cell>> Account::compute_account_storage_dict(td::HashSet<vm::CellHash>* storage_cells) const {
+td::Result<Ref<vm::Cell>> Account::compute_account_storage_dict() const {
   if (storage.is_null()) {
     return td::Status::Error("cannot compute storage dict: empty storage");
   }
@@ -618,7 +616,7 @@ td::Result<Ref<vm::Cell>> Account::compute_account_storage_dict(td::HashSet<vm::
   if (storage_for_stat.is_null()) {
     return td::Status::Error("cannot compute storage dict: invalid storage");
   }
-  TRY_STATUS(stat.replace_roots(storage_for_stat->prefetch_all_refs(), false, storage_cells));
+  TRY_STATUS(stat.replace_roots(storage_for_stat->prefetch_all_refs()));
   // Root of AccountStorage is not counted in AccountStorageStat
   td::uint64 expected_cells = stat.get_total_cells() + 1;
   td::uint64 expected_bits = stat.get_total_bits() + storage->size();

crypto/block/transaction.h

@@ -301,7 +301,7 @@ struct Account {
   bool set_address(ton::WorkchainId wc, td::ConstBitPtr new_addr);
   bool unpack(Ref<vm::CellSlice> account, ton::UnixTime now, bool special);
   bool init_new(ton::UnixTime now);
-  td::Result<Ref<vm::Cell>> compute_account_storage_dict(td::HashSet<vm::CellHash>* storage_cells = nullptr) const;
+  td::Result<Ref<vm::Cell>> compute_account_storage_dict() const;
   td::Status init_account_storage_stat(Ref<vm::Cell> dict_root);
   bool deactivate();
   bool recompute_tmp_addr(Ref<vm::CellSlice>& tmp_addr, int fixed_prefix_length, td::ConstBitPtr orig_addr_rewrite) const;

crypto/vm/cells/CellUsageTree.cpp

@@ -99,11 +99,11 @@ void CellUsageTree::mark_path(NodeId node_id) {
   }
 }
 
-CellUsageTree::NodeId CellUsageTree::get_parent(NodeId node_id) {
+CellUsageTree::NodeId CellUsageTree::get_parent(NodeId node_id) const {
   return nodes_[node_id].parent;
 }
 
-CellUsageTree::NodeId CellUsageTree::get_child(NodeId node_id, unsigned ref_id) {
+CellUsageTree::NodeId CellUsageTree::get_child(NodeId node_id, unsigned ref_id) const {
   DCHECK(ref_id < CellTraits::max_refs);
   return nodes_[node_id].children[ref_id];
 }

crypto/vm/cells/CellUsageTree.h

@@ -59,8 +59,8 @@ class CellUsageTree : public std::enable_shared_from_this<CellUsageTree> {
   bool has_mark(NodeId node_id) const;
   void set_mark(NodeId node_id, bool mark = true);
   void mark_path(NodeId node_id);
-  NodeId get_parent(NodeId node_id);
-  NodeId get_child(NodeId node_id, unsigned ref_id);
+  NodeId get_parent(NodeId node_id) const;
+  NodeId get_child(NodeId node_id, unsigned ref_id) const;
   void set_use_mark_for_is_loaded(bool use_mark = true);
   NodeId create_child(NodeId node_id, unsigned ref_id);
 

crypto/vm/cells/MerkleProof.h

@@ -74,6 +74,9 @@ class MerkleProofBuilder {
   void set_cell_load_callback(std::function<void(const LoadedCell&)> f) {
     usage_tree->set_cell_load_callback(std::move(f));
   }
+  const CellUsageTree &get_usage_tree() const {
+    return *usage_tree;
+  }
 };
 
 }  // namespace vm

validator/impl/collator-impl.h

@@ -227,7 +227,6 @@ class Collator final : public td::actor::Actor {
     vm::ProofStorageStat proof_stat;
     bool add_to_collated_data = false;
     std::vector<Ref<vm::Cell>> storage_stat_updates;
-    td::HashSet<vm::CellHash> original_storage_cells;
   };
   std::map<td::Bits256, AccountStorageDict> account_storage_dicts_;
 
@@ -275,7 +274,8 @@ class Collator final : public td::actor::Actor {
   void after_get_shard_state(int idx, td::Result<Ref<ShardState>> res, td::PerfLogAction token);
   void after_get_block_data(int idx, td::Result<Ref<BlockData>> res, td::PerfLogAction token);
   void after_get_shard_blocks(td::Result<std::vector<Ref<ShardTopBlockDescription>>> res, td::PerfLogAction token);
-  void after_get_storage_stat_cache(td::Result<std::function<td::Ref<vm::Cell>(const td::Bits256&)>> res);
+  void after_get_storage_stat_cache(td::Result<std::function<td::Ref<vm::Cell>(const td::Bits256&)>> res,
+                                    td::PerfLogAction token);
   bool preprocess_prev_mc_state();
   bool register_mc_state(Ref<MasterchainStateQ> other_mc_state);
   bool request_aux_mc_state(BlockSeqno seqno, Ref<MasterchainStateQ>& state);
@@ -360,7 +360,7 @@ class Collator final : public td::actor::Actor {
   bool update_account_dict_estimation(const block::transaction::Transaction& trans);
   void update_account_storage_dict_info(const block::transaction::Transaction& trans);
   bool update_min_mc_seqno(ton::BlockSeqno some_mc_seqno);
-  bool process_account_storage_dict(const block::Account& account);
+  bool process_account_storage_dict(block::Account& account);
   bool combine_account_transactions();
   bool update_public_libraries();
   bool update_account_public_libraries(Ref<vm::Cell> orig_libs, Ref<vm::Cell> final_libs, const td::Bits256& addr);