Merge pull request #1767 from ton-blockchain/optimize-collate

Optimistic collation and other optimizations

Author: EmelyanenkoK

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

@@ -64,7 +64,8 @@ set(VALIDATOR_HEADERS
   shard-block-retainer.hpp
 
   collation-manager.hpp
-  collator-node.hpp
+  collator-node/collator-node.hpp
+  collator-node/collator-node-session.hpp
   manager-disk.h
   manager-disk.hpp
   manager-init.h
@@ -81,7 +82,8 @@ set(VALIDATOR_SOURCE
   apply-block.cpp
   block-handle.cpp
   collation-manager.cpp
-  collator-node.cpp
+  collator-node/collator-node.cpp
+  collator-node/collator-node-session.cpp
   get-next-key-blocks.cpp
   import-db-slice.cpp
   import-db-slice-local.cpp

validator-session/validator-session.hpp

@@ -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/CMakeLists.txt

@@ -16,7 +16,7 @@
 */
 #include "collation-manager.hpp"
 
-#include "collator-node.hpp"
+#include "collator-node/collator-node.hpp"
 #include "fabric.h"
 #include "td/utils/Random.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/apply-block.cpp

@@ -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);