Don't wait for storing state to celldb in most cases

Author: SpyCheese

validator/apply-block.cpp

@@ -166,7 +166,7 @@ void ApplyBlock::written_block_data() {
     });
 
     td::actor::send_closure(manager_, &ValidatorManager::wait_block_state, handle_, apply_block_priority(), timeout_,
-                            std::move(P));
+                            true, std::move(P));
   }
 }
 

validator/downloaders/wait-block-state-merge.cpp

@@ -55,7 +55,7 @@ void WaitBlockStateMerge::start_up() {
     }
   });
 
-  td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, left_, priority_, timeout_,
+  td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, left_, priority_, timeout_, false,
                           std::move(P_l));
 
   auto P_r = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
@@ -66,7 +66,7 @@ void WaitBlockStateMerge::start_up() {
     }
   });
 
-  td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, right_, priority_, timeout_,
+  td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, right_, priority_, timeout_, false,
                           std::move(P_r));
 }
 

validator/downloaders/wait-block-state.cpp

@@ -32,26 +32,31 @@ void WaitBlockState::alarm() {
 }
 
 void WaitBlockState::abort_query(td::Status reason) {
-  if (promise_) {
+  if (promise_no_store_) {
+    promise_no_store_.set_error(
+        reason.move_as_error_prefix(PSTRING() << "failed to download state " << handle_->id() << ": "));
+  }
+  if (promise_final_) {
     if (priority_ > 0 || (reason.code() != ErrorCode::timeout && reason.code() != ErrorCode::notready)) {
       LOG(WARNING) << "aborting wait block state query for " << handle_->id() << " priority=" << priority_ << ": "
                    << reason;
     } else {
       LOG(DEBUG) << "aborting wait block state query for " << handle_->id() << " priority=" << priority_ << ": "
                  << reason;
     }
-    promise_.set_error(reason.move_as_error_prefix(PSTRING() << "failed to download state " << handle_->id() << ": "));
+    promise_final_.set_error(
+        reason.move_as_error_prefix(PSTRING() << "failed to download state " << handle_->id() << ": "));
   }
   stop();
 }
 
 void WaitBlockState::finish_query() {
   CHECK(handle_->received_state());
-  /*if (handle_->id().is_masterchain() && handle_->inited_proof()) {
-    td::actor::send_closure(manager_, &ValidatorManager::new_block, handle_, prev_state_, [](td::Unit) {});
-  }*/
-  if (promise_) {
-    promise_.set_result(prev_state_);
+  if (promise_no_store_) {
+    promise_no_store_.set_result(prev_state_);
+  }
+  if (promise_final_) {
+    promise_final_.set_result(prev_state_);
   }
   stop();
 }
@@ -275,10 +280,16 @@ void WaitBlockState::got_block_data(td::Ref<BlockData> data) {
 }
 
 void WaitBlockState::apply() {
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
+    if (R.is_error()) {
+      td::actor::send_closure(SelfId, &WaitBlockState::abort_query, R.move_as_error_prefix("db set error: "));
+    } else {
+      td::actor::send_closure(SelfId, &WaitBlockState::written_state, R.move_as_ok());
+    }
+  });
+
   if (opts_->get_permanent_celldb()) {
-    td::actor::send_closure(manager_, &ValidatorManager::set_block_state_from_data, handle_, block_,
-                            std::move(promise_));
-    stop();
+    td::actor::send_closure(manager_, &ValidatorManager::set_block_state_from_data, handle_, block_, std::move(P));
     return;
   }
   TD_PERF_COUNTER(apply_block_to_state);
@@ -289,15 +300,11 @@ void WaitBlockState::apply() {
     return;
   }
 
-  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
-    if (R.is_error()) {
-      td::actor::send_closure(SelfId, &WaitBlockState::abort_query, R.move_as_error_prefix("db set error: "));
-    } else {
-      td::actor::send_closure(SelfId, &WaitBlockState::written_state, R.move_as_ok());
-    }
-  });
-
   td::actor::send_closure(manager_, &ValidatorManager::set_block_state, handle_, prev_state_, std::move(P));
+  if (promise_no_store_) {
+    promise_no_store_.set_result(prev_state_);
+    promise_no_store_ = {};
+  }
 }
 
 void WaitBlockState::written_state(td::Ref<ShardState> upd_state) {
@@ -317,6 +324,10 @@ void WaitBlockState::got_state_from_db(td::Ref<ShardState> state) {
     });
 
     td::actor::send_closure(manager_, &ValidatorManager::set_block_state, handle_, prev_state_, std::move(P));
+    if (promise_no_store_) {
+      promise_no_store_.set_result(prev_state_);
+      promise_no_store_ = {};
+    }
   } else {
     finish_query();
   }

validator/downloaders/wait-block-state.hpp

@@ -28,15 +28,17 @@ class WaitBlockState : public td::actor::Actor {
  public:
   WaitBlockState(BlockHandle handle, td::uint32 priority, td::Ref<ValidatorManagerOptions> opts,
                  td::Ref<MasterchainState> last_masterchain_state, td::actor::ActorId<ValidatorManager> manager,
-                 td::Timestamp timeout, td::Promise<td::Ref<ShardState>> promise,
+                 td::Timestamp timeout, td::Promise<td::Ref<ShardState>> promise_no_store,
+                 td::Promise<td::Ref<ShardState>> promise_final,
                  td::Ref<PersistentStateDescription> persistent_state_desc = {})
       : handle_(std::move(handle))
       , priority_(priority)
       , opts_(opts)
       , last_masterchain_state_(last_masterchain_state)
       , manager_(manager)
       , timeout_(timeout)
-      , promise_(std::move(promise))
+      , promise_no_store_(std::move(promise_no_store))
+      , promise_final_(std::move(promise_final))
       , persistent_state_desc_(std::move(persistent_state_desc))
       , perf_timer_("waitstate", 1.0, [manager](double duration) {
         send_closure(manager, &ValidatorManager::add_perf_timer_stat, "waitstate", duration);
@@ -96,7 +98,8 @@ class WaitBlockState : public td::actor::Actor {
   td::Ref<MasterchainState> last_masterchain_state_;
   td::actor::ActorId<ValidatorManager> manager_;
   td::Timestamp timeout_;
-  td::Promise<td::Ref<ShardState>> promise_;
+  td::Promise<td::Ref<ShardState>> promise_no_store_;
+  td::Promise<td::Ref<ShardState>> promise_final_;
   td::Ref<PersistentStateDescription> persistent_state_desc_;
 
   td::Ref<ShardState> prev_state_;

validator/impl/accept-block.cpp

@@ -626,7 +626,7 @@ void AcceptBlockQuery::got_last_mc_block(std::pair<td::Ref<MasterchainState>, Bl
     VLOG(VALIDATOR_DEBUG) << "shardchain block refers to newer masterchain block " << mc_blkid_.to_str()
                           << ", trying to obtain it";
     td::actor::send_closure_later(manager_, &ValidatorManager::wait_block_state_short, mc_blkid_, priority(), timeout_,
-                                  [SelfId = actor_id(this)](td::Result<Ref<ShardState>> R) {
+                                  false, [SelfId = actor_id(this)](td::Result<Ref<ShardState>> R) {
                                     check_send_error(SelfId, R) ||
                                         td::actor::send_closure_bool(SelfId, &AcceptBlockQuery::got_mc_state,
                                                                      R.move_as_ok());

validator/impl/check-proof.cpp

@@ -344,7 +344,7 @@ void CheckProof::got_block_handle(BlockHandle handle) {
     process_masterchain_state();
     return;
   }
-  td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, prev_[0], priority(), timeout_,
+  td::actor::send_closure(manager_, &ValidatorManager::wait_block_state_short, prev_[0], priority(), timeout_, false,
                           [SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
                             check_send_error(SelfId, R) ||
                                 td::actor::send_closure_bool(SelfId, &CheckProof::got_masterchain_state,

validator/impl/collator.cpp

@@ -299,7 +299,7 @@ void Collator::load_prev_states_blocks() {
     ++pending;
     auto token = perf_log_.start_action(PSTRING() << "wait_block_state #" << i);
     td::actor::send_closure_later(
-        manager, &ValidatorManager::wait_block_state_short, prev_blocks[i], priority(), timeout,
+        manager, &ValidatorManager::wait_block_state_short, prev_blocks[i], priority(), timeout, false,
         [self = get_self(), i, token = std::move(token)](td::Result<Ref<ShardState>> res) mutable {
           LOG(DEBUG) << "got answer to wait_block_state query #" << i;
           td::actor::send_closure_later(std::move(self), &Collator::after_get_shard_state, i, std::move(res),
@@ -340,7 +340,7 @@ void Collator::process_optimistic_prev_block() {
     ++pending;
     auto token = perf_log_.start_action("opt wait_block_state");
     td::actor::send_closure_later(
-        manager, &ValidatorManager::wait_block_state_short, prev_prev[0], priority(), timeout,
+        manager, &ValidatorManager::wait_block_state_short, prev_prev[0], priority(), timeout, false,
         [self = get_self(), token = std::move(token)](td::Result<Ref<ShardState>> res) mutable {
           LOG(DEBUG) << "got answer to wait_block_state query (opt)";
           td::actor::send_closure_later(std::move(self), &Collator::after_get_shard_state_optimistic, std::move(res),
@@ -574,7 +574,7 @@ bool Collator::request_aux_mc_state(BlockSeqno seqno, Ref<MasterchainStateQ>& st
   ++pending;
   auto token = perf_log_.start_action(PSTRING() << "auxiliary wait_block_state " << blkid.to_str());
   td::actor::send_closure_later(
-      manager, &ValidatorManager::wait_block_state_short, blkid, priority(), timeout,
+      manager, &ValidatorManager::wait_block_state_short, blkid, priority(), timeout, false,
       [self = get_self(), blkid, token = std::move(token)](td::Result<Ref<ShardState>> res) mutable {
         LOG(DEBUG) << "got answer to wait_block_state query for " << blkid.to_str();
         td::actor::send_closure_later(std::move(self), &Collator::after_get_aux_shard_state, blkid, std::move(res),

validator/impl/out-msg-queue-proof.cpp

@@ -334,7 +334,7 @@ void OutMsgQueueImporter::get_proof_local(std::shared_ptr<CacheEntry> entry, Blo
     return;
   }
   td::actor::send_closure(
-      manager_, &ValidatorManager::wait_block_state_short, block, 0, entry->timeout,
+      manager_, &ValidatorManager::wait_block_state_short, block, 0, entry->timeout, false,
       [=, SelfId = actor_id(this), manager = manager_, timeout = entry->timeout,
        retry_after = td::Timestamp::in(0.1)](td::Result<Ref<ShardState>> R) mutable {
         if (R.is_error()) {

validator/impl/validate-query.cpp

@@ -372,7 +372,7 @@ void ValidateQuery::start_up() {
       LOG(DEBUG) << "sending wait_block_state() query #" << i << " for " << prev_blocks[i].to_str() << " to Manager";
       ++pending;
       td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, prev_blocks[i], priority(),
-                                    timeout, [self = get_self(), i](td::Result<Ref<ShardState>> res) -> void {
+                                    timeout, false, [self = get_self(), i](td::Result<Ref<ShardState>> res) -> void {
                                       LOG(DEBUG) << "got answer to wait_block_state_short query #" << i;
                                       td::actor::send_closure_later(
                                           std::move(self), &ValidateQuery::after_get_shard_state, i, std::move(res));
@@ -784,7 +784,7 @@ void ValidateQuery::got_mc_handle(td::Result<BlockHandle> res) {
   }
   auto mc_handle = res.move_as_ok();
   td::actor::send_closure_later(
-      manager, &ValidatorManager::wait_block_state, mc_handle, priority(), timeout,
+      manager, &ValidatorManager::wait_block_state, mc_handle, priority(), timeout, false,
       [self = get_self(), id = id_, mc_handle](td::Result<Ref<ShardState>> res) {
         LOG(DEBUG) << "got answer to wait_block_state() query for masterchain block";
         if (res.is_ok() && mc_handle->id().seqno() > 0 && !mc_handle->inited_proof()) {
@@ -1764,7 +1764,7 @@ bool ValidateQuery::request_aux_mc_state(BlockSeqno seqno, Ref<MasterchainStateQ
   CHECK(blkid.is_valid_ext() && blkid.is_masterchain());
   LOG(DEBUG) << "sending auxiliary wait_block_state() query for " << blkid.to_str() << " to Manager";
   ++pending;
-  td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, blkid, priority(), timeout,
+  td::actor::send_closure_later(manager, &ValidatorManager::wait_block_state_short, blkid, priority(), timeout, false,
                                 [self = get_self(), blkid](td::Result<Ref<ShardState>> res) {
                                   LOG(DEBUG) << "got answer to wait_block_state query for " << blkid.to_str();
                                   td::actor::send_closure_later(std::move(self),

validator/manager-disk.cpp

@@ -321,14 +321,15 @@ void ValidatorManagerImpl::dec_pending_new_blocks() {
 }
 
 void ValidatorManagerImpl::wait_block_state(BlockHandle handle, td::uint32 priority, td::Timestamp timeout,
-                                            td::Promise<td::Ref<ShardState>> promise) {
+                                            bool wait_store, td::Promise<td::Ref<ShardState>> promise) {
   auto it = wait_state_.find(handle->id());
   if (it == wait_state_.end()) {
     auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), handle](td::Result<td::Ref<ShardState>> R) {
       td::actor::send_closure(SelfId, &ValidatorManagerImpl::finished_wait_state, handle->id(), std::move(R));
     });
     auto id = td::actor::create_actor<WaitBlockState>("waitstate", handle, 0, opts_, last_masterchain_state_,
-                                                      actor_id(this), td::Timestamp::in(10.0), std::move(P))
+                                                      actor_id(this), td::Timestamp::in(10.0),
+                                                      td::Promise<td::Ref<ShardState>>{}, std::move(P))
                   .release();
     wait_state_[handle->id()].actor_ = id;
     it = wait_state_.find(handle->id());
@@ -340,14 +341,14 @@ void ValidatorManagerImpl::wait_block_state(BlockHandle handle, td::uint32 prior
 }
 
 void ValidatorManagerImpl::wait_block_state_short(BlockIdExt block_id, td::uint32 priority, td::Timestamp timeout,
-                                                  td::Promise<td::Ref<ShardState>> promise) {
+                                                  bool wait_store, td::Promise<td::Ref<ShardState>> promise) {
   auto P = td::PromiseCreator::lambda(
-      [SelfId = actor_id(this), timeout, promise = std::move(promise)](td::Result<BlockHandle> R) mutable {
+      [=, SelfId = actor_id(this), promise = std::move(promise)](td::Result<BlockHandle> R) mutable {
         if (R.is_error()) {
           promise.set_error(R.move_as_error());
           return;
         }
-        td::actor::send_closure(SelfId, &ValidatorManagerImpl::wait_block_state, R.move_as_ok(), 0, timeout,
+        td::actor::send_closure(SelfId, &ValidatorManagerImpl::wait_block_state, R.move_as_ok(), 0, timeout, wait_store,
                                 std::move(promise));
       });
   get_block_handle(block_id, true, std::move(P));
@@ -401,7 +402,7 @@ void ValidatorManagerImpl::wait_prev_block_state(BlockHandle handle, td::uint32
     auto shard = handle->id().shard_full();
     auto prev_shard = handle->one_prev(true).shard_full();
     if (shard == prev_shard) {
-      wait_block_state_short(handle->one_prev(true), 0, timeout, std::move(promise));
+      wait_block_state_short(handle->one_prev(true), 0, timeout, true, std::move(promise));
     } else {
       CHECK(shard_parent(shard) == prev_shard);
       bool left = shard_child(prev_shard, true) == shard;
@@ -420,7 +421,7 @@ void ValidatorManagerImpl::wait_prev_block_state(BlockHandle handle, td::uint32
               }
             }
           });
-      wait_block_state_short(handle->one_prev(true), 0, timeout, std::move(P));
+      wait_block_state_short(handle->one_prev(true), 0, timeout, true, std::move(P));
     }
   } else {
     wait_block_state_merge(handle->one_prev(true), handle->one_prev(false), 0, timeout, std::move(promise));
@@ -495,7 +496,7 @@ void ValidatorManagerImpl::wait_block_message_queue(BlockHandle handle, td::uint
     }
   });
 
-  wait_block_state(handle, 0, timeout, std::move(P));
+  wait_block_state(handle, 0, timeout, true, std::move(P));
 }
 
 void ValidatorManagerImpl::wait_block_message_queue_short(BlockIdExt block_id, td::uint32 priority,