Optimistic block generation

Author: SpyCheese

tdutils/td/utils/Timer.h

@@ -160,6 +160,9 @@ class PerfLog {
 };
 template <class T>
 double PerfLogAction::finish(const T &result) {
+  if (!perf_log_) {
+    return 0.0;
+  }
   if (result.is_ok()) {
     return perf_log_->finish_action(i_, td::Status::OK());
   } else {

tl/generate/scheme/ton_api.tl

@@ -344,6 +344,7 @@ validatorSession.blockUpdate ts:long actions:(vector validatorSession.round.Mess
 validatorSession.candidate src:int256 round:int root_hash:int256 data:bytes collated_data:bytes = validatorSession.Candidate;
 validatorSession.compressedCandidate flags:# src:int256 round:int root_hash:int256 decompressed_size:int data:bytes = validatorSession.Candidate;
 validatorSession.compressedCandidateV2 flags:# src:int256 round:int root_hash:int256 data:bytes = validatorSession.Candidate;
+validatorSession.optimisticCandidateBroadcast flags:# prev_candidate_id:int256 data:bytes = validatorSession.OptimisticCandidateBroadcast;
 
 validatorSession.config catchain_idle_timeout:double catchain_max_deps:int round_candidates:int next_candidate_delay:double round_attempt_duration:int
         max_round_attempts:int max_block_size:int max_collated_data_size:int = validatorSession.Config;
@@ -962,7 +963,7 @@ validatorStats.blockStats
     old_out_msg_queue_size:long new_out_msg_queue_size:long msg_queue_cleaned:int
     neighbors:(vector validatorStats.blockStats.neighborStats) = validatorStats.BlockStats;
 validatorStats.collateWorkTimeStats
-    total:double queue_cleanup:double prelim_storage_stat:double trx_tvm:double trx_storage_stat:double
+    total:double optimistic_apply:double queue_cleanup:double prelim_storage_stat:double trx_tvm:double trx_storage_stat:double
     trx_other:double final_storage_stat:double create_block:double create_collated_data:double create_block_candidate:double
     = validatorStats.CollateWorkTimeStats;
 validatorStats.storageStatCacheStats

tl/generate/scheme/ton_api.tlo

@@ -93,6 +93,9 @@ class ValidatorSession : public td::actor::Actor {
                                         ValidatorSessionFileHash file_hash,
                                         ValidatorSessionCollatedDataFileHash collated_data_file_hash,
                                         td::Promise<BlockCandidate> promise) = 0;
+    virtual void generate_block_optimistic(BlockSourceInfo source_info, td::BufferSlice prev_block, RootHash prev_root_hash,
+                                    FileHash prev_file_hash, td::Promise<GeneratedCandidate> promise) {
+    }
     virtual ~Callback() = default;
   };
 

validator-session/validator-session.cpp

@@ -161,13 +161,38 @@ class ValidatorSessionImpl : public ValidatorSession {
   bool catchain_started_ = false;
   bool allow_unsafe_self_blocks_resync_;
   bool compress_block_candidates_ = false;
+  bool allow_optimistic_generation_ = false;
 
   ValidatorSessionStats cur_stats_;
   bool stats_inited_ = false;
   std::map<std::pair<td::uint32, ValidatorSessionCandidateId>, std::vector<td::uint32>>
       stats_pending_approve_;  // round, candidate_id -> approvers
   std::map<std::pair<td::uint32, ValidatorSessionCandidateId>, std::vector<td::uint32>>
       stats_pending_sign_;  // round, candidate_id -> signers
+
+  struct SentCandidateStats {
+    bool sent = false;
+    double sent_at = -1.0;
+    double serialize_time = -1.0;
+    size_t serialized_size = 0;
+  };
+  std::map<ValidatorSessionCandidateId, SentCandidateStats> sent_candidates_;
+
+  struct BroadcastInfo {
+    ValidatorSessionCandidateId candidate_id;
+    double received_at = -1.0;
+    double deserialize_time = -1.0;
+    size_t serialized_size = 0;
+    ValidatorSessionFileHash file_hash;
+    ValidatorSessionCollatedDataFileHash collated_data_hash;
+  };
+  struct OptimisticBroadcast {
+    tl_object_ptr<ton_api::validatorSession_candidate> candidate;
+    ValidatorSessionCandidateId prev_candidate_id;
+    BroadcastInfo broadcast_info;
+  };
+  std::map<std::pair<td::uint32, td::uint32>, OptimisticBroadcast> optimistic_broadcasts_;  // round, src -> broadcast
+
   void stats_init();
   void stats_add_round();
   ValidatorSessionStats::Producer *stats_get_candidate_stat(
@@ -176,6 +201,10 @@ class ValidatorSessionImpl : public ValidatorSession {
   ValidatorSessionStats::Producer *stats_get_candidate_stat_by_id(td::uint32 round,
                                                                   ValidatorSessionCandidateId candidate_id);
   void stats_process_action(td::uint32 node_id, ton_api::validatorSession_round_Message &action);
+  void process_approve(td::uint32 node_id, td::uint32 round, ValidatorSessionCandidateId candidate_id);
+
+  void generated_optimistic_candidate(td::uint32 round, GeneratedCandidate candidate,
+                                      ValidatorSessionCandidateId prev_candidate);
 
  public:
   ValidatorSessionImpl(catchain::CatChainSessionId session_id, ValidatorSessionOptions opts, PublicKeyHash local_id,
@@ -205,6 +234,9 @@ class ValidatorSessionImpl : public ValidatorSession {
   bool ensure_candidate_unique(td::uint32 src_idx, td::uint32 round, ValidatorSessionCandidateId block_id);
   void process_broadcast(PublicKeyHash src, td::BufferSlice data, td::optional<ValidatorSessionCandidateId> expected_id,
                          bool is_overlay_broadcast, bool is_startup);
+  void process_received_block(td::uint32 block_round, PublicKeyHash src, td::uint32 src_idx,
+                              tl_object_ptr<ton_api::validatorSession_candidate> candidate, const BroadcastInfo &info,
+                              bool is_overlay_broadcast, bool is_startup);
   void process_message(PublicKeyHash src, td::BufferSlice data);
   void process_query(PublicKeyHash src, td::BufferSlice data, td::Promise<td::BufferSlice> promise);
 
@@ -218,6 +250,9 @@ class ValidatorSessionImpl : public ValidatorSession {
                                  td::BufferSlice signature);
 
   void generated_block(td::uint32 round, GeneratedCandidate c, double collation_time);
+  SentCandidateStats &send_candidate_broadcast(
+      td::uint32 round, const BlockCandidate &candidate,
+      td::optional<ValidatorSessionCandidateId> optimistic_prev_candidate = {});
   void signed_block(td::uint32 round, ValidatorSessionCandidateId hash, td::BufferSlice signature);
 
   void end_request(td::uint32 round, ValidatorSessionCandidateId block_id) {

validator-session/validator-session.h

@@ -38,18 +38,43 @@ void CollationManager::collate_block(ShardIdFull shard, BlockIdExt min_mastercha
                                      td::Promise<GeneratedCandidate> promise, int proto_version) {
   if (shard.is_masterchain()) {
     run_collate_query(
-        shard, min_masterchain_block_id, std::move(prev), creator, std::move(validator_set),
-        opts_->get_collator_options(), manager_, td::Timestamp::in(10.0), promise.wrap([](BlockCandidate&& candidate) {
+        CollateParams{.shard = shard,
+                      .min_masterchain_block_id = min_masterchain_block_id,
+                      .prev = std::move(prev),
+                      .creator = creator,
+                      .validator_set = std::move(validator_set),
+                      .collator_opts = opts_->get_collator_options()},
+        manager_, td::Timestamp::in(10.0), std::move(cancellation_token), promise.wrap([](BlockCandidate&& candidate) {
           return GeneratedCandidate{.candidate = std::move(candidate), .is_cached = false, .self_collated = true};
-        }),
-        adnl::AdnlNodeIdShort::zero(), std::move(cancellation_token), 0);
+        }));
     return;
   }
   collate_shard_block(shard, min_masterchain_block_id, std::move(prev), creator, priority, std::move(validator_set),
                       max_answer_size, std::move(cancellation_token), std::move(promise), td::Timestamp::in(10.0),
                       proto_version);
 }
 
+void CollationManager::collate_next_block(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
+                                          BlockIdExt prev_block_id, td::BufferSlice prev_block,
+                                          Ed25519_PublicKey creator, BlockCandidatePriority priority,
+                                          td::Ref<ValidatorSet> validator_set, td::uint64 max_answer_size,
+                                          td::CancellationToken cancellation_token,
+                                          td::Promise<GeneratedCandidate> promise, int proto_version) {
+  TRY_RESULT_PROMISE(promise, prev_block_data, create_block(prev_block_id, std::move(prev_block)));
+  run_collate_query(
+      CollateParams{.shard = shard,
+                    .min_masterchain_block_id = min_masterchain_block_id,
+                    .prev = {prev_block_id},
+                    .creator = creator,
+                    .validator_set = std::move(validator_set),
+                    .collator_opts = opts_->get_collator_options(),
+                    .optimistic_prev_block_ = std::move(prev_block_data)},
+      manager_, td::Timestamp::in(10.0), std::move(cancellation_token), promise.wrap([](BlockCandidate&& candidate) {
+        return GeneratedCandidate{.candidate = std::move(candidate), .is_cached = false, .self_collated = true};
+      }));
+  // TODO: request to collator node
+}
+
 void CollationManager::collate_shard_block(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
                                            std::vector<BlockIdExt> prev, Ed25519_PublicKey creator,
                                            BlockCandidatePriority priority, td::Ref<ValidatorSet> validator_set,
@@ -109,11 +134,15 @@ void CollationManager::collate_shard_block(ShardIdFull shard, BlockIdExt min_mas
 
   if (selected_collator.is_zero() && s->self_collate) {
     run_collate_query(
-        shard, min_masterchain_block_id, std::move(prev), creator, std::move(validator_set),
-        opts_->get_collator_options(), manager_, td::Timestamp::in(10.0), promise.wrap([](BlockCandidate&& candidate) {
+        CollateParams{.shard = shard,
+                      .min_masterchain_block_id = min_masterchain_block_id,
+                      .prev = std::move(prev),
+                      .creator = creator,
+                      .validator_set = std::move(validator_set),
+                      .collator_opts = opts_->get_collator_options()},
+        manager_, td::Timestamp::in(10.0), std::move(cancellation_token), promise.wrap([](BlockCandidate&& candidate) {
           return GeneratedCandidate{.candidate = std::move(candidate), .is_cached = false, .self_collated = true};
-        }),
-        adnl::AdnlNodeIdShort::zero(), std::move(cancellation_token), 0);
+        }));
     return;
   }
 

validator-session/validator-session.hpp

@@ -39,6 +39,12 @@ class CollationManager : public td::actor::Actor {
                      td::uint64 max_answer_size, td::CancellationToken cancellation_token,
                      td::Promise<GeneratedCandidate> promise, int proto_version);
 
+  void collate_next_block(ShardIdFull shard, BlockIdExt min_masterchain_block_id, BlockIdExt prev_block_id,
+                          td::BufferSlice prev_block, Ed25519_PublicKey creator, BlockCandidatePriority priority,
+                          td::Ref<ValidatorSet> validator_set, td::uint64 max_answer_size,
+                          td::CancellationToken cancellation_token, td::Promise<GeneratedCandidate> promise,
+                          int proto_version);
+
   void update_options(td::Ref<ValidatorManagerOptions> opts);
 
   void validator_group_started(ShardIdFull shard);

validator/collation-manager.cpp

@@ -539,18 +539,21 @@ void CollatorNode::generate_block(ShardIdFull shard, CatchainSeqno cc_seqno, std
   };
   cache_entry->started = true;
   cache_entry->block_seqno = block_seqno;
-  run_collate_query(
-      shard, last_masterchain_state_->get_block_id(), std::move(prev_blocks), Ed25519_PublicKey{td::Bits256::zero()},
-      last_masterchain_state_->get_validator_set(shard), opts_->get_collator_options(), manager_, timeout,
-      [=, SelfId = actor_id(this), timer = td::Timer{}](td::Result<BlockCandidate> R) {
-        FLOG(INFO) {
-          prefix_inner(sb, shard, cc_seqno, block_seqno, o_priority);
-          sb << timer.elapsed() << ": " << (R.is_ok() ? "OK" : R.error().to_string());
-        };
-        td::actor::send_closure(SelfId, &CollatorNode::process_result, cache_entry, std::move(R));
-      },
-      local_id_, cache_entry->cancellation_token_source.get_cancellation_token(),
-      CollateMode::skip_store_candidate | CollateMode::from_collator_node);
+  run_collate_query(CollateParams{.shard = shard,
+                                  .min_masterchain_block_id = last_masterchain_state_->get_block_id(),
+                                  .prev = std::move(prev_blocks),
+                                  .validator_set = last_masterchain_state_->get_validator_set(shard),
+                                  .collator_opts = opts_->get_collator_options(),
+                                  .collator_node_id = local_id_,
+                                  .skip_store_candidate = true},
+                    manager_, timeout, cache_entry->cancellation_token_source.get_cancellation_token(),
+                    [=, SelfId = actor_id(this), timer = td::Timer{}](td::Result<BlockCandidate> R) {
+                      FLOG(INFO) {
+                        prefix_inner(sb, shard, cc_seqno, block_seqno, o_priority);
+                        sb << timer.elapsed() << ": " << (R.is_ok() ? "OK" : R.error().to_string());
+                      };
+                      td::actor::send_closure(SelfId, &CollatorNode::process_result, cache_entry, std::move(R));
+                    });
 }
 
 void CollatorNode::process_result(std::shared_ptr<CacheEntry> cache_entry, td::Result<BlockCandidate> R) {

validator/collation-manager.hpp

@@ -26,8 +26,23 @@ namespace ton {
 
 namespace validator {
 
+struct CollateParams {
+  ShardIdFull shard;
+  BlockIdExt min_masterchain_block_id;
+  std::vector<BlockIdExt> prev;
+  bool is_hardfork = false;
+  Ed25519_PublicKey creator{td::Bits256::zero()};
+  td::Ref<ValidatorSet> validator_set = {};
+  td::Ref<CollatorOptions> collator_opts = {};
+  adnl::AdnlNodeIdShort collator_node_id = adnl::AdnlNodeIdShort::zero();
+  bool skip_store_candidate = false;
+  int attempt_idx = 0;
+
+  // Optional - used for optimistic collation
+  Ref<BlockData> optimistic_prev_block_ = {};
+};
+
 enum ValidateMode { fake = 1 };
-enum CollateMode { skip_store_candidate = 1, from_collator_node = 2 };
 
 td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_,
                                         td::Ref<ValidatorManagerOptions> opts);
@@ -85,15 +100,8 @@ void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
                         BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
                         td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
                         td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
-void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                       Ed25519_PublicKey creator, td::Ref<ValidatorSet> validator_set,
-                       td::Ref<CollatorOptions> collator_opts, td::actor::ActorId<ValidatorManager> manager,
-                       td::Timestamp timeout, td::Promise<BlockCandidate> promise,
-                       adnl::AdnlNodeIdShort collator_node_id, td::CancellationToken cancellation_token, unsigned mode,
-                       int attempt_idx = 0);
-void run_collate_hardfork(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,
-                          td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
-                          td::Promise<BlockCandidate> promise);
+void run_collate_query(CollateParams params, td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
+                       td::CancellationToken cancellation_token, td::Promise<BlockCandidate> promise);
 void run_liteserver_query(td::BufferSlice data, td::actor::ActorId<ValidatorManager> manager,
                           td::actor::ActorId<LiteServerCache> cache, td::Promise<td::BufferSlice> promise);
 void run_fetch_account_state(WorkchainId wc, StdSmcAddress  addr, td::actor::ActorId<ValidatorManager> manager,