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

Validator patch: state download, adnl stats (#1257)

Browse source 
* Persistent state download improvements

1) Don't start over on restart
2) Download shards one at a time to reduce RAM usage
3) More logs

* Remove old peers from adnl stats
This commit is contained in:
SpyCheese 2024-10-09 13:55:59 +03:00 • committed by GitHub
parent 1da94e62ad
commit b69214b6af
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 135 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

14
validator/downloaders/download-state.cpp
View file

@ -50,7 +50,16 @@ void DownloadShardState::start_up() {
void DownloadShardState::got_block_handle(BlockHandle handle) {
handle_ = std::move(handle);
download_state();
if (handle_->received_state()) {
LOG(WARNING) << "shard state " << block_id_.to_str() << " already stored in db";
td::actor::send_closure(manager_, &ValidatorManagerInterface::get_shard_state_from_db, handle_,
[SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
R.ensure();
td::actor::send_closure(SelfId, &DownloadShardState::written_shard_state, R.move_as_ok());
});
} else {
download_state();
}
}
void DownloadShardState::retry() {
@ -165,6 +174,7 @@ void DownloadShardState::downloaded_shard_state(td::BufferSlice data) {
}
void DownloadShardState::checked_shard_state() {
LOG(WARNING) << "checked shard state " << block_id_.to_str();
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
R.ensure();
td::actor::send_closure(SelfId, &DownloadShardState::written_shard_state_file);
@ -179,6 +189,7 @@ void DownloadShardState::checked_shard_state() {
}
void DownloadShardState::written_shard_state_file() {
LOG(WARNING) << "written shard state file " << block_id_.to_str();
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
R.ensure();
td::actor::send_closure(SelfId, &DownloadShardState::written_shard_state, R.move_as_ok());
@ -207,6 +218,7 @@ void DownloadShardState::written_shard_state(td::Ref<ShardState> state) {
}
void DownloadShardState::written_block_handle() {
LOG(WARNING) << "finished downloading and storing shard state " << block_id_.to_str();
finish_query();
}

2
validator/manager-init.cpp
View file

@ -227,7 +227,7 @@ void ValidatorManagerMasterchainReiniter::choose_masterchain_state() {
}
if (!p || ValidatorManager::is_persistent_state(h->unix_time(), p->unix_time())) {
auto ttl = ValidatorManager::persistent_state_ttl(h->unix_time());
double time_to_download = 3600 * 3;
double time_to_download = 3600 * 8;
if (ttl > td::Clocks::system() + time_to_download) {
handle = h;
break;

28
validator/net/download-state.cpp
View file

@ -52,12 +52,7 @@ DownloadState::DownloadState(BlockIdExt block_id, BlockIdExt masterchain_block_i
void DownloadState::abort_query(td::Status reason) {
if (promise_) {
if (reason.code() == ErrorCode::notready || reason.code() == ErrorCode::timeout) {
VLOG(FULL_NODE_DEBUG) << "failed to download state " << block_id_ << " from " << download_from_ << ": " << reason;
} else {
VLOG(FULL_NODE_NOTICE) << "failed to download state " << block_id_ << " from " << download_from_ << ": "
<< reason;
}
LOG(WARNING) << "failed to download state " << block_id_.to_str() << " from " << download_from_ << ": " << reason;
promise_.set_error(std::move(reason));
}
stop();
@ -77,6 +72,19 @@ void DownloadState::finish_query() {
void DownloadState::start_up() {
alarm_timestamp() = timeout_;
td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_persistent_state, block_id_,
masterchain_block_id_,
[SelfId = actor_id(this), block_id = block_id_](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &DownloadState::get_block_handle);
} else {
LOG(WARNING) << "got block state from disk: " << block_id.to_str();
td::actor::send_closure(SelfId, &DownloadState::got_block_state, R.move_as_ok());
}
});
}
void DownloadState::get_block_handle() {
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<BlockHandle> R) {
if (R.is_error()) {
td::actor::send_closure(SelfId, &DownloadState::abort_query, R.move_as_error());
@ -115,7 +123,7 @@ void DownloadState::got_block_handle(BlockHandle handle) {
void DownloadState::got_node_to_download(adnl::AdnlNodeIdShort node) {
download_from_ = node;
LOG(INFO) << "downloading state " << block_id_.to_str() << " from " << download_from_;
LOG(WARNING) << "downloading state " << block_id_.to_str() << " from " << download_from_;
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) mutable {
if (R.is_error()) {
@ -192,8 +200,8 @@ void DownloadState::got_block_state_part(td::BufferSlice data, td::uint32 reques
double elapsed = prev_logged_timer_.elapsed();
if (elapsed > 10.0) {
prev_logged_timer_ = td::Timer();
LOG(INFO) << "downloading state " << block_id_.to_str() << ": total=" << sum_ << " ("
<< td::format::as_size((td::uint64)(double(sum_ - prev_logged_sum_) / elapsed)) << "/s)";
LOG(WARNING) << "downloading state " << block_id_.to_str() << ": " << td::format::as_size(sum_) << " ("
<< td::format::as_size((td::uint64)(double(sum_ - prev_logged_sum_) / elapsed)) << "/s)";
prev_logged_sum_ = sum_;
}
@ -234,7 +242,7 @@ void DownloadState::got_block_state_part(td::BufferSlice data, td::uint32 reques
void DownloadState::got_block_state(td::BufferSlice data) {
state_ = std::move(data);
LOG(INFO) << "finished downloading state " << block_id_.to_str() << ": total=" << sum_;
LOG(WARNING) << "finished downloading state " << block_id_.to_str() << ": " << td::format::as_size(state_.size());
finish_query();
}

1
validator/net/download-state.hpp
View file

@ -43,6 +43,7 @@ class DownloadState : public td::actor::Actor {
void finish_query();
void start_up() override;
void get_block_handle();
void got_block_handle(BlockHandle handle);
void got_node_to_download(adnl::AdnlNodeIdShort node);
void got_block_state_description(td::BufferSlice data_description);

44
validator/shard-client.cpp
View file

@ -79,30 +79,30 @@ void ShardClient::got_init_state_from_db(td::Ref<MasterchainState> state) {
void ShardClient::start_up_init_mode() {
build_shard_overlays();
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
R.ensure();
td::actor::send_closure(SelfId, &ShardClient::applied_all_shards);
});
td::MultiPromise mp;
auto ig = mp.init_guard();
ig.add_promise(std::move(P));
auto vec = masterchain_state_->get_shards();
for (auto &shard : vec) {
if (opts_->need_monitor(shard->shard())) {
auto P = td::PromiseCreator::lambda([promise = ig.get_promise()](td::Result<td::Ref<ShardState>> R) mutable {
R.ensure();
promise.set_value(td::Unit());
});
td::actor::create_actor<DownloadShardState>("downloadstate", shard->top_block_id(),
masterchain_block_handle_->id(), 2, manager_,
td::Timestamp::in(3600 * 3), std::move(P))
.release();
std::vector<BlockIdExt> shards;
for (const auto& s : masterchain_state_->get_shards()) {
if (opts_->need_monitor(s->shard())) {
shards.push_back(s->top_block_id());
}
}
download_shard_states(masterchain_block_handle_->id(), std::move(shards), 0);
}
void ShardClient::download_shard_states(BlockIdExt masterchain_block_id, std::vector<BlockIdExt> shards, size_t idx) {
if (idx >= shards.size()) {
LOG(WARNING) << "downloaded all shard states";
applied_all_shards();
return;
}
BlockIdExt block_id = shards[idx];
td::actor::create_actor<DownloadShardState>(
"downloadstate", block_id, masterchain_block_handle_->id(), 2, manager_, td::Timestamp::in(3600 * 5),
[=, SelfId = actor_id(this), shards = std::move(shards)](td::Result<td::Ref<ShardState>> R) {
R.ensure();
td::actor::send_closure(SelfId, &ShardClient::download_shard_states, masterchain_block_id, std::move(shards),
idx + 1);
})
.release();
}
void ShardClient::applied_all_shards() {

9
validator/shard-client.hpp
View file

@ -68,19 +68,12 @@ class ShardClient : public td::actor::Actor {
void start_up() override;
void start_up_init_mode();
void start_up_init_mode_finished();
void download_shard_states(BlockIdExt masterchain_block_id, std::vector<BlockIdExt> shards, size_t idx);
void start();
void got_state_from_db(BlockIdExt masterchain_block_id);
void got_init_handle_from_db(BlockHandle handle);
void got_init_state_from_db(td::Ref<MasterchainState> state);
void im_download_shard_state(BlockIdExt block_id, td::Promise<td::Unit> promise);
void im_downloaded_zero_state(BlockIdExt block_id, td::BufferSlice data, td::Promise<td::Unit> promise);
void im_downloaded_proof_link(BlockIdExt block_id, td::BufferSlice data, td::Promise<td::Unit> promise);
void im_checked_proof_link(BlockIdExt block_id, td::Promise<td::Unit> promise);
void im_downloaded_shard_state(BlockIdExt block_id, td::Promise<td::Unit> promise);
void im_got_shard_handle(BlockHandle handle, td::Promise<td::Unit> promise);
void new_masterchain_block_id(BlockIdExt masterchain_block_id);
void got_masterchain_block_handle(BlockHandle handle);
void download_masterchain_state();