external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

Merge branch 'session-stats-patch' into accelerator

Browse source
This commit is contained in:
SpyCheese 2024-08-20 12:41:55 +03:00
commit 5080cdffdd
23 changed files with 385 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

5
validator/impl/collator-impl.h
View file

@ -372,6 +372,11 @@ class Collator final : public td::actor::Actor {
public:
static td::uint32 get_skip_externals_queue_size();
private:
td::Timer work_timer_{true};
td::ThreadCpuTimer cpu_work_timer_{true};
CollationStats stats_;
};
} // namespace validator

63
validator/impl/collator.cpp
View file

@ -1855,6 +1855,12 @@ bool Collator::register_shard_block_creators(std::vector<td::Bits256> creator_li
* @returns True if collation is successful, false otherwise.
*/
bool Collator::try_collate() {
work_timer_.resume();
cpu_work_timer_.resume();
SCOPE_EXIT {
work_timer_.pause();
cpu_work_timer_.pause();
};
if (!preinit_complete) {
LOG(WARNING) << "running do_preinit()";
if (!do_preinit()) {
@ -3611,6 +3617,29 @@ bool Collator::process_inbound_message(Ref<vm::CellSlice> enq_msg, ton::LogicalT
return true;
}
/**
* Creates a string that explains which limit is exceeded. Used for collator stats.
*
* @param block_limit_status Status of block limits.
* @param cls Which limit class is exceeded.
*
* @returns String for collator stats.
*/
static std::string block_full_comment(const block::BlockLimitStatus& block_limit_status, unsigned cls) {
auto bytes = block_limit_status.estimate_block_size();
if (!block_limit_status.limits.bytes.fits(cls, bytes)) {
return PSTRING() << "block_full bytes " << bytes;
}
if (!block_limit_status.limits.gas.fits(cls, block_limit_status.gas_used)) {
return PSTRING() << "block_full gas " << block_limit_status.gas_used;
}
auto lt_delta = block_limit_status.cur_lt - block_limit_status.limits.start_lt;
if (!block_limit_status.limits.lt_delta.fits(cls, lt_delta)) {
return PSTRING() << "block_full lt_delta " << lt_delta;
}
return "";
}
/**
* Processes inbound internal messages from message queues of the neighbors.
* Messages are processed until the normal limit is reached, soft timeout is reached or there are no more messages.
@ -3642,11 +3671,14 @@ bool Collator::process_inbound_internal_messages() {
}
if (block_full_) {
LOG(INFO) << "BLOCK FULL, stop processing inbound internal messages";
stats_.limits_log += PSTRING() << "INBOUND_INT_MESSAGES: "
<< block_full_comment(*block_limit_status_, block::ParamLimits::cl_normal) << "\n";
break;
}
if (soft_timeout_.is_in_past(td::Timestamp::now())) {
block_full_ = true;
LOG(WARNING) << "soft timeout reached, stop processing inbound internal messages";
stats_.limits_log += PSTRING() << "INBOUND_INT_MESSAGES: timeout\n";
break;
}
if (!check_cancelled()) {
@ -3695,10 +3727,13 @@ bool Collator::process_inbound_external_messages() {
}
if (full) {
LOG(INFO) << "BLOCK FULL, stop processing external messages";
stats_.limits_log += PSTRING() << "INBOUND_EXT_MESSAGES: "
<< block_full_comment(*block_limit_status_, block::ParamLimits::cl_soft) << "\n";
break;
}
if (medium_timeout_.is_in_past(td::Timestamp::now())) {
LOG(WARNING) << "medium timeout reached, stop processing inbound external messages";
stats_.limits_log += PSTRING() << "INBOUND_EXT_MESSAGES: timeout\n";
break;
}
if (!check_cancelled()) {
@ -3707,6 +3742,11 @@ bool Collator::process_inbound_external_messages() {
auto ext_msg = ext_msg_struct.cell;
ton::Bits256 hash{ext_msg->get_hash().bits()};
int r = process_external_message(std::move(ext_msg));
if (r > 0) {
++stats_.ext_msgs_accepted;
} else {
++stats_.ext_msgs_rejected;
}
if (r < 0) {
bad_ext_msgs_.emplace_back(ext_msg_struct.hash);
return false;
@ -3812,11 +3852,15 @@ bool Collator::process_dispatch_queue() {
block_full_ = !block_limit_status_->fits(block::ParamLimits::cl_normal);
if (block_full_) {
LOG(INFO) << "BLOCK FULL, stop processing dispatch queue";
stats_.limits_log += PSTRING() << "DISPATCH_QUEUE_STAGE_" << iter << ": "
<< block_full_comment(*block_limit_status_, block::ParamLimits::cl_normal)
<< "\n";
return true;
}
if (soft_timeout_.is_in_past(td::Timestamp::now())) {
block_full_ = true;
LOG(WARNING) << "soft timeout reached, stop processing dispatch queue";
stats_.limits_log += PSTRING() << "DISPATCH_QUEUE_STAGE_" << iter << ": timeout\n";
return true;
}
StdSmcAddress src_addr;
@ -3866,6 +3910,7 @@ bool Collator::process_dispatch_queue() {
++total_count;
if (total_count >= max_total_count[iter]) {
dispatch_queue_total_limit_reached_ = true;
stats_.limits_log += PSTRING() << "DISPATCH_QUEUE_STAGE_" << iter << ": total limit reached\n";
break;
}
}
@ -4215,6 +4260,8 @@ bool Collator::process_new_messages(bool enqueue_only) {
if ((block_full_ || have_unprocessed_account_dispatch_queue_) && !enqueue_only) {
LOG(INFO) << "BLOCK FULL, enqueue all remaining new messages";
enqueue_only = true;
stats_.limits_log += PSTRING() << "NEW_MESSAGES: "
<< block_full_comment(*block_limit_status_, block::ParamLimits::cl_normal) << "\n";
}
if (!check_cancelled()) {
return false;
@ -4226,6 +4273,8 @@ bool Collator::process_new_messages(bool enqueue_only) {
} else if (res == 3) {
LOG(INFO) << "All remaining new messages must be enqueued (BLOCK FULL)";
enqueue_only = true;
stats_.limits_log += PSTRING() << "NEW_MESSAGES: "
<< block_full_comment(*block_limit_status_, block::ParamLimits::cl_normal) << "\n";
}
}
return true;
@ -5665,6 +5714,18 @@ bool Collator::create_block_candidate() {
td::actor::send_closure_later(manager, &ValidatorManager::complete_external_messages, std::move(delay_ext_msgs_),
std::move(bad_ext_msgs_));
}
double work_time = work_timer_.elapsed();
double cpu_work_time = cpu_work_timer_.elapsed();
LOG(WARNING) << "Collate query work time = " << work_time << "s, cpu time = " << cpu_work_time << "s";
stats_.bytes = block_limit_status_->estimate_block_size();
stats_.gas = block_limit_status_->gas_used;
stats_.lt_delta = block_limit_status_->cur_lt - block_limit_status_->limits.start_lt;
stats_.cat_bytes = block_limit_status_->limits.classify_size(stats_.bytes);
stats_.cat_gas = block_limit_status_->limits.classify_gas(stats_.gas);
stats_.cat_lt_delta = block_limit_status_->limits.classify_lt(block_limit_status_->cur_lt);
td::actor::send_closure(manager, &ValidatorManager::record_collate_query_stats, block_candidate->id, work_time,
cpu_work_time, std::move(stats_));
return true;
}
@ -5770,6 +5831,7 @@ void Collator::after_get_external_messages(td::Result<std::vector<std::pair<Ref<
}
auto vect = res.move_as_ok();
for (auto& p : vect) {
++stats_.ext_msgs_total;
auto& ext_msg = p.first;
int priority = p.second;
Ref<vm::Cell> ext_msg_cell = ext_msg->root_cell();
@ -5781,6 +5843,7 @@ void Collator::after_get_external_messages(td::Result<std::vector<std::pair<Ref<
}
}
if (err) {
++stats_.ext_msgs_filtered;
bad_ext_msgs_.emplace_back(ext_msg->hash());
}
}

21
validator/impl/validate-query.cpp
View file

@ -117,6 +117,7 @@ bool ValidateQuery::reject_query(std::string error, td::BufferSlice reason) {
error = error_ctx() + error;
LOG(ERROR) << "REJECT: aborting validation of block candidate for " << shard_.to_str() << " : " << error;
if (main_promise) {
record_stats();
errorlog::ErrorLog::log(PSTRING() << "REJECT: aborting validation of block candidate for " << shard_.to_str()
<< " : " << error << ": data=" << block_candidate.id.file_hash.to_hex()
<< " collated_data=" << block_candidate.collated_file_hash.to_hex());
@ -155,6 +156,7 @@ bool ValidateQuery::soft_reject_query(std::string error, td::BufferSlice reason)
error = error_ctx() + error;
LOG(ERROR) << "SOFT REJECT: aborting validation of block candidate for " << shard_.to_str() << " : " << error;
if (main_promise) {
record_stats();
errorlog::ErrorLog::log(PSTRING() << "SOFT REJECT: aborting validation of block candidate for " << shard_.to_str()
<< " : " << error << ": data=" << block_candidate.id.file_hash.to_hex()
<< " collated_data=" << block_candidate.collated_file_hash.to_hex());
@ -178,6 +180,7 @@ bool ValidateQuery::fatal_error(td::Status error) {
error.ensure_error();
LOG(ERROR) << "aborting validation of block candidate for " << shard_.to_str() << " : " << error.to_string();
if (main_promise) {
record_stats();
auto c = error.code();
if (c <= -667 && c >= -670) {
errorlog::ErrorLog::log(PSTRING() << "FATAL ERROR: aborting validation of block candidate for " << shard_.to_str()
@ -236,6 +239,7 @@ bool ValidateQuery::fatal_error(std::string err_msg, int err_code) {
*/
void ValidateQuery::finish_query() {
if (main_promise) {
record_stats();
LOG(WARNING) << "validate query done";
LOG(WARNING) << "validation took " << perf_timer_.elapsed() << " s";
main_promise.set_result(now_);
@ -6901,6 +6905,12 @@ bool ValidateQuery::try_validate() {
if (pending) {
return true;
}
work_timer_.resume();
cpu_work_timer_.resume();
SCOPE_EXIT {
work_timer_.pause();
cpu_work_timer_.pause();
};
try {
if (!stage_) {
LOG(WARNING) << "try_validate stage 0";
@ -7040,6 +7050,17 @@ void ValidateQuery::written_candidate() {
finish_query();
}
/**
* Sends validation work time to manager.
*/
void ValidateQuery::record_stats() {
double work_time = work_timer_.elapsed();
double cpu_work_time = cpu_work_timer_.elapsed();
LOG(WARNING) << "Validate query work time = " << work_time << "s, cpu time = " << cpu_work_time << "s";
td::actor::send_closure(manager, &ValidatorManager::record_validate_query_stats, block_candidate.id, work_time,
cpu_work_time);
}
} // namespace validator
} // namespace ton

4
validator/impl/validate-query.hpp
View file

@ -404,6 +404,10 @@ class ValidateQuery : public td::actor::Actor {
}
return true;
}
td::Timer work_timer_{true};
td::ThreadCpuTimer cpu_work_timer_{true};
void record_stats();
};
} // namespace validator

17
validator/interfaces/validator-manager.h
View file

@ -53,6 +53,16 @@ struct AsyncSerializerState {
UnixTime last_written_block_ts;
};
struct CollationStats {
td::uint32 bytes, gas, lt_delta;
int cat_bytes, cat_gas, cat_lt_delta;
std::string limits_log;
td::uint32 ext_msgs_total = 0;
td::uint32 ext_msgs_filtered = 0;
td::uint32 ext_msgs_accepted = 0;
td::uint32 ext_msgs_rejected = 0;
};
using ValidateCandidateResult = td::Variant<UnixTime, CandidateReject>;
class ValidatorManager : public ValidatorManagerInterface {
@ -176,6 +186,7 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) = 0;
virtual void log_new_validator_group_stats(validatorsession::NewValidatorGroupStats stats) = 0;
virtual void log_end_validator_group_stats(validatorsession::EndValidatorGroupStats stats) = 0;
virtual void get_block_handle_for_litequery(BlockIdExt block_id, td::Promise<ConstBlockHandle> promise) = 0;
virtual void get_block_data_for_litequery(BlockIdExt block_id, td::Promise<td::Ref<BlockData>> promise) = 0;
@ -195,6 +206,12 @@ class ValidatorManager : public ValidatorManagerInterface {
virtual void add_lite_query_stats(int lite_query_id) {
}
virtual void record_collate_query_stats(BlockIdExt block_id, double work_time, double cpu_work_time,
CollationStats stats) {
}
virtual void record_validate_query_stats(BlockIdExt block_id, double work_time, double cpu_work_time) {
}
virtual void add_persistent_state_description(td::Ref<PersistentStateDescription> desc) = 0;
static bool is_persistent_state(UnixTime ts, UnixTime prev_ts) {

3
validator/manager-disk.hpp
View file

@ -401,6 +401,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void log_new_validator_group_stats(validatorsession::NewValidatorGroupStats stats) override {
UNREACHABLE();
}
void log_end_validator_group_stats(validatorsession::EndValidatorGroupStats stats) override {
UNREACHABLE();
}
void get_out_msg_queue_size(BlockIdExt block_id, td::Promise<td::uint64> promise) override {
if (queue_size_counter_.empty()) {
queue_size_counter_ = td::actor::create_actor<QueueSizeCounter>("queuesizecounter", td::Ref<MasterchainState>{},

3
validator/manager-hardfork.hpp
View file

@ -464,6 +464,9 @@ class ValidatorManagerImpl : public ValidatorManager {
void log_new_validator_group_stats(validatorsession::NewValidatorGroupStats stats) override {
UNREACHABLE();
}
void log_end_validator_group_stats(validatorsession::EndValidatorGroupStats stats) override {
UNREACHABLE();
}
void get_out_msg_queue_size(BlockIdExt block_id, td::Promise<td::uint64> promise) override {
if (queue_size_counter_.empty()) {
queue_size_counter_ = td::actor::create_actor<QueueSizeCounter>("queuesizecounter", td::Ref<MasterchainState>{},

100
validator/manager.cpp
View file

@ -42,6 +42,7 @@
#include "td/utils/JsonBuilder.h"
#include "common/delay.h"
#include "td/utils/filesystem.h"
#include "validator/stats-merger.h"
@ -2248,7 +2249,7 @@ void ValidatorManagerImpl::update_shards() {
}
new_validator_groups_.emplace(val_group_id, std::move(it2->second));
} else {
auto G = create_validator_group(val_group_id, shard, val_set, opts, started_);
auto G = create_validator_group(val_group_id, shard, val_set, key_seqno, opts, started_);
if (!G.empty()) {
td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_);
}
@ -2302,7 +2303,7 @@ void ValidatorManagerImpl::update_shards() {
}
new_validator_groups_.emplace(val_group_id, std::move(it2->second));
} else {
auto G = create_validator_group(val_group_id, shard, val_set, opts, started_);
auto G = create_validator_group(val_group_id, shard, val_set, key_seqno, opts, started_);
if (!G.empty()) {
td::actor::send_closure(G, &ValidatorGroup::start, prev, last_masterchain_block_id_);
}
@ -2328,7 +2329,7 @@ void ValidatorManagerImpl::update_shards() {
} else {
new_next_validator_groups_.emplace(
val_group_id,
ValidatorGroupEntry{create_validator_group(val_group_id, shard, val_set, opts, started_), shard});
ValidatorGroupEntry{create_validator_group(val_group_id, shard, val_set, key_seqno, opts, started_), shard});
}
}
}
@ -2438,7 +2439,7 @@ ValidatorSessionId ValidatorManagerImpl::get_validator_set_id(ShardIdFull shard,
}
td::actor::ActorOwn<ValidatorGroup> ValidatorManagerImpl::create_validator_group(
ValidatorSessionId session_id, ShardIdFull shard, td::Ref<ValidatorSet> validator_set,
ValidatorSessionId session_id, ShardIdFull shard, td::Ref<ValidatorSet> validator_set, BlockSeqno key_seqno,
validatorsession::ValidatorSessionOptions opts, bool init_session) {
if (check_gc_list_.count(session_id) == 1) {
return td::actor::ActorOwn<ValidatorGroup>{};
@ -2449,7 +2450,7 @@ td::actor::ActorOwn<ValidatorGroup> ValidatorManagerImpl::create_validator_group
auto validator_id = get_validator(shard, validator_set);
CHECK(!validator_id.is_zero());
auto G = td::actor::create_actor<ValidatorGroup>(
PSTRING() << "valgroup" << shard.to_str(), shard, validator_id, session_id, validator_set,
PSTRING() << "valgroup" << shard.to_str(), shard, validator_id, session_id, validator_set, key_seqno,
last_masterchain_state_->get_collator_config(true), opts, keyring_, adnl_, rldp_, overlays_, db_root_,
actor_id(this), init_session, opts_->check_unsafe_resync_allowed(validator_set->get_catchain_seqno()), opts_,
opts_->need_monitor(shard, last_masterchain_state_));
@ -3055,13 +3056,35 @@ void ValidatorManagerImpl::log_validator_session_stats(BlockIdExt block_id,
for (const auto &round : stats.rounds) {
std::vector<tl_object_ptr<ton_api::validatorSession_statsProducer>> producers;
for (const auto &producer : round.producers) {
BlockIdExt cur_block_id{block_id.id, producer.root_hash, producer.file_hash};
auto it = recorded_block_stats_.find(cur_block_id);
tl_object_ptr<ton_api::validatorSession_collationStats> collation_stats;
if (it != recorded_block_stats_.end() && it->second.collator_stats_) {
auto &stats = it->second.collator_stats_.value();
collation_stats = create_tl_object<ton_api::validatorSession_collationStats>(
stats.bytes, stats.gas, stats.lt_delta, stats.cat_bytes, stats.cat_gas, stats.cat_lt_delta,
stats.limits_log, stats.ext_msgs_total, stats.ext_msgs_filtered, stats.ext_msgs_accepted,
stats.ext_msgs_rejected);
}
std::string approvers, signers;
for (bool x : producer.approvers) {
approvers += (x ? '1' : '0');
}
for (bool x : producer.signers) {
signers += (x ? '1' : '0');
}
producers.push_back(create_tl_object<ton_api::validatorSession_statsProducer>(
producer.id.bits256_value(), producer.candidate_id, producer.block_status, producer.comment,
producer.block_timestamp, producer.is_accepted, producer.is_ours, producer.got_submit_at,
producer.collation_time, producer.collated_at, producer.collation_cached, producer.validation_time,
producer.validated_at, producer.validation_cached, producer.gen_utime, producer.approved_weight,
producer.approved_33pct_at, producer.approved_66pct_at, producer.signed_weight, producer.signed_33pct_at,
producer.signed_66pct_at, producer.serialize_time, producer.deserialize_time, producer.serialized_size));
producer.id.bits256_value(), producer.candidate_id, producer.block_status, producer.root_hash,
producer.file_hash, producer.comment, producer.block_timestamp, producer.is_accepted, producer.is_ours,
producer.got_submit_at, producer.collation_time, producer.collated_at, producer.collation_cached,
it == recorded_block_stats_.end() ? -1.0 : it->second.collator_work_time_,
it == recorded_block_stats_.end() ? -1.0 : it->second.collator_cpu_work_time_, std::move(collation_stats),
producer.validation_time, producer.validated_at, producer.validation_cached,
it == recorded_block_stats_.end() ? -1.0 : it->second.validator_work_time_,
it == recorded_block_stats_.end() ? -1.0 : it->second.validator_cpu_work_time_, producer.gen_utime,
producer.approved_weight, producer.approved_33pct_at, producer.approved_66pct_at, std::move(approvers),
producer.signed_weight, producer.signed_33pct_at, producer.signed_66pct_at, std::move(signers),
producer.serialize_time, producer.deserialize_time, producer.serialized_size));
}
rounds.push_back(create_tl_object<ton_api::validatorSession_statsRound>(round.timestamp, std::move(producers)));
}
@ -3093,8 +3116,8 @@ void ValidatorManagerImpl::log_new_validator_group_stats(validatorsession::NewVa
create_tl_object<ton_api::validatorSession_newValidatorGroupStats_node>(node.id.bits256_value(), node.weight));
}
auto obj = create_tl_object<ton_api::validatorSession_newValidatorGroupStats>(
stats.session_id, stats.shard.workchain, stats.shard.shard, stats.cc_seqno, stats.timestamp, stats.self_idx,
std::move(nodes));
stats.session_id, stats.shard.workchain, stats.shard.shard, stats.cc_seqno, stats.last_key_block_seqno,
stats.timestamp, stats.self_idx, std::move(nodes));
auto s = td::json_encode<std::string>(td::ToJson(*obj.get()), false);
s.erase(std::remove_if(s.begin(), s.end(), [](char c) { return c == '\n' || c == '\r'; }), s.end());
@ -3103,7 +3126,31 @@ void ValidatorManagerImpl::log_new_validator_group_stats(validatorsession::NewVa
file << s << "\n";
file.close();
LOG(INFO) << "Writing new validator group stats for " << stats.shard.to_str();
LOG(INFO) << "Writing new validator group stats for " << stats.session_id << " shard=" << stats.shard.to_str()
<< " cc_seqno=" << stats.cc_seqno;
}
void ValidatorManagerImpl::log_end_validator_group_stats(validatorsession::EndValidatorGroupStats stats) {
std::string fname = opts_->get_session_logs_file();
if (fname.empty()) {
return;
}
std::vector<tl_object_ptr<ton_api::validatorSession_endValidatorGroupStats_node>> nodes;
for (const auto &node : stats.nodes) {
nodes.push_back(create_tl_object<ton_api::validatorSession_endValidatorGroupStats_node>(node.id.bits256_value(),
node.catchain_blocks));
}
auto obj = create_tl_object<ton_api::validatorSession_endValidatorGroupStats>(stats.session_id, stats.timestamp,
std::move(nodes));
auto s = td::json_encode<std::string>(td::ToJson(*obj.get()), false);
s.erase(std::remove_if(s.begin(), s.end(), [](char c) { return c == '\n' || c == '\r'; }), s.end());
std::ofstream file;
file.open(fname, std::ios_base::app);
file << s << "\n";
file.close();
LOG(INFO) << "Writing end validator group stats for " << stats.session_id;
}
void ValidatorManagerImpl::get_block_handle_for_litequery(BlockIdExt block_id, td::Promise<ConstBlockHandle> promise) {
@ -3480,6 +3527,31 @@ td::actor::ActorOwn<ValidatorManagerInterface> ValidatorManagerFactory::create(
rldp, overlays);
}
void ValidatorManagerImpl::record_collate_query_stats(BlockIdExt block_id, double work_time, double cpu_work_time,
CollationStats stats) {
auto &record = new_block_stats_record(block_id);
record.collator_work_time_ = work_time;
record.collator_cpu_work_time_ = cpu_work_time;
record.collator_stats_ = std::move(stats);
}
void ValidatorManagerImpl::record_validate_query_stats(BlockIdExt block_id, double work_time, double cpu_work_time) {
auto &record = new_block_stats_record(block_id);
record.validator_work_time_ = work_time;
record.validator_cpu_work_time_ = cpu_work_time;
}
ValidatorManagerImpl::RecordedBlockStats &ValidatorManagerImpl::new_block_stats_record(BlockIdExt block_id) {
if (!recorded_block_stats_.count(block_id)) {
recorded_block_stats_lru_.push(block_id);
if (recorded_block_stats_lru_.size() > 4096) {
recorded_block_stats_.erase(recorded_block_stats_lru_.front());
recorded_block_stats_lru_.pop();
}
}
return recorded_block_stats_[block_id];
}
size_t ValidatorManagerImpl::CheckedExtMsgCounter::get_msg_count(WorkchainId wc, StdSmcAddress addr) {
before_query();
auto it1 = counter_cur_.find({wc, addr});

19
validator/manager.hpp
View file

@ -39,6 +39,7 @@
#include <map>
#include <set>
#include <list>
#include <queue>
namespace ton {
@ -278,7 +279,7 @@ class ValidatorManagerImpl : public ValidatorManager {
BlockSeqno last_key_block_seqno,
const validatorsession::ValidatorSessionOptions &opts);
td::actor::ActorOwn<ValidatorGroup> create_validator_group(ValidatorSessionId session_id, ShardIdFull shard,
td::Ref<ValidatorSet> validator_set,
td::Ref<ValidatorSet> validator_set, BlockSeqno key_seqno,
validatorsession::ValidatorSessionOptions opts,
bool create_catchain);
struct ValidatorGroupEntry {
@ -619,6 +620,7 @@ class ValidatorManagerImpl : public ValidatorManager {
void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override;
void log_new_validator_group_stats(validatorsession::NewValidatorGroupStats stats) override;
void log_end_validator_group_stats(validatorsession::EndValidatorGroupStats stats) override;
void update_options(td::Ref<ValidatorManagerOptions> opts) override;
@ -756,6 +758,21 @@ class ValidatorManagerImpl : public ValidatorManager {
td::actor::ActorOwn<CandidatesBuffer> candidates_buffer_;
struct RecordedBlockStats {
double collator_work_time_ = -1.0;
double collator_cpu_work_time_ = -1.0;
td::optional<CollationStats> collator_stats_;
double validator_work_time_ = -1.0;
double validator_cpu_work_time_ = -1.0;
};
std::map<BlockIdExt, RecordedBlockStats> recorded_block_stats_;
std::queue<BlockIdExt> recorded_block_stats_lru_;
void record_collate_query_stats(BlockIdExt block_id, double work_time, double cpu_work_time,
CollationStats stats) override;
void record_validate_query_stats(BlockIdExt block_id, double work_time, double cpu_work_time) override;
RecordedBlockStats &new_block_stats_record(BlockIdExt block_id);
struct Collator {
td::actor::ActorOwn<CollatorNode> actor;
std::set<ShardIdFull> shards;

11
validator/validator-group.cpp
View file

@ -369,6 +369,7 @@ void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterch
stats.session_id = session_id_;
stats.shard = shard_;
stats.cc_seqno = validator_set_->get_catchain_seqno();
stats.last_key_block_seqno = last_key_block_seqno_;
stats.timestamp = td::Clocks::system();
td::uint32 idx = 0;
for (const auto& node : validator_set_->export_vector()) {
@ -400,6 +401,16 @@ void ValidatorGroup::destroy() {
td::actor::send_closure(manager, &ValidatorManager::log_validator_session_stats, block_id,
std::move(stats));
});
td::actor::send_closure(session_, &validatorsession::ValidatorSession::get_end_stats,
[manager = manager_](td::Result<validatorsession::EndValidatorGroupStats> R) {
if (R.is_error()) {
LOG(DEBUG) << "Failed to get validator session end stats: " << R.move_as_error();
return;
}
auto stats = R.move_as_ok();
td::actor::send_closure(manager, &ValidatorManager::log_end_validator_group_stats,
std::move(stats));
});
auto ses = session_.release();
delay_action([ses]() mutable { td::actor::send_closure(ses, &validatorsession::ValidatorSession::destroy); },
td::Timestamp::in(10.0));

6
validator/validator-group.hpp
View file

@ -70,8 +70,8 @@ class ValidatorGroup : public td::actor::Actor {
}
ValidatorGroup(ShardIdFull shard, PublicKeyHash local_id, ValidatorSessionId session_id,
td::Ref<ValidatorSet> validator_set, block::CollatorConfig collator_config,
validatorsession::ValidatorSessionOptions config,
td::Ref<ValidatorSet> validator_set, BlockSeqno last_key_block_seqno,
block::CollatorConfig collator_config, validatorsession::ValidatorSessionOptions config,
td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<overlay::Overlays> overlays,
std::string db_root, td::actor::ActorId<ValidatorManager> validator_manager, bool create_session,
@ -80,6 +80,7 @@ class ValidatorGroup : public td::actor::Actor {
, local_id_(std::move(local_id))
, session_id_(session_id)
, validator_set_(std::move(validator_set))
, last_key_block_seqno_(last_key_block_seqno)
, collator_config_(std::move(collator_config))
, config_(std::move(config))
, keyring_(keyring)
@ -122,6 +123,7 @@ class ValidatorGroup : public td::actor::Actor {
BlockIdExt min_masterchain_block_id_;
td::Ref<ValidatorSet> validator_set_;
BlockSeqno last_key_block_seqno_;
block::CollatorConfig collator_config_;
validatorsession::ValidatorSessionOptions config_;