mirror of
https://github.com/ton-blockchain/ton
synced 2025-03-09 15:40:10 +00:00
Cache recent block states and adjust timeouts (#823)
* Add parameter --celldb-compress-depth to speed up celldb * Fix collator timeout * Add block_state_cache * Adjust state cache ttl * Don't merge shards when queue is too big * Decrease lt limit if previous block is too old --------- Co-authored-by: SpyCheese <mikle98@yandex.ru>
This commit is contained in:
EmelyanenkoK
GitHub
parent
7fcf267717
commit
9b6d699c21
20 changed files with 230 additions and 37 deletions
|
|
@ -27,16 +27,25 @@ namespace vm {
|
|||
namespace {
|
||||
class RefcntCellStorer {
|
||||
public:
|
||||
RefcntCellStorer(td::int32 refcnt, const DataCell &cell) : refcnt_(refcnt), cell_(cell) {
|
||||
RefcntCellStorer(td::int32 refcnt, const td::Ref<DataCell> &cell, bool as_boc)
|
||||
: refcnt_(refcnt), cell_(cell), as_boc_(as_boc) {
|
||||
}
|
||||
|
||||
template <class StorerT>
|
||||
void store(StorerT &storer) const {
|
||||
using td::store;
|
||||
if (as_boc_) {
|
||||
td::int32 tag = -1;
|
||||
store(tag, storer);
|
||||
store(refcnt_, storer);
|
||||
td::BufferSlice data = vm::std_boc_serialize(cell_).move_as_ok();
|
||||
storer.store_slice(data);
|
||||
return;
|
||||
}
|
||||
store(refcnt_, storer);
|
||||
store(cell_, storer);
|
||||
for (unsigned i = 0; i < cell_.size_refs(); i++) {
|
||||
auto cell = cell_.get_ref(i);
|
||||
store(*cell_, storer);
|
||||
for (unsigned i = 0; i < cell_->size_refs(); i++) {
|
||||
auto cell = cell_->get_ref(i);
|
||||
auto level_mask = cell->get_level_mask();
|
||||
auto level = level_mask.get_level();
|
||||
td::uint8 x = static_cast<td::uint8>(level_mask.get_mask());
|
||||
|
|
@ -60,7 +69,8 @@ class RefcntCellStorer {
|
|||
|
||||
private:
|
||||
td::int32 refcnt_;
|
||||
const DataCell &cell_;
|
||||
td::Ref<DataCell> cell_;
|
||||
bool as_boc_;
|
||||
};
|
||||
|
||||
class RefcntCellParser {
|
||||
|
|
@ -69,11 +79,17 @@ class RefcntCellParser {
|
|||
}
|
||||
td::int32 refcnt;
|
||||
Ref<DataCell> cell;
|
||||
bool stored_boc_;
|
||||
|
||||
template <class ParserT>
|
||||
void parse(ParserT &parser, ExtCellCreator &ext_cell_creator) {
|
||||
using ::td::parse;
|
||||
parse(refcnt, parser);
|
||||
stored_boc_ = false;
|
||||
if (refcnt == -1) {
|
||||
stored_boc_ = true;
|
||||
parse(refcnt, parser);
|
||||
}
|
||||
if (!need_data_) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -81,6 +97,12 @@ class RefcntCellParser {
|
|||
TRY_STATUS(parser.get_status());
|
||||
auto size = parser.get_left_len();
|
||||
td::Slice data = parser.template fetch_string_raw<td::Slice>(size);
|
||||
if (stored_boc_) {
|
||||
TRY_RESULT(boc, vm::std_boc_deserialize(data));
|
||||
TRY_RESULT(loaded_cell, boc->load_cell());
|
||||
cell = std::move(loaded_cell.data_cell);
|
||||
return td::Status::OK();
|
||||
}
|
||||
CellSerializationInfo info;
|
||||
auto cell_data = data;
|
||||
TRY_STATUS(info.init(cell_data, 0 /*ref_byte_size*/));
|
||||
|
|
@ -122,7 +144,8 @@ class RefcntCellParser {
|
|||
};
|
||||
} // namespace
|
||||
|
||||
CellLoader::CellLoader(std::shared_ptr<KeyValueReader> reader) : reader_(std::move(reader)) {
|
||||
CellLoader::CellLoader(std::shared_ptr<KeyValueReader> reader, std::function<void(const LoadResult &)> on_load_callback)
|
||||
: reader_(std::move(reader)), on_load_callback_(std::move(on_load_callback)) {
|
||||
CHECK(reader_);
|
||||
}
|
||||
|
||||
|
|
@ -145,7 +168,11 @@ td::Result<CellLoader::LoadResult> CellLoader::load(td::Slice hash, bool need_da
|
|||
|
||||
res.refcnt_ = refcnt_cell.refcnt;
|
||||
res.cell_ = std::move(refcnt_cell.cell);
|
||||
res.stored_boc_ = refcnt_cell.stored_boc_;
|
||||
//CHECK(res.cell_->get_hash() == hash);
|
||||
if (on_load_callback_) {
|
||||
on_load_callback_(res);
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
|
@ -157,7 +184,7 @@ td::Status CellStorer::erase(td::Slice hash) {
|
|||
return kv_.erase(hash);
|
||||
}
|
||||
|
||||
td::Status CellStorer::set(td::int32 refcnt, const DataCell &cell) {
|
||||
return kv_.set(cell.get_hash().as_slice(), td::serialize(RefcntCellStorer(refcnt, cell)));
|
||||
td::Status CellStorer::set(td::int32 refcnt, const td::Ref<DataCell> &cell, bool as_boc) {
|
||||
return kv_.set(cell->get_hash().as_slice(), td::serialize(RefcntCellStorer(refcnt, cell, as_boc)));
|
||||
}
|
||||
} // namespace vm
|
||||
|
|
|
|||
|
|
@ -45,19 +45,21 @@ class CellLoader {
|
|||
|
||||
Ref<DataCell> cell_;
|
||||
td::int32 refcnt_{0};
|
||||
bool stored_boc_{false};
|
||||
};
|
||||
CellLoader(std::shared_ptr<KeyValueReader> reader);
|
||||
CellLoader(std::shared_ptr<KeyValueReader> reader, std::function<void(const LoadResult &)> on_load_callback = {});
|
||||
td::Result<LoadResult> load(td::Slice hash, bool need_data, ExtCellCreator &ext_cell_creator);
|
||||
|
||||
private:
|
||||
std::shared_ptr<KeyValueReader> reader_;
|
||||
std::function<void(const LoadResult &)> on_load_callback_;
|
||||
};
|
||||
|
||||
class CellStorer {
|
||||
public:
|
||||
CellStorer(KeyValue &kv);
|
||||
td::Status erase(td::Slice hash);
|
||||
td::Status set(td::int32 refcnt, const DataCell &cell);
|
||||
td::Status set(td::int32 refcnt, const td::Ref<DataCell> &cell, bool as_boc);
|
||||
|
||||
private:
|
||||
KeyValue &kv_;
|
||||
|
|
|
|||
|
|
@ -210,6 +210,14 @@ class DynamicBagOfCellsDbImpl : public DynamicBagOfCellsDb, private ExtCellCreat
|
|||
return td::Status::OK();
|
||||
}
|
||||
|
||||
void set_celldb_compress_depth(td::uint32 value) override {
|
||||
celldb_compress_depth_ = value;
|
||||
}
|
||||
|
||||
vm::ExtCellCreator& as_ext_cell_creator() override {
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
std::unique_ptr<CellLoader> loader_;
|
||||
std::vector<Ref<Cell>> to_inc_;
|
||||
|
|
@ -217,6 +225,7 @@ class DynamicBagOfCellsDbImpl : public DynamicBagOfCellsDb, private ExtCellCreat
|
|||
CellHashTable<CellInfo> hash_table_;
|
||||
std::vector<CellInfo *> visited_;
|
||||
Stats stats_diff_;
|
||||
td::uint32 celldb_compress_depth_{0};
|
||||
|
||||
static td::NamedThreadSafeCounter::CounterRef get_thread_safe_counter() {
|
||||
static auto res = td::NamedThreadSafeCounter::get_default().get_counter("DynamicBagOfCellsDb");
|
||||
|
|
@ -443,7 +452,8 @@ class DynamicBagOfCellsDbImpl : public DynamicBagOfCellsDb, private ExtCellCreat
|
|||
guard.dismiss();
|
||||
} else {
|
||||
auto loaded_cell = info.cell->load_cell().move_as_ok();
|
||||
storer.set(info.db_refcnt, *loaded_cell.data_cell);
|
||||
storer.set(info.db_refcnt, loaded_cell.data_cell,
|
||||
loaded_cell.data_cell->get_depth() == celldb_compress_depth_ && celldb_compress_depth_ != 0);
|
||||
info.in_db = true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,6 +64,9 @@ class DynamicBagOfCellsDb {
|
|||
// restart with new loader will also reset stats_diff
|
||||
virtual td::Status set_loader(std::unique_ptr<CellLoader> loader) = 0;
|
||||
|
||||
virtual void set_celldb_compress_depth(td::uint32 value) = 0;
|
||||
virtual vm::ExtCellCreator& as_ext_cell_creator() = 0;
|
||||
|
||||
static std::unique_ptr<DynamicBagOfCellsDb> create();
|
||||
|
||||
class AsyncExecutor {
|
||||
|
|
|
|||
|
|
@ -1363,6 +1363,7 @@ td::Status ValidatorEngine::load_global_config() {
|
|||
if (!session_logs_file_.empty()) {
|
||||
validator_options_.write().set_session_logs_file(session_logs_file_);
|
||||
}
|
||||
validator_options_.write().set_celldb_compress_depth(celldb_compress_depth_);
|
||||
|
||||
std::vector<ton::BlockIdExt> h;
|
||||
for (auto &x : conf.validator_->hardforks_) {
|
||||
|
|
@ -3761,6 +3762,11 @@ int main(int argc, char *argv[]) {
|
|||
acts.push_back([&x, at]() { td::actor::send_closure(x, &ValidatorEngine::schedule_shutdown, (double)at); });
|
||||
return td::Status::OK();
|
||||
});
|
||||
p.add_checked_option('\0', "celldb-compress-depth", "(default: 0)", [&](td::Slice arg) {
|
||||
TRY_RESULT(value, td::to_integer_safe<td::uint32>(arg));
|
||||
acts.push_back([&x, value]() { td::actor::send_closure(x, &ValidatorEngine::set_celldb_compress_depth, value); });
|
||||
return td::Status::OK();
|
||||
});
|
||||
auto S = p.run(argc, argv);
|
||||
if (S.is_error()) {
|
||||
LOG(ERROR) << "failed to parse options: " << S.move_as_error();
|
||||
|
|
|
|||
|
|
@ -200,6 +200,7 @@ class ValidatorEngine : public td::actor::Actor {
|
|||
double sync_ttl_ = 0;
|
||||
double archive_ttl_ = 0;
|
||||
double key_proof_ttl_ = 0;
|
||||
td::uint32 celldb_compress_depth_ = 0;
|
||||
bool read_config_ = false;
|
||||
bool started_keyring_ = false;
|
||||
bool started_ = false;
|
||||
|
|
@ -257,6 +258,9 @@ class ValidatorEngine : public td::actor::Actor {
|
|||
keys_[key.compute_short_id()] = key;
|
||||
}
|
||||
void schedule_shutdown(double at);
|
||||
void set_celldb_compress_depth(td::uint32 value) {
|
||||
celldb_compress_depth_ = value;
|
||||
}
|
||||
void start_up() override;
|
||||
ValidatorEngine() {
|
||||
}
|
||||
|
|
|
|||
|
|
@ -62,16 +62,29 @@ void CellDbBase::execute_sync(std::function<void()> f) {
|
|||
f();
|
||||
}
|
||||
|
||||
CellDbIn::CellDbIn(td::actor::ActorId<RootDb> root_db, td::actor::ActorId<CellDb> parent, std::string path)
|
||||
: root_db_(root_db), parent_(parent), path_(std::move(path)) {
|
||||
CellDbIn::CellDbIn(td::actor::ActorId<RootDb> root_db, td::actor::ActorId<CellDb> parent, std::string path,
|
||||
td::Ref<ValidatorManagerOptions> opts)
|
||||
: root_db_(root_db), parent_(parent), path_(std::move(path)), opts_(opts) {
|
||||
}
|
||||
|
||||
void CellDbIn::start_up() {
|
||||
on_load_callback_ = [db = actor_id(this),
|
||||
compress_depth = opts_->get_celldb_compress_depth()](const vm::CellLoader::LoadResult& res) {
|
||||
if (res.cell_.is_null()) {
|
||||
return;
|
||||
}
|
||||
bool expected_stored_boc = res.cell_->get_depth() == compress_depth && compress_depth != 0;
|
||||
if (expected_stored_boc != res.stored_boc_) {
|
||||
td::actor::send_closure(db, &CellDbIn::migrate_cell, td::Bits256{res.cell_->get_hash().bits()});
|
||||
}
|
||||
};
|
||||
|
||||
CellDbBase::start_up();
|
||||
cell_db_ = std::make_shared<td::RocksDb>(td::RocksDb::open(path_).move_as_ok());
|
||||
|
||||
boc_ = vm::DynamicBagOfCellsDb::create();
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot())).ensure();
|
||||
boc_->set_celldb_compress_depth(opts_->get_celldb_compress_depth());
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot(), on_load_callback_)).ensure();
|
||||
td::actor::send_closure(parent_, &CellDb::update_snapshot, cell_db_->snapshot());
|
||||
|
||||
alarm_timestamp() = td::Timestamp::in(10.0);
|
||||
|
|
@ -129,7 +142,7 @@ void CellDbIn::store_cell(BlockIdExt block_id, td::Ref<vm::Cell> cell, td::Promi
|
|||
set_block(key_hash, std::move(D));
|
||||
cell_db_->commit_write_batch().ensure();
|
||||
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot())).ensure();
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot(), on_load_callback_)).ensure();
|
||||
td::actor::send_closure(parent_, &CellDb::update_snapshot, cell_db_->snapshot());
|
||||
|
||||
promise.set_result(boc_->load_cell(cell->get_hash().as_slice()));
|
||||
|
|
@ -140,6 +153,9 @@ void CellDbIn::get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>>
|
|||
}
|
||||
|
||||
void CellDbIn::alarm() {
|
||||
if (migrate_after_ && migrate_after_.is_in_past()) {
|
||||
migrate_cells();
|
||||
}
|
||||
auto E = get_block(get_empty_key_hash()).move_as_ok();
|
||||
auto N = get_block(E.next).move_as_ok();
|
||||
if (N.is_empty()) {
|
||||
|
|
@ -220,7 +236,7 @@ void CellDbIn::gc_cont2(BlockHandle handle) {
|
|||
cell_db_->commit_write_batch().ensure();
|
||||
alarm_timestamp() = td::Timestamp::now();
|
||||
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot())).ensure();
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot(), on_load_callback_)).ensure();
|
||||
td::actor::send_closure(parent_, &CellDb::update_snapshot, cell_db_->snapshot());
|
||||
|
||||
DCHECK(get_block(key_hash).is_error());
|
||||
|
|
@ -273,6 +289,49 @@ void CellDbIn::set_block(KeyHash key_hash, DbEntry e) {
|
|||
cell_db_->set(td::as_slice(key), e.release()).ensure();
|
||||
}
|
||||
|
||||
void CellDbIn::migrate_cell(td::Bits256 hash) {
|
||||
cells_to_migrate_.insert(hash);
|
||||
if (cells_to_migrate_.size() >= 32) {
|
||||
migrate_cells();
|
||||
} else if (!migrate_after_) {
|
||||
migrate_after_ = td::Timestamp::in(1.0);
|
||||
}
|
||||
}
|
||||
|
||||
void CellDbIn::migrate_cells() {
|
||||
if (cells_to_migrate_.empty()) {
|
||||
return;
|
||||
}
|
||||
vm::CellStorer stor{*cell_db_};
|
||||
auto loader = std::make_unique<vm::CellLoader>(cell_db_->snapshot());
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(*loader)).ensure();
|
||||
cell_db_->begin_write_batch().ensure();
|
||||
td::uint32 cnt = 0;
|
||||
for (const auto& hash : cells_to_migrate_) {
|
||||
auto R = loader->load(hash.as_slice(), true, boc_->as_ext_cell_creator());
|
||||
if (R.is_error()) {
|
||||
continue;
|
||||
}
|
||||
if (R.ok().status == vm::CellLoader::LoadResult::NotFound) {
|
||||
continue;
|
||||
}
|
||||
bool expected_stored_boc =
|
||||
R.ok().cell_->get_depth() == opts_->get_celldb_compress_depth() && opts_->get_celldb_compress_depth() != 0;
|
||||
if (expected_stored_boc != R.ok().stored_boc_) {
|
||||
++cnt;
|
||||
stor.set(R.ok().refcnt(), R.ok().cell_, expected_stored_boc).ensure();
|
||||
}
|
||||
}
|
||||
cells_to_migrate_.clear();
|
||||
if (cnt > 0) {
|
||||
LOG(DEBUG) << "Migrated " << cnt << " cells";
|
||||
}
|
||||
cell_db_->commit_write_batch().ensure();
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(cell_db_->snapshot(), on_load_callback_)).ensure();
|
||||
td::actor::send_closure(parent_, &CellDb::update_snapshot, cell_db_->snapshot());
|
||||
migrate_after_ = td::Timestamp::never();
|
||||
}
|
||||
|
||||
void CellDb::load_cell(RootHash hash, td::Promise<td::Ref<vm::DataCell>> promise) {
|
||||
if (!started_) {
|
||||
td::actor::send_closure(cell_db_, &CellDbIn::load_cell, hash, std::move(promise));
|
||||
|
|
@ -300,7 +359,18 @@ void CellDb::get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> p
|
|||
void CellDb::start_up() {
|
||||
CellDbBase::start_up();
|
||||
boc_ = vm::DynamicBagOfCellsDb::create();
|
||||
cell_db_ = td::actor::create_actor<CellDbIn>("celldbin", root_db_, actor_id(this), path_);
|
||||
boc_->set_celldb_compress_depth(opts_->get_celldb_compress_depth());
|
||||
cell_db_ = td::actor::create_actor<CellDbIn>("celldbin", root_db_, actor_id(this), path_, opts_);
|
||||
on_load_callback_ = [db = cell_db_.get(),
|
||||
compress_depth = opts_->get_celldb_compress_depth()](const vm::CellLoader::LoadResult& res) {
|
||||
if (res.cell_.is_null()) {
|
||||
return;
|
||||
}
|
||||
bool expected_stored_boc = res.cell_->get_depth() == compress_depth && compress_depth != 0;
|
||||
if (expected_stored_boc != res.stored_boc_) {
|
||||
td::actor::send_closure(db, &CellDbIn::migrate_cell, td::Bits256{res.cell_->get_hash().bits()});
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
CellDbIn::DbEntry::DbEntry(tl_object_ptr<ton_api::db_celldb_value> entry)
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@
|
|||
#include "ton/ton-types.h"
|
||||
#include "interfaces/block-handle.h"
|
||||
#include "auto/tl/ton_api.h"
|
||||
#include "validator.h"
|
||||
|
||||
namespace ton {
|
||||
|
||||
|
|
@ -53,7 +54,10 @@ class CellDbIn : public CellDbBase {
|
|||
void store_cell(BlockIdExt block_id, td::Ref<vm::Cell> cell, td::Promise<td::Ref<vm::DataCell>> promise);
|
||||
void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise);
|
||||
|
||||
CellDbIn(td::actor::ActorId<RootDb> root_db, td::actor::ActorId<CellDb> parent, std::string path);
|
||||
void migrate_cell(td::Bits256 hash);
|
||||
|
||||
CellDbIn(td::actor::ActorId<RootDb> root_db, td::actor::ActorId<CellDb> parent, std::string path,
|
||||
td::Ref<ValidatorManagerOptions> opts);
|
||||
|
||||
void start_up() override;
|
||||
void alarm() override;
|
||||
|
|
@ -89,13 +93,20 @@ class CellDbIn : public CellDbBase {
|
|||
void gc_cont2(BlockHandle handle);
|
||||
void skip_gc();
|
||||
|
||||
void migrate_cells();
|
||||
|
||||
td::actor::ActorId<RootDb> root_db_;
|
||||
td::actor::ActorId<CellDb> parent_;
|
||||
|
||||
std::string path_;
|
||||
td::Ref<ValidatorManagerOptions> opts_;
|
||||
|
||||
std::unique_ptr<vm::DynamicBagOfCellsDb> boc_;
|
||||
std::shared_ptr<vm::KeyValue> cell_db_;
|
||||
|
||||
std::function<void(const vm::CellLoader::LoadResult&)> on_load_callback_;
|
||||
std::set<td::Bits256> cells_to_migrate_;
|
||||
td::Timestamp migrate_after_ = td::Timestamp::never();
|
||||
};
|
||||
|
||||
class CellDb : public CellDbBase {
|
||||
|
|
@ -104,11 +115,12 @@ class CellDb : public CellDbBase {
|
|||
void store_cell(BlockIdExt block_id, td::Ref<vm::Cell> cell, td::Promise<td::Ref<vm::DataCell>> promise);
|
||||
void update_snapshot(std::unique_ptr<td::KeyValueReader> snapshot) {
|
||||
started_ = true;
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(std::move(snapshot))).ensure();
|
||||
boc_->set_loader(std::make_unique<vm::CellLoader>(std::move(snapshot), on_load_callback_)).ensure();
|
||||
}
|
||||
void get_cell_db_reader(td::Promise<std::shared_ptr<vm::CellDbReader>> promise);
|
||||
|
||||
CellDb(td::actor::ActorId<RootDb> root_db, std::string path) : root_db_(root_db), path_(path) {
|
||||
CellDb(td::actor::ActorId<RootDb> root_db, std::string path, td::Ref<ValidatorManagerOptions> opts)
|
||||
: root_db_(root_db), path_(path), opts_(opts) {
|
||||
}
|
||||
|
||||
void start_up() override;
|
||||
|
|
@ -116,11 +128,14 @@ class CellDb : public CellDbBase {
|
|||
private:
|
||||
td::actor::ActorId<RootDb> root_db_;
|
||||
std::string path_;
|
||||
td::Ref<ValidatorManagerOptions> opts_;
|
||||
|
||||
td::actor::ActorOwn<CellDbIn> cell_db_;
|
||||
|
||||
std::unique_ptr<vm::DynamicBagOfCellsDb> boc_;
|
||||
bool started_ = false;
|
||||
|
||||
std::function<void(const vm::CellLoader::LoadResult&)> on_load_callback_;
|
||||
};
|
||||
|
||||
} // namespace validator
|
||||
|
|
|
|||
|
|
@ -397,7 +397,7 @@ void RootDb::get_hardforks(td::Promise<std::vector<BlockIdExt>> promise) {
|
|||
}
|
||||
|
||||
void RootDb::start_up() {
|
||||
cell_db_ = td::actor::create_actor<CellDb>("celldb", actor_id(this), root_path_ + "/celldb/");
|
||||
cell_db_ = td::actor::create_actor<CellDb>("celldb", actor_id(this), root_path_ + "/celldb/", opts_);
|
||||
state_db_ = td::actor::create_actor<StateDb>("statedb", actor_id(this), root_path_ + "/state/");
|
||||
static_files_db_ = td::actor::create_actor<StaticFilesDb>("staticfilesdb", actor_id(this), root_path_ + "/static/");
|
||||
archive_db_ = td::actor::create_actor<ArchiveManager>("archive", actor_id(this), root_path_);
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@
|
|||
#include "statedb.hpp"
|
||||
#include "staticfilesdb.hpp"
|
||||
#include "archive-manager.hpp"
|
||||
#include "validator.h"
|
||||
|
||||
namespace ton {
|
||||
|
||||
|
|
@ -34,8 +35,9 @@ namespace validator {
|
|||
class RootDb : public Db {
|
||||
public:
|
||||
enum class Flags : td::uint32 { f_started = 1, f_ready = 2, f_switched = 4, f_archived = 8 };
|
||||
RootDb(td::actor::ActorId<ValidatorManager> validator_manager, std::string root_path)
|
||||
: validator_manager_(validator_manager), root_path_(std::move(root_path)) {
|
||||
RootDb(td::actor::ActorId<ValidatorManager> validator_manager, std::string root_path,
|
||||
td::Ref<ValidatorManagerOptions> opts)
|
||||
: validator_manager_(validator_manager), root_path_(std::move(root_path)), opts_(opts) {
|
||||
}
|
||||
|
||||
void start_up() override;
|
||||
|
|
@ -138,6 +140,7 @@ class RootDb : public Db {
|
|||
td::actor::ActorId<ValidatorManager> validator_manager_;
|
||||
|
||||
std::string root_path_;
|
||||
td::Ref<ValidatorManagerOptions> opts_;
|
||||
|
||||
td::actor::ActorOwn<CellDb> cell_db_;
|
||||
td::actor::ActorOwn<StateDb> state_db_;
|
||||
|
|
|
|||
|
|
@ -20,12 +20,14 @@
|
|||
|
||||
#include "interfaces/validator-manager.h"
|
||||
#include "interfaces/db.h"
|
||||
#include "validator.h"
|
||||
|
||||
namespace ton {
|
||||
|
||||
namespace validator {
|
||||
|
||||
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_);
|
||||
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_,
|
||||
td::Ref<ValidatorManagerOptions> opts);
|
||||
td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
|
||||
std::string db_root);
|
||||
|
||||
|
|
|
|||
|
|
@ -159,6 +159,7 @@ class Collator final : public td::actor::Actor {
|
|||
bool report_version_{false};
|
||||
bool skip_topmsgdescr_{false};
|
||||
bool skip_extmsg_{false};
|
||||
bool queue_too_big_{false};
|
||||
bool short_dequeue_records_{false};
|
||||
td::uint64 overload_history_{0}, underload_history_{0};
|
||||
td::uint64 block_size_estimate_{};
|
||||
|
|
|
|||
|
|
@ -703,9 +703,7 @@ bool Collator::unpack_last_mc_state() {
|
|||
return fatal_error(limits.move_as_error());
|
||||
}
|
||||
block_limits_ = limits.move_as_ok();
|
||||
if (!is_masterchain()) {
|
||||
// block_limits_->bytes = {131072 / 3, 524288 / 3, 1048576 / 3};
|
||||
// block_limits_->gas = {2000000 / 3, 10000000 / 3, 20000000 / 3};
|
||||
if (now_ > prev_now_ + 15 && block_limits_->lt_delta.hard() > 200) {
|
||||
block_limits_->lt_delta = {20, 180, 200};
|
||||
}
|
||||
LOG(DEBUG) << "block limits: bytes [" << block_limits_->bytes.underload() << ", " << block_limits_->bytes.soft()
|
||||
|
|
@ -1828,9 +1826,6 @@ bool Collator::init_utime() {
|
|||
if (timeout < new_timeout) {
|
||||
double add = new_timeout.at() - timeout.at();
|
||||
timeout = new_timeout;
|
||||
queue_cleanup_timeout_ += add;
|
||||
soft_timeout_ += add;
|
||||
medium_timeout_ += add;
|
||||
alarm_timestamp() = timeout;
|
||||
}
|
||||
|
||||
|
|
@ -2259,6 +2254,7 @@ bool Collator::out_msg_queue_cleanup() {
|
|||
if (outq_cleanup_partial_ || total > 8000) {
|
||||
LOG(INFO) << "out_msg_queue too big, skipping importing external messages";
|
||||
skip_extmsg_ = true;
|
||||
queue_too_big_ = true;
|
||||
}
|
||||
auto rt = out_msg_queue_->get_root();
|
||||
if (verbosity >= 2) {
|
||||
|
|
@ -4170,8 +4166,12 @@ bool Collator::check_block_overload() {
|
|||
<< " size_estimate=" << block_size_estimate_;
|
||||
auto cl = block_limit_status_->classify();
|
||||
if (cl <= block::ParamLimits::cl_underload) {
|
||||
underload_history_ |= 1;
|
||||
LOG(INFO) << "block is underloaded";
|
||||
if (queue_too_big_) {
|
||||
LOG(INFO) << "block is underloaded, but don't set underload history because out msg queue is big";
|
||||
} else {
|
||||
underload_history_ |= 1;
|
||||
LOG(INFO) << "block is underloaded";
|
||||
}
|
||||
} else if (cl >= block::ParamLimits::cl_soft) {
|
||||
overload_history_ |= 1;
|
||||
LOG(INFO) << "block is overloaded (category " << cl << ")";
|
||||
|
|
|
|||
|
|
@ -39,8 +39,9 @@ namespace ton {
|
|||
|
||||
namespace validator {
|
||||
|
||||
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_) {
|
||||
return td::actor::create_actor<RootDb>("db", manager, db_root_);
|
||||
td::actor::ActorOwn<Db> create_db_actor(td::actor::ActorId<ValidatorManager> manager, std::string db_root_,
|
||||
td::Ref<ValidatorManagerOptions> opts) {
|
||||
return td::actor::create_actor<RootDb>("db", manager, db_root_, opts);
|
||||
}
|
||||
|
||||
td::actor::ActorOwn<LiteServerCache> create_liteserver_cache_actor(td::actor::ActorId<ValidatorManager> manager,
|
||||
|
|
|
|||
|
|
@ -901,7 +901,7 @@ void ValidatorManagerImpl::send_top_shard_block_description(td::Ref<ShardTopBloc
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::start_up() {
|
||||
db_ = create_db_actor(actor_id(this), db_root_);
|
||||
db_ = create_db_actor(actor_id(this), db_root_, opts_);
|
||||
|
||||
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<ValidatorManagerInitResult> R) {
|
||||
R.ensure();
|
||||
|
|
|
|||
|
|
@ -549,7 +549,7 @@ void ValidatorManagerImpl::register_block_handle(BlockHandle handle, td::Promise
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::start_up() {
|
||||
db_ = create_db_actor(actor_id(this), db_root_);
|
||||
db_ = create_db_actor(actor_id(this), db_root_, opts_);
|
||||
}
|
||||
|
||||
void ValidatorManagerImpl::try_get_static_file(FileHash file_hash, td::Promise<td::BufferSlice> promise) {
|
||||
|
|
|
|||
|
|
@ -585,6 +585,12 @@ void ValidatorManagerImpl::run_ext_query(td::BufferSlice data, td::Promise<td::B
|
|||
|
||||
void ValidatorManagerImpl::wait_block_state(BlockHandle handle, td::uint32 priority, td::Timestamp timeout,
|
||||
td::Promise<td::Ref<ShardState>> promise) {
|
||||
auto it0 = block_state_cache_.find(handle->id());
|
||||
if (it0 != block_state_cache_.end()) {
|
||||
it0->second.ttl_ = td::Timestamp::in(30.0);
|
||||
promise.set_result(it0->second.state_);
|
||||
return;
|
||||
}
|
||||
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) {
|
||||
|
|
@ -988,6 +994,9 @@ void ValidatorManagerImpl::get_block_by_seqno_from_db(AccountIdPrefixFull accoun
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::finished_wait_state(BlockHandle handle, td::Result<td::Ref<ShardState>> R) {
|
||||
if (R.is_ok()) {
|
||||
block_state_cache_[handle->id()] = {R.ok(), td::Timestamp::in(30.0)};
|
||||
}
|
||||
auto it = wait_state_.find(handle->id());
|
||||
if (it != wait_state_.end()) {
|
||||
if (R.is_error()) {
|
||||
|
|
@ -1441,7 +1450,7 @@ void ValidatorManagerImpl::send_block_broadcast(BlockBroadcast broadcast) {
|
|||
}
|
||||
|
||||
void ValidatorManagerImpl::start_up() {
|
||||
db_ = create_db_actor(actor_id(this), db_root_);
|
||||
db_ = create_db_actor(actor_id(this), db_root_, opts_);
|
||||
lite_server_cache_ = create_liteserver_cache_actor(actor_id(this), db_root_);
|
||||
token_manager_ = td::actor::create_actor<TokenManager>("tokenmanager");
|
||||
td::mkdir(db_root_ + "/tmp/").ensure();
|
||||
|
|
@ -2373,6 +2382,31 @@ void ValidatorManagerImpl::alarm() {
|
|||
for (auto &w : shard_client_waiters_) {
|
||||
w.second.check_timers();
|
||||
}
|
||||
for (auto it = block_state_cache_.begin(); it != block_state_cache_.end();) {
|
||||
bool del = it->second.ttl_.is_in_past();
|
||||
if (del) {
|
||||
auto block_id = it->first;
|
||||
if (block_id.is_masterchain()) {
|
||||
if (block_id.seqno() == last_masterchain_seqno_) {
|
||||
it->second.ttl_ = td::Timestamp::in(30.0);
|
||||
del = false;
|
||||
}
|
||||
} else if (last_masterchain_state_.not_null()) {
|
||||
auto shard = last_masterchain_state_->get_shard_from_config(block_id.shard_full());
|
||||
if (shard.not_null()) {
|
||||
if (block_id.seqno() == shard->top_block_id().seqno()) {
|
||||
it->second.ttl_ = td::Timestamp::in(30.0);
|
||||
del = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (del) {
|
||||
it = block_state_cache_.erase(it);
|
||||
} else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
}
|
||||
alarm_timestamp().relax(check_waiters_at_);
|
||||
if (check_shard_clients_.is_in_past()) {
|
||||
|
|
|
|||
|
|
@ -183,6 +183,12 @@ class ValidatorManagerImpl : public ValidatorManager {
|
|||
std::map<BlockIdExt, WaitList<WaitBlockState, td::Ref<ShardState>>> wait_state_;
|
||||
std::map<BlockIdExt, WaitList<WaitBlockData, td::Ref<BlockData>>> wait_block_data_;
|
||||
|
||||
struct CachedBlockState {
|
||||
td::Ref<ShardState> state_;
|
||||
td::Timestamp ttl_;
|
||||
};
|
||||
std::map<BlockIdExt, CachedBlockState> block_state_cache_;
|
||||
|
||||
struct WaitBlockHandle {
|
||||
std::vector<td::Promise<BlockHandle>> waiting_;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -114,6 +114,9 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
|
|||
std::string get_session_logs_file() const override {
|
||||
return session_logs_file_;
|
||||
}
|
||||
td::uint32 get_celldb_compress_depth() const override {
|
||||
return celldb_compress_depth_;
|
||||
}
|
||||
|
||||
void set_zero_block_id(BlockIdExt block_id) override {
|
||||
zero_block_id_ = block_id;
|
||||
|
|
@ -167,6 +170,9 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
|
|||
void set_session_logs_file(std::string f) override {
|
||||
session_logs_file_ = std::move(f);
|
||||
}
|
||||
void set_celldb_compress_depth(td::uint32 value) override {
|
||||
celldb_compress_depth_ = value;
|
||||
}
|
||||
|
||||
ValidatorManagerOptionsImpl *make_copy() const override {
|
||||
return new ValidatorManagerOptionsImpl(*this);
|
||||
|
|
@ -209,6 +215,7 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
|
|||
BlockSeqno truncate_{0};
|
||||
BlockSeqno sync_upto_{0};
|
||||
std::string session_logs_file_;
|
||||
td::uint32 celldb_compress_depth_{0};
|
||||
};
|
||||
|
||||
} // namespace validator
|
||||
|
|
|
|||
|
|
@ -81,6 +81,7 @@ struct ValidatorManagerOptions : public td::CntObject {
|
|||
virtual BlockSeqno get_truncate_seqno() const = 0;
|
||||
virtual BlockSeqno sync_upto() const = 0;
|
||||
virtual std::string get_session_logs_file() const = 0;
|
||||
virtual td::uint32 get_celldb_compress_depth() const = 0;
|
||||
|
||||
virtual void set_zero_block_id(BlockIdExt block_id) = 0;
|
||||
virtual void set_init_block_id(BlockIdExt block_id) = 0;
|
||||
|
|
@ -100,6 +101,7 @@ struct ValidatorManagerOptions : public td::CntObject {
|
|||
virtual void truncate_db(BlockSeqno seqno) = 0;
|
||||
virtual void set_sync_upto(BlockSeqno seqno) = 0;
|
||||
virtual void set_session_logs_file(std::string f) = 0;
|
||||
virtual void set_celldb_compress_depth(td::uint32 value) = 0;
|
||||
|
||||
static td::Ref<ValidatorManagerOptions> create(
|
||||
BlockIdExt zero_block_id, BlockIdExt init_block_id,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue