From 325e791d57f91e6285cbe728f102dbe61fd7686c Mon Sep 17 00:00:00 2001 From: evoskuil Date: Tue, 22 Oct 2024 17:48:33 -0400 Subject: [PATCH 01/16] Use height_t for events. --- include/bitcoin/node/impl/chasers/chaser_organize.ipp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/bitcoin/node/impl/chasers/chaser_organize.ipp b/include/bitcoin/node/impl/chasers/chaser_organize.ipp index 4f354e2e..3e13c7a1 100644 --- a/include/bitcoin/node/impl/chasers/chaser_organize.ipp +++ b/include/bitcoin/node/impl/chasers/chaser_organize.ipp @@ -195,7 +195,7 @@ void CLASS::do_organize(typename Block::cptr block, bool strong{}; uint256_t work{}; hashes tree_branch{}; - size_t branch_point{}; + height_t branch_point{}; header_links store_branch{}; if (!get_branch_work(work, branch_point, tree_branch, store_branch, header)) From 60f003cdbbe91e24b810d173321ad944bb02d9fb Mon Sep 17 00:00:00 2001 From: evoskuil Date: Tue, 22 Oct 2024 17:50:08 -0400 Subject: [PATCH 02/16] Add public chaser::stop() and make ::stopping() public. --- include/bitcoin/node/chasers/chaser.hpp | 10 ++++++---- src/chasers/chaser.cpp | 4 ++++ 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/include/bitcoin/node/chasers/chaser.hpp b/include/bitcoin/node/chasers/chaser.hpp index 6cfd9de9..18ddc7a8 100644 --- a/include/bitcoin/node/chasers/chaser.hpp +++ b/include/bitcoin/node/chasers/chaser.hpp @@ -43,6 +43,12 @@ class BCN_API chaser /// Should be called from node strand. virtual code start() NOEXCEPT = 0; + + /// Override to capture non-blocking stopping. + virtual void stopping(const code& ec) NOEXCEPT; + + /// Override to capture blocking stop. + virtual void stop() NOEXCEPT; protected: /// Abstract base class protected construct. @@ -68,10 +74,6 @@ class BCN_API chaser /// Methods. /// ----------------------------------------------------------------------- - /// Override to capture node stopping, allow full_node to invoke. - friend full_node; - virtual void stopping(const code& ec) NOEXCEPT; - /// Node threadpool is stopped and may still be joining. virtual bool closed() const NOEXCEPT; diff --git a/src/chasers/chaser.cpp b/src/chasers/chaser.cpp index bdb2f4af..7621bcb7 100644 --- a/src/chasers/chaser.cpp +++ b/src/chasers/chaser.cpp @@ -47,6 +47,10 @@ void chaser::stopping(const code&) NOEXCEPT { } +void chaser::stop() NOEXCEPT +{ +} + bool chaser::closed() const NOEXCEPT { return node_.closed(); From 4ecffd58999bf23f45e687b0d4686bfeeae7b348 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 23 Oct 2024 13:30:27 -0400 Subject: [PATCH 03/16] Enable block-fanout validation, disabled confirmability. --- .../bitcoin/node/chasers/chaser_confirm.hpp | 2 + .../bitcoin/node/chasers/chaser_validate.hpp | 26 +- src/chasers/chaser_confirm.cpp | 28 +- src/chasers/chaser_validate.cpp | 288 +++++------------- src/full_node.cpp | 40 +-- 5 files changed, 128 insertions(+), 256 deletions(-) diff --git a/include/bitcoin/node/chasers/chaser_confirm.hpp b/include/bitcoin/node/chasers/chaser_confirm.hpp index dba250ea..28c6bd46 100644 --- a/include/bitcoin/node/chasers/chaser_confirm.hpp +++ b/include/bitcoin/node/chasers/chaser_confirm.hpp @@ -40,6 +40,8 @@ class BCN_API chaser_confirm chaser_confirm(full_node& node) NOEXCEPT; code start() NOEXCEPT override; + void stopping(const code& ec) NOEXCEPT override; + void stop() NOEXCEPT override; protected: using header_links = std_vector; diff --git a/include/bitcoin/node/chasers/chaser_validate.hpp b/include/bitcoin/node/chasers/chaser_validate.hpp index c34f3b61..5b60c61e 100644 --- a/include/bitcoin/node/chasers/chaser_validate.hpp +++ b/include/bitcoin/node/chasers/chaser_validate.hpp @@ -39,10 +39,8 @@ class BCN_API chaser_validate chaser_validate(full_node& node) NOEXCEPT; code start() NOEXCEPT override; - - /// Validate a populated candidate block. - virtual void validate(const system::chain::block::cptr& block, - const database::header_link& link, size_t height) NOEXCEPT; + void stopping(const code& ec) NOEXCEPT override; + void stop() NOEXCEPT override; protected: typedef network::race_unity race; @@ -50,24 +48,13 @@ class BCN_API chaser_validate virtual bool handle_event(const code& ec, chase event_, event_value value) NOEXCEPT; - virtual void do_validate(const system::chain::block::cptr& block, - database::header_link::integer link, size_t height) NOEXCEPT; - virtual void do_regressed(height_t branch_point) NOEXCEPT; virtual void do_checked(height_t height) NOEXCEPT; virtual void do_bump(height_t height) NOEXCEPT; - virtual bool enqueue_block(const database::header_link& link) NOEXCEPT; - virtual void validate_tx(const database::context& ctx, - const database::tx_link& link, const race::ptr& racer) NOEXCEPT; - virtual void handle_tx(const code& ec, const database::tx_link& tx, - const race::ptr& racer) NOEXCEPT; - virtual void handle_txs(const code& ec, const database::tx_link& tx, - const database::header_link& link, - const database::context& ctx) NOEXCEPT; - virtual void validate_block(const code& ec, - const database::header_link& link, - const database::context& ctx) NOEXCEPT; + virtual void validate_block(const database::header_link& link) NOEXCEPT; + virtual void complete_block(const code& ec, + const database::header_link& link, size_t height) NOEXCEPT; private: // neutrino @@ -79,11 +66,12 @@ class BCN_API chaser_validate // These are thread safe. const uint64_t initial_subsidy_; - const uint32_t subsidy_interval_blocks_; + const uint32_t subsidy_interval_; // These are protected by strand. network::threadpool threadpool_; system::hash_digest neutrino_{}; + size_t validation_backlog_{}; }; } // namespace node diff --git a/src/chasers/chaser_confirm.cpp b/src/chasers/chaser_confirm.cpp index 9fb4b147..aee2949d 100644 --- a/src/chasers/chaser_confirm.cpp +++ b/src/chasers/chaser_confirm.cpp @@ -38,7 +38,7 @@ BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) chaser_confirm::chaser_confirm(full_node& node) NOEXCEPT : chaser(node), - threadpool_(std::max(node.config().node.threads, 1_u32)) + threadpool_(one) { } @@ -48,11 +48,27 @@ code chaser_confirm::start() NOEXCEPT return error::success; } +void chaser_confirm::stopping(const code& ec) NOEXCEPT +{ + // Stop threadpool keep-alive, all work must self-terminate to affect join. + threadpool_.stop(); + chaser::stopping(ec); +} + +void chaser_confirm::stop() NOEXCEPT +{ + if (!threadpool_.join()) + { + BC_ASSERT_MSG(false, "failed to join threadpool"); + std::abort(); + } +} + // Protected // ---------------------------------------------------------------------------- bool chaser_confirm::handle_event(const code&, chase event_, - event_value value) NOEXCEPT + event_value) NOEXCEPT { if (closed()) return false; @@ -67,15 +83,15 @@ bool chaser_confirm::handle_event(const code&, chase event_, case chase::blocks: { // TODO: value is branch point. - BC_ASSERT(std::holds_alternative(value)); - POST(do_validated, std::get(value)); + ////BC_ASSERT(std::holds_alternative(value)); + ////POST(do_validated, std::get(value)); break; } case chase::valid: { // value is individual height. - BC_ASSERT(std::holds_alternative(value)); - POST(do_validated, std::get(value)); + ////BC_ASSERT(std::holds_alternative(value)); + ////POST(do_validated, std::get(value)); break; } case chase::stop: diff --git a/src/chasers/chaser_validate.cpp b/src/chasers/chaser_validate.cpp index 8cc86609..78cc41bb 100644 --- a/src/chasers/chaser_validate.cpp +++ b/src/chasers/chaser_validate.cpp @@ -35,16 +35,20 @@ using namespace system::neutrino; using namespace database; using namespace std::placeholders; +// TODO: update specialized fault codes, reintegrate neutrino. + // Shared pointer is required to keep the race object alive in bind closure. BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR) BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED) BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) +// High thread priority ensures download does not overflow validation backlog. chaser_validate::chaser_validate(full_node& node) NOEXCEPT : chaser(node), initial_subsidy_(node.config().bitcoin.initial_subsidy()), - subsidy_interval_blocks_(node.config().bitcoin.subsidy_interval_blocks), - threadpool_(std::max(node.config().node.threads, 1_u32)) + subsidy_interval_(node.config().bitcoin.subsidy_interval_blocks), + threadpool_(std::max(node.config().node.threads, 1_u32), + network::thread_priority::high) { } @@ -55,6 +59,22 @@ code chaser_validate::start() NOEXCEPT return error::success; } +void chaser_validate::stopping(const code& ec) NOEXCEPT +{ + // Stop threadpool keep-alive, all work must self-terminate to affect join. + threadpool_.stop(); + chaser::stopping(ec); +} + +void chaser_validate::stop() NOEXCEPT +{ + if (!threadpool_.join()) + { + BC_ASSERT_MSG(false, "failed to join threadpool"); + std::abort(); + } +} + bool chaser_validate::handle_event(const code&, chase event_, event_value value) NOEXCEPT { @@ -109,28 +129,6 @@ bool chaser_validate::handle_event(const code&, chase event_, return true; } -// validate -// ---------------------------------------------------------------------------- - -// Could also pass ctx. -void chaser_validate::validate(const chain::block::cptr& block, - const header_link& link, size_t height) NOEXCEPT -{ - if (closed()) - return; - - POST(do_validate, block, link, height); -} - -void chaser_validate::do_validate(const chain::block::cptr& block, - database::header_link::integer link, size_t height) NOEXCEPT -{ - BC_ASSERT(stranded()); - - if (block->is_valid() && link != header_link::terminal) - fire(events::block_validated, height); -} - // track downloaded in order (to validate) // ---------------------------------------------------------------------------- @@ -157,250 +155,118 @@ void chaser_validate::do_checked(height_t height) NOEXCEPT void chaser_validate::do_bump(height_t) NOEXCEPT { BC_ASSERT(stranded()); - auto& query = archive(); - - // TODO: update specialized fault codes. + const auto& query = archive(); // Validate checked blocks starting immediately after last validated. + // Bypass until next event if validation backlog is full. for (auto height = add1(position()); !closed(); ++height) { - // Precondition (associated). - // .................................................................... - - // Validation is always sequential from position, along the candidate - // index. It does not care about regressions that may be in process. const auto link = query.to_candidate(height); - - // database::error::unassociated - // database::error::block_unconfirmable - // database::error::block_confirmable - // database::error::block_valid - // database::error::unknown_state - // database::error::unvalidated const auto ec = query.get_block_state(link); + + // Wait until the gap is filled. if (ec == database::error::unassociated) - { - // Wait until the gap is filled. return; - } + // complete_block always follows and decrements. + ++validation_backlog_; + + // Causes a reorganization (should have been encountered by headers). if (ec == database::error::block_unconfirmable) { - LOGR("Unconfirmable block [" << height << "] " << ec.message()); - fire(events::block_unconfirmable, height); - notify(ec, chase::unvalid, link); + complete_block(ec, link, height); return; } + set_position(height); + if ((ec == database::error::block_valid) || (ec == database::error::block_confirmable) || is_under_checkpoint(height) || query.is_milestone(link)) { - update_position(height); - ////fire(events::validate_bypassed, height); - - // Don't confirm until validations are current. - if (is_current(link)) - notify(ec, chase::valid, height); - } - else - { - // Validation is currently bypassed in all cases. - ////// TODO: the quantity of work must be throttled. - ////// Will very rapidly pump outstanding work in asio queue. - ////if (!enqueue_block(link)) - ////{ - //// fault(error::node_validate); - //// return; - ////} - if (!query.set_block_valid(link)) - { - fault(error::set_block_valid); - return; - } - - // Retain last height in validation sequence, update neutrino. - update_position(height); - ////fire(events::block_validated, height); - - // Don't confirm until validations are current. - if (is_current(link)) - notify(ec, chase::valid, height); + complete_block(error::success, link, height); + continue; } - } -} - -// DISTRUBUTE WORK UNITS -bool chaser_validate::enqueue_block(const header_link& link) NOEXCEPT -{ - BC_ASSERT(stranded()); - const auto& query = archive(); - context ctx{}; - const auto txs = query.to_transactions(link); - if (txs.empty() || !query.get_context(ctx, link)) - return false; - - const auto racer = std::make_shared(txs.size()); - racer->start(BIND(handle_txs, _1, _2, link, ctx)); - ////fire(events::block_buffered, ctx.height); - - for (auto tx = txs.begin(); !closed() && tx != txs.end(); ++tx) + // Report backlog, should generally not exceed dowload window. + fire(events::block_buffered, validation_backlog_); boost::asio::post(threadpool_.service(), - BIND(validate_tx, ctx, *tx, racer)); - - return true; + BIND(validate_block, link)); + } } -// START WORK UNIT -void chaser_validate::validate_tx(const context& ctx, const tx_link& link, - const race::ptr& racer) NOEXCEPT +void chaser_validate::validate_block(const header_link& link) NOEXCEPT { if (closed()) - { - POST(handle_tx, network::error::service_stopped, link, racer); return; - } auto& query = archive(); - auto ec = query.get_tx_state(link, ctx); - - // These states bypass validation. - if (ec == database::error::integrity || - ec == database::error::tx_connected || - ec == database::error::tx_disconnected) + const auto block = query.get_block(link); + if (!block) { - POST(handle_tx, ec, link, racer); + POST(complete_block, database::error::integrity, link, zero); return; } - // These other states imply validation is required. - //// database::error::tx_preconnected - //// database::error::unknown_state - //// database::error::unvalidated - - const chain::context ctx_ - { - ctx.flags, // [accept & connect] - {}, // timestamp - {}, // mtp - ctx.height, // [accept] - {}, // minimum_block_version - {} // work_required - }; - - code invalid{ system::error::missing_previous_output }; - const auto tx = query.get_transaction(link); - if (!tx) + chain::context ctx{}; + if (!query.get_context(ctx, link)) { - ec = database::error::integrity; + POST(complete_block, database::error::integrity, link, zero); + return; } - else if (!query.populate(*tx)) - { - ec = query.set_tx_disconnected(link, ctx) ? invalid : - database::error::integrity; - fire(events::tx_invalidated, ctx.height); - } - else if (((invalid = tx->accept(ctx_))) || ((invalid = tx->connect(ctx_)))) + // TODO: performance test with and without self-population. + ////block->populate(); + if (!query.populate(*block)) { - ec = query.set_tx_disconnected(link, ctx) ? invalid : - database::error::integrity; + POST(complete_block, database::error::integrity, link, ctx.height); + return; + } - fire(events::tx_invalidated, ctx.height); - LOGR("Invalid tx [" << encode_hash(tx->hash(false)) << "] in block (" - << ctx.height << ") " << invalid.message()); + code ec{}; + if (((ec = block->accept(ctx, subsidy_interval_, initial_subsidy_))) || + ((ec = block->connect(ctx)))) + { + if (!query.set_block_unconfirmable(link)) + { + ec = database::error::integrity; + } } - else + else if (!query.set_block_valid(link)) { - const auto bip16 = ctx_.is_enabled(chain::flags::bip16_rule); - const auto bip141 = ctx_.is_enabled(chain::flags::bip141_rule); - const auto sigops = tx->signature_operations(bip16, bip141); - - // TODO: cache fee and sigops from validation stage. - ec = query.set_tx_connected(link, ctx, tx->fee(), sigops) ? - database::error::success : database::error::integrity; + ec = database::error::integrity; } - - POST(handle_tx, ec, link, racer); -} - -// FINISH WORK UNIT -void chaser_validate::handle_tx(const code& ec, const tx_link& tx, - const race::ptr& racer) NOEXCEPT -{ - BC_ASSERT(stranded()); - - // handle_txs will only get invoked once, with a first error code, so - // invoke fault here ensure that non-validation codes are not lost. - if (ec == database::error::integrity) - fault(error::node_validate); - - // TODO: need to sort out bypass, validity, and fault codes. - // Always allow the racer to finish, invokes handle_txs exactly once. - racer->finish(ec, tx); -} - -// SYNCHRONIZE WORK UNITS -void chaser_validate::handle_txs(const code& ec, const tx_link& tx, - const header_link& link, const context& ctx) NOEXCEPT -{ - BC_ASSERT(stranded()); - if (closed()) - return; - - if (ec) + else { - // Log tx here as it's the first failed one. - LOGR("Error validating tx [" << encode_hash(archive().get_tx_key(tx)) - << "] " << ec.message()); + fire(events::block_validated, ctx.height); } - validate_block(ec, link, ctx); + POST(complete_block, ec, link, ctx.height); } -// SUMMARIZE WORK -void chaser_validate::validate_block(const code& ec, - const header_link& link, const context& ctx) NOEXCEPT +void chaser_validate::complete_block(const code& ec, const header_link& link, + size_t height) NOEXCEPT { BC_ASSERT(stranded()); - auto& query = archive(); - - if (ec == database::error::integrity) - { - fault(error::node_validate); - return; - } + --validation_backlog_; if (ec) { - if (!query.set_block_unconfirmable(link)) + if (ec == database::error::integrity) { - fault(error::set_block_unconfirmable); + fault(ec); return; } - LOGR("Unconfirmable block [" << ctx.height << "] " << ec.message()); - notify(ec, chase::unconfirmable, link); - fire(events::block_unconfirmable, ctx.height); + LOGR("Unconfirmable block [" << height << "] " << ec.message()); + fire(events::block_unconfirmable, height); + notify(ec, chase::unvalid, link); return; } - // TODO: move fee setter to set_block_valid (transitory) and propagate to - // TODO: set_block_confirmable (final). Bypassed do not have the fee cache. - if (!query.set_block_valid(link)) - { - fault(error::set_block_valid); - return; - } - - // TODO: collect fees and sigops for block validate with no block. - - // fire event first so that log is ordered. - fire(events::block_validated, ctx.height); - notify(ec, chase::valid, ctx.height); - - LOGV("Block.txs accepted and connected: " << ctx.height); + // Trigger confirmation now that validations are current. + if (is_current(link)) + notify(ec, chase::valid, possible_wide_cast(height)); } // neutrino diff --git a/src/full_node.cpp b/src/full_node.cpp index 85b154a9..fd7b43cc 100644 --- a/src/full_node.cpp +++ b/src/full_node.cpp @@ -122,19 +122,19 @@ void full_node::do_run(const result_handler& handler) NOEXCEPT void full_node::close() NOEXCEPT { - // Block on chaser stop (including dedicated threadpool joins). - ////chaser_header_.stop(); - ////chaser_block_.stop(); - ////chaser_check_.stop(); - ////chaser_validate_.stop(); - ////chaser_confirm_.stop(); - ////chaser_transaction_.stop(); - ////chaser_template_.stop(); - ////chaser_snapshot_.stop(); - ////chaser_storage_.stop(); - // Base (p2p) invokes do_close(). p2p::close(); + + // Block on chaser stop (including dedicated threadpool joins). + chaser_header_.stop(); + chaser_block_.stop(); + chaser_check_.stop(); + chaser_validate_.stop(); + chaser_confirm_.stop(); + chaser_transaction_.stop(); + chaser_template_.stop(); + chaser_snapshot_.stop(); + chaser_storage_.stop(); } // Base (p2p) invokes do_close(). @@ -143,15 +143,15 @@ void full_node::do_close() NOEXCEPT BC_ASSERT(stranded()); // Initiate chaser stopping (including dedicated threadpools). - ////chaser_header_.stopping(network::error::service_stopped); - ////chaser_block_.stopping(network::error::service_stopped); - ////chaser_check_.stopping(network::error::service_stopped); - ////chaser_validate_.stopping(network::error::service_stopped); - ////chaser_confirm_.stopping(network::error::service_stopped); - ////chaser_transaction_.stopping(network::error::service_stopped); - ////chaser_template_.stopping(network::error::service_stopped); - ////chaser_snapshot_.stopping(network::error::service_stopped); - ////chaser_storage_.stopping(network::error::service_stopped); + chaser_header_.stopping(network::error::service_stopped); + chaser_block_.stopping(network::error::service_stopped); + chaser_check_.stopping(network::error::service_stopped); + chaser_validate_.stopping(network::error::service_stopped); + chaser_confirm_.stopping(network::error::service_stopped); + chaser_transaction_.stopping(network::error::service_stopped); + chaser_template_.stopping(network::error::service_stopped); + chaser_snapshot_.stopping(network::error::service_stopped); + chaser_storage_.stopping(network::error::service_stopped); event_subscriber_.stop(network::error::service_stopped, chase::stop, {}); p2p::do_close(); From 17410ae19290102f145cb355d26aa3f057883305 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 23 Oct 2024 13:31:20 -0400 Subject: [PATCH 04/16] Change validator backlog to use tx count and work in chunks. --- src/chasers/chaser_validate.cpp | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/src/chasers/chaser_validate.cpp b/src/chasers/chaser_validate.cpp index 78cc41bb..df812cbe 100644 --- a/src/chasers/chaser_validate.cpp +++ b/src/chasers/chaser_validate.cpp @@ -35,6 +35,15 @@ using namespace system::neutrino; using namespace database; using namespace std::placeholders; +// In this build we are evaluating an unconfigurable backlog of blocks based +// on their cumulative tx count. Value loosely approximates 100 full blocks. +// Since validation is being deferred until download is current, there is no +// material issue with starving the CPU. The backlog here is filled when the +// validator is starved, but that should consume the CPU. Splitting download, +// populate, and validate mitigates thrashing that is otherwise likely on low +// resource machines. This can be made more dynamic to optimize big machines. +constexpr auto validation_window = 5'000_size * 100_size; + // TODO: update specialized fault codes, reintegrate neutrino. // Shared pointer is required to keep the race object alive in bind closure. @@ -42,7 +51,6 @@ BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR) BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED) BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) -// High thread priority ensures download does not overflow validation backlog. chaser_validate::chaser_validate(full_node& node) NOEXCEPT : chaser(node), initial_subsidy_(node.config().bitcoin.initial_subsidy()), @@ -159,17 +167,20 @@ void chaser_validate::do_bump(height_t) NOEXCEPT // Validate checked blocks starting immediately after last validated. // Bypass until next event if validation backlog is full. - for (auto height = add1(position()); !closed(); ++height) + for (auto height = add1(position()); + (validation_backlog_ < validation_window) && !closed(); ++height) { const auto link = query.to_candidate(height); const auto ec = query.get_block_state(link); - // Wait until the gap is filled. - if (ec == database::error::unassociated) + // TODO: make currency requirement more flexible/configurable. + // TODO: machines with high/fast RAM/SSD can handle much more. + // Wait until the gap is filled at a current height. + if (ec == database::error::unassociated || !is_current(link)) return; // complete_block always follows and decrements. - ++validation_backlog_; + validation_backlog_ += query.get_tx_count(link); // Causes a reorganization (should have been encountered by headers). if (ec == database::error::block_unconfirmable) @@ -248,7 +259,9 @@ void chaser_validate::complete_block(const code& ec, const header_link& link, size_t height) NOEXCEPT { BC_ASSERT(stranded()); - --validation_backlog_; + + // Probably cheaper to requery this than to pass it. + validation_backlog_ -= archive().get_tx_count(link); if (ec) { @@ -267,6 +280,10 @@ void chaser_validate::complete_block(const code& ec, const header_link& link, // Trigger confirmation now that validations are current. if (is_current(link)) notify(ec, chase::valid, possible_wide_cast(height)); + + // Prevent stall. + if (is_zero(validation_backlog_)) + do_bump(height_t{}); } // neutrino From 7876ff5d7ab1c41549b377e7754d8185ce497763 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Fri, 25 Oct 2024 12:24:59 -0400 Subject: [PATCH 05/16] Update and disable validation chaser. --- src/chasers/chaser_validate.cpp | 61 +++++++++++++++++---------------- 1 file changed, 31 insertions(+), 30 deletions(-) diff --git a/src/chasers/chaser_validate.cpp b/src/chasers/chaser_validate.cpp index df812cbe..1babda5e 100644 --- a/src/chasers/chaser_validate.cpp +++ b/src/chasers/chaser_validate.cpp @@ -35,14 +35,15 @@ using namespace system::neutrino; using namespace database; using namespace std::placeholders; +// TODO: dynamically manage the blocklog size to establish desired CPU usage. // In this build we are evaluating an unconfigurable backlog of blocks based -// on their cumulative tx count. Value loosely approximates 100 full blocks. +// on their cumulative tx count. Value loosely approximates 1024 full blocks. // Since validation is being deferred until download is current, there is no // material issue with starving the CPU. The backlog here is filled when the // validator is starved, but that should consume the CPU. Splitting download, // populate, and validate mitigates thrashing that is otherwise likely on low // resource machines. This can be made more dynamic to optimize big machines. -constexpr auto validation_window = 5'000_size * 100_size; +constexpr auto validation_window = 5'000_size * 1024_size; // TODO: update specialized fault codes, reintegrate neutrino. @@ -84,7 +85,7 @@ void chaser_validate::stop() NOEXCEPT } bool chaser_validate::handle_event(const code&, chase event_, - event_value value) NOEXCEPT + event_value) NOEXCEPT { if (closed()) return false; @@ -99,30 +100,30 @@ bool chaser_validate::handle_event(const code&, chase event_, { // Track downloaded. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - case chase::start: - case chase::bump: - { - POST(do_bump, height_t{}); - break; - } - case chase::checked: - { - BC_ASSERT(std::holds_alternative(value)); - POST(do_checked, std::get(value)); - break; - } - case chase::regressed: - { - BC_ASSERT(std::holds_alternative(value)); - POST(do_regressed, std::get(value)); - break; - } - case chase::disorganized: - { - BC_ASSERT(std::holds_alternative(value)); - POST(do_regressed, std::get(value)); - break; - } + ////case chase::start: + ////case chase::bump: + ////{ + //// POST(do_bump, height_t{}); + //// break; + ////} + ////case chase::checked: + ////{ + //// BC_ASSERT(std::holds_alternative(value)); + //// POST(do_checked, std::get(value)); + //// break; + ////} + ////case chase::regressed: + ////{ + //// BC_ASSERT(std::holds_alternative(value)); + //// POST(do_regressed, std::get(value)); + //// break; + ////} + ////case chase::disorganized: + ////{ + //// BC_ASSERT(std::holds_alternative(value)); + //// POST(do_regressed, std::get(value)); + //// break; + ////} // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ case chase::stop: { @@ -173,10 +174,10 @@ void chaser_validate::do_bump(height_t) NOEXCEPT const auto link = query.to_candidate(height); const auto ec = query.get_block_state(link); - // TODO: make currency requirement more flexible/configurable. - // TODO: machines with high/fast RAM/SSD can handle much more. + // TODO: Block until ungapped to current and then start at top validated. + // Wait until the gap is filled at a current height. - if (ec == database::error::unassociated || !is_current(link)) + if (ec == database::error::unassociated) return; // complete_block always follows and decrements. From 63564b97cca073c98ee256625265f65212d0ac07 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 15:41:01 -0400 Subject: [PATCH 06/16] Allow maximal work allocation. --- src/chasers/chaser_check.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/chasers/chaser_check.cpp b/src/chasers/chaser_check.cpp index 3c52fd2b..eb35bf00 100644 --- a/src/chasers/chaser_check.cpp +++ b/src/chasers/chaser_check.cpp @@ -365,14 +365,15 @@ size_t chaser_check::set_unassociated() NOEXCEPT size_t chaser_check::get_inventory_size() const NOEXCEPT { // Either condition means blocks shouldn't be getting downloaded (yet). - const auto peers = config().network.outbound_connections; + const size_t peers = config().network.outbound_connections; if (is_zero(peers) || !is_current()) return zero; const auto& query = archive(); const auto fork = query.get_fork(); - const auto window = config().node.maximum_concurrency_(); - const auto step = std::min(window, messages::max_inventory); + + const auto span = system::ceilinged_multiply(messages::max_inventory, peers); + const auto step = std::min(maximum_concurrency_, span); const auto inventory = query.get_unassociated_count_above(fork, step); return system::ceilinged_divide(inventory, peers); } From b7d1c7580b5ae4a61f7dd96a75787391316409ae Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 16:42:44 -0400 Subject: [PATCH 07/16] Comments on message suspension. --- include/bitcoin/node/impl/chasers/chaser_organize.ipp | 5 +++++ src/chasers/chaser_check.cpp | 5 +++++ src/chasers/chaser_template.cpp | 4 ++++ src/chasers/chaser_transaction.cpp | 5 +++++ 4 files changed, 19 insertions(+) diff --git a/include/bitcoin/node/impl/chasers/chaser_organize.ipp b/include/bitcoin/node/impl/chasers/chaser_organize.ipp index 3e13c7a1..790399d0 100644 --- a/include/bitcoin/node/impl/chasers/chaser_organize.ipp +++ b/include/bitcoin/node/impl/chasers/chaser_organize.ipp @@ -89,6 +89,11 @@ bool CLASS::handle_event(const code&, chase event_, event_value value) NOEXCEPT if (closed()) return false; + // TODO: allow required messages. + ////// Stop generating query during suspension. + ////if (suspended()) + //// return true; + switch (event_) { case chase::unchecked: diff --git a/src/chasers/chaser_check.cpp b/src/chasers/chaser_check.cpp index eb35bf00..c71b5d36 100644 --- a/src/chasers/chaser_check.cpp +++ b/src/chasers/chaser_check.cpp @@ -95,6 +95,11 @@ bool chaser_check::handle_event(const code&, chase event_, if (closed()) return false; + // TODO: allow required messages. + ////// Stop generating query during suspension. + ////if (suspended()) + //// return true; + switch (event_) { // Track downloaded. diff --git a/src/chasers/chaser_template.cpp b/src/chasers/chaser_template.cpp index 411c4460..3c10b3c9 100644 --- a/src/chasers/chaser_template.cpp +++ b/src/chasers/chaser_template.cpp @@ -57,6 +57,10 @@ bool chaser_template::handle_event(const code&, chase event_, if (closed()) return false; + // Stop generating query during suspension. + if (suspended()) + return true; + // TODO: also handle confirmed/unconfirmed. switch (event_) { diff --git a/src/chasers/chaser_transaction.cpp b/src/chasers/chaser_transaction.cpp index 2c4be79e..f76c0ef3 100644 --- a/src/chasers/chaser_transaction.cpp +++ b/src/chasers/chaser_transaction.cpp @@ -57,6 +57,11 @@ bool chaser_transaction::handle_event(const code&, chase event_, if (closed()) return false; + // TODO: allow required messages. + ////// Stop generating query during suspension. + ////if (suspended()) + //// return true; + switch (event_) { case chase::stop: From 99359da647bf34e1c7840e80f309a10d4c209752 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 16:41:12 -0400 Subject: [PATCH 08/16] Update snapshot to split valid and confirmable. --- .../bitcoin/node/chasers/chaser_snapshot.hpp | 11 +++- src/chasers/chaser_snapshot.cpp | 58 ++++++++++++++++--- 2 files changed, 58 insertions(+), 11 deletions(-) diff --git a/include/bitcoin/node/chasers/chaser_snapshot.hpp b/include/bitcoin/node/chasers/chaser_snapshot.hpp index 0672491a..466de1da 100644 --- a/include/bitcoin/node/chasers/chaser_snapshot.hpp +++ b/include/bitcoin/node/chasers/chaser_snapshot.hpp @@ -40,26 +40,31 @@ class BCN_API chaser_snapshot code start() NOEXCEPT override; protected: - virtual void do_confirm(height_t height) NOEXCEPT; virtual void do_archive(height_t height) NOEXCEPT; + virtual void do_valid(height_t height) NOEXCEPT; + virtual void do_confirm(height_t height) NOEXCEPT; virtual bool handle_event(const code& ec, chase event_, event_value value) NOEXCEPT; private: bool update_bytes() NOEXCEPT; bool update_valid(height_t height) NOEXCEPT; + bool update_confirm(height_t height) NOEXCEPT; void do_snapshot(height_t height) NOEXCEPT; // These are thread safe. const size_t top_checkpoint_; - const size_t snapshot_valid_; const uint64_t snapshot_bytes_; - const bool enabled_valid_; + const size_t snapshot_valid_; + const size_t snapshot_confirm_; const bool enabled_bytes_; + const bool enabled_valid_; + const bool enabled_confirm_; // These are protected by strand. uint64_t bytes_{}; size_t valid_{}; + size_t confirm_{}; }; } // namespace node diff --git a/src/chasers/chaser_snapshot.cpp b/src/chasers/chaser_snapshot.cpp index 938b3700..72cb81b8 100644 --- a/src/chasers/chaser_snapshot.cpp +++ b/src/chasers/chaser_snapshot.cpp @@ -37,10 +37,12 @@ BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) chaser_snapshot::chaser_snapshot(full_node& node) NOEXCEPT : chaser(node), top_checkpoint_(node.config().bitcoin.top_checkpoint().height()), - snapshot_valid_(node.config().node.snapshot_valid), snapshot_bytes_(node.config().node.snapshot_bytes), + snapshot_valid_(node.config().node.snapshot_valid), + snapshot_confirm_(node.config().node.snapshot_confirm), + enabled_bytes_(to_bool(snapshot_bytes_)), enabled_valid_(to_bool(snapshot_valid_)), - enabled_bytes_(to_bool(snapshot_bytes_)) + enabled_confirm_(to_bool(snapshot_confirm_)) { } @@ -50,12 +52,17 @@ chaser_snapshot::chaser_snapshot(full_node& node) NOEXCEPT code chaser_snapshot::start() NOEXCEPT { // Initial values assume all stops or starts are snapped. + // get_top_validated is an expensive scan. if (enabled_bytes_) bytes_ = archive().store_body_size(); if (enabled_valid_) valid_ = std::max(archive().get_top_confirmed(), top_checkpoint_); + ////valid_ = std::max(archive().get_top_validated(), top_checkpoint_); + + if (enabled_confirm_) + confirm_ = std::max(archive().get_top_confirmed(), top_checkpoint_); if (enabled_bytes_ || enabled_valid_) { @@ -74,24 +81,37 @@ bool chaser_snapshot::handle_event(const code& ec, chase event_, if (closed()) return false; + // Stop generating query during suspension. + if (suspended()) + return true; + switch (event_) { + // blocks first and headers first (checked) messages case chase::blocks: case chase::checked: { - if (!enabled_bytes_ || ec) break; + if (!enabled_bytes_ || ec) + break; - // Checked blocks are out of order, so this is probalistic. BC_ASSERT(std::holds_alternative(value)); POST(do_archive, std::get(value)); break; } + case chase::valid: + { + if (!enabled_valid_ || ec) + break; + + BC_ASSERT(std::holds_alternative(value)); + POST(do_valid, std::get(value)); + break; + } case chase::confirmable: { - // Skip bypassed confirmable events as they are close to archive. - if (!enabled_valid_ || ec) break; + if (!enabled_confirm_ || ec) + break; - // Confirmable covers all validation except set_confirmed (link). BC_ASSERT(std::holds_alternative(value)); POST(do_confirm, std::get(value)); break; @@ -118,12 +138,23 @@ void chaser_snapshot::do_archive(size_t height) NOEXCEPT LOGN("Snapshot at archived height [" << height << "] is started."); do_snapshot(height); } + +void chaser_snapshot::do_valid(size_t height) NOEXCEPT +{ + BC_ASSERT(stranded()); + + if (closed() || !update_valid(height)) + return; + + LOGN("Snapshot at validated height [" << height << "] is started."); + do_snapshot(height); +} void chaser_snapshot::do_confirm(size_t height) NOEXCEPT { BC_ASSERT(stranded()); - if (closed() || !update_valid(height)) + if (closed() || !update_confirm(height)) return; LOGN("Snapshot at confirmable height [" << height << "] is started."); @@ -169,6 +200,10 @@ void chaser_snapshot::do_snapshot(size_t height) NOEXCEPT bytes_ = query.store_body_size(); if (enabled_valid_) + valid_ = height; + ////valid_ = std::max(query.get_top_validated(), top_checkpoint_); + + if (enabled_confirm_) valid_ = std::max(query.get_top_confirmed(), top_checkpoint_); } @@ -187,6 +222,13 @@ bool chaser_snapshot::update_valid(height_t height) NOEXCEPT return growth >= snapshot_valid_; } +bool chaser_snapshot::update_confirm(height_t height) NOEXCEPT +{ + // The difference may have been negative and therefore show zero growth. + const auto growth = floored_subtract(height, valid_); + return growth >= snapshot_confirm_; +} + BC_POP_WARNING() } // namespace node From 1a8890d4e95d1f0947f12fe82d915734b1286eda Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 15:57:18 -0400 Subject: [PATCH 09/16] Add and test new validate/confirm settings. --- include/bitcoin/node/settings.hpp | 5 +++++ src/parser.cpp | 29 +++++++++++++++++++++++++++-- src/settings.cpp | 11 ++++++++--- test/settings.cpp | 13 ++++++++----- 4 files changed, 48 insertions(+), 10 deletions(-) diff --git a/include/bitcoin/node/settings.hpp b/include/bitcoin/node/settings.hpp index dcd67236..993d30fa 100644 --- a/include/bitcoin/node/settings.hpp +++ b/include/bitcoin/node/settings.hpp @@ -73,15 +73,20 @@ class BCN_API settings /// Properties. bool headers_first; + bool priority_validation; + bool concurrent_validation; + bool concurrent_confirmation; float allowed_deviation; uint16_t allocation_multiple; uint64_t snapshot_bytes; uint32_t snapshot_valid; + uint32_t snapshot_confirm; uint32_t maximum_height; uint32_t maximum_concurrency; uint16_t sample_period_seconds; uint32_t currency_window_minutes; uint32_t threads; + bool prepopulate; /// Helpers. virtual size_t maximum_height_() const NOEXCEPT; diff --git a/src/parser.cpp b/src/parser.cpp index 82013d9a..75527a3d 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -883,6 +883,26 @@ options_metadata parser::load_settings() THROWS value(&configured.node.threads), "The number of threads in the validation threadpool, defaults to 16." ) + ( + "node.prepopulate", + value(&configured.node.prepopulate), + "Populate block prevous from self before query [testing], defaults to true." + ) + ( + "node.priority_validation", + value(&configured.node.priority_validation), + "Set the validation threadpool to high priority, defaults to false." + ) + ( + "node.concurrent_validation", + value(&configured.node.concurrent_validation), + "Perform validation concurrently with download, defaults to false." + ) + ( + "node.concurrent_confirmation", + value(&configured.node.concurrent_confirmation), + "Perform confirmation concurrently with download, defaults to false." + ) ( "node.headers_first", value(&configured.node.headers_first), @@ -911,12 +931,17 @@ options_metadata parser::load_settings() THROWS ( "node.snapshot_bytes", value(&configured.node.snapshot_bytes), - "Downloaded bytes that triggers snapshot, defaults to '107374182400' (0 disables)." + "Downloaded bytes that triggers snapshot, defaults to '200000000000' (0 disables)." ) ( "node.snapshot_valid", value(&configured.node.snapshot_valid), - "Completed validations that trigger snapshot, defaults to '100000' (0 disables)." + "Completed validations that trigger snapshot, defaults to '250000' (0 disables)." + ) + ( + "node.snapshot_confirm", + value(&configured.node.snapshot_confirm), + "Completed confirmations that trigger snapshot, defaults to '500000' (0 disables)." ) ( "node.sample_period_seconds", diff --git a/src/settings.cpp b/src/settings.cpp index 67d5fee8..eb600543 100644 --- a/src/settings.cpp +++ b/src/settings.cpp @@ -76,15 +76,20 @@ namespace node { settings::settings() NOEXCEPT : headers_first{ true }, + priority_validation{ false }, + concurrent_validation{ false }, + concurrent_confirmation{ false }, allowed_deviation{ 1.5 }, allocation_multiple{ 20 }, - snapshot_bytes{ 107'374'182'400 }, - snapshot_valid{ 100'000 }, + snapshot_bytes{ 200'000'000'000 }, + snapshot_valid{ 250'000 }, + snapshot_confirm{ 500'000 }, maximum_height{ 0 }, maximum_concurrency{ 50'000 }, sample_period_seconds{ 10 }, currency_window_minutes{ 60 }, - threads{ 1 } + threads{ 1 }, + prepopulate{ true } { } diff --git a/test/settings.cpp b/test/settings.cpp index 2341a1c4..d89339b2 100644 --- a/test/settings.cpp +++ b/test/settings.cpp @@ -55,21 +55,24 @@ BOOST_AUTO_TEST_CASE(settings__node__default_context__expected) const node::settings node{}; BOOST_REQUIRE_EQUAL(node.headers_first, true); + BOOST_REQUIRE_EQUAL(node.priority_validation, false); + BOOST_REQUIRE_EQUAL(node.concurrent_validation, false); + BOOST_REQUIRE_EQUAL(node.concurrent_confirmation, false); BOOST_REQUIRE_EQUAL(node.allowed_deviation, 1.5); - BOOST_REQUIRE_EQUAL(node.snapshot_bytes, 107'374'182'400_u64); - BOOST_REQUIRE_EQUAL(node.snapshot_valid, 100'000_u32); BOOST_REQUIRE_EQUAL(node.maximum_height, 0_u32); BOOST_REQUIRE_EQUAL(node.allocation_multiple, 20_u16); - + BOOST_REQUIRE_EQUAL(node.snapshot_bytes, 200'000'000'000_u64); + BOOST_REQUIRE_EQUAL(node.snapshot_valid, 250'000_u32); + BOOST_REQUIRE_EQUAL(node.snapshot_confirm, 500'000_u32); BOOST_REQUIRE_EQUAL(node.maximum_height_(), max_size_t); BOOST_REQUIRE_EQUAL(node.maximum_concurrency, 50000_u32); BOOST_REQUIRE_EQUAL(node.maximum_concurrency_(), 50000_size); BOOST_REQUIRE_EQUAL(node.sample_period_seconds, 10_u16); - + BOOST_REQUIRE_EQUAL(node.threads, 1_u32); + BOOST_REQUIRE_EQUAL(node.prepopulate, true); BOOST_REQUIRE(node.sample_period() == steady_clock::duration(seconds(10))); BOOST_REQUIRE_EQUAL(node.currency_window_minutes, 60_u32); BOOST_REQUIRE(node.currency_window() == steady_clock::duration(minutes(60))); - BOOST_REQUIRE_EQUAL(node.threads, 1_u32); } BOOST_AUTO_TEST_SUITE_END() From 1451264d9b48b1c03e60bec7a17fd20f62e7b7ac Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 16:44:05 -0400 Subject: [PATCH 10/16] Incorporate new validation/confirmation settings. --- .../bitcoin/node/chasers/chaser_confirm.hpp | 4 + .../bitcoin/node/chasers/chaser_validate.hpp | 3 + src/chasers/chaser_confirm.cpp | 35 ++++-- src/chasers/chaser_validate.cpp | 115 ++++++++++-------- 4 files changed, 94 insertions(+), 63 deletions(-) diff --git a/include/bitcoin/node/chasers/chaser_confirm.hpp b/include/bitcoin/node/chasers/chaser_confirm.hpp index 28c6bd46..5bafdaa7 100644 --- a/include/bitcoin/node/chasers/chaser_confirm.hpp +++ b/include/bitcoin/node/chasers/chaser_confirm.hpp @@ -53,6 +53,7 @@ class BCN_API chaser_confirm virtual void do_validated(height_t height) NOEXCEPT; virtual void do_reorganize(size_t height) NOEXCEPT; virtual void do_organize(size_t height) NOEXCEPT; + virtual bool enqueue_block(const database::header_link& link) NOEXCEPT; virtual void confirm_tx(const database::context& ctx, const database::tx_link& link, const race::ptr& racer) NOEXCEPT; @@ -84,6 +85,9 @@ class BCN_API chaser_confirm bool get_is_strong(bool& strong, const uint256_t& fork_work, size_t fork_point) const NOEXCEPT; + // This is thread safe. + const bool concurrent_; + // These are protected by strand. network::threadpool threadpool_; header_links popped_{}; diff --git a/include/bitcoin/node/chasers/chaser_validate.hpp b/include/bitcoin/node/chasers/chaser_validate.hpp index 5b60c61e..90f6fe9f 100644 --- a/include/bitcoin/node/chasers/chaser_validate.hpp +++ b/include/bitcoin/node/chasers/chaser_validate.hpp @@ -65,6 +65,9 @@ class BCN_API chaser_validate const system::chain::block& block) NOEXCEPT; // These are thread safe. + const bool prepopulate_; + const bool concurrent_; + const size_t maximum_backlog_; const uint64_t initial_subsidy_; const uint32_t subsidy_interval_; diff --git a/src/chasers/chaser_confirm.cpp b/src/chasers/chaser_confirm.cpp index aee2949d..8017bf1a 100644 --- a/src/chasers/chaser_confirm.cpp +++ b/src/chasers/chaser_confirm.cpp @@ -36,9 +36,13 @@ using namespace std::placeholders; BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) +// threads and priority_validation currently overloading validation settings. chaser_confirm::chaser_confirm(full_node& node) NOEXCEPT : chaser(node), - threadpool_(one) + concurrent_(node.config().node.concurrent_confirmation), + threadpool_(std::max(node.config().node.threads, 1_u32), + node.config().node.priority_validation ? + network::thread_priority::high : network::thread_priority::normal) { } @@ -68,30 +72,38 @@ void chaser_confirm::stop() NOEXCEPT // ---------------------------------------------------------------------------- bool chaser_confirm::handle_event(const code&, chase event_, - event_value) NOEXCEPT + event_value value) NOEXCEPT { if (closed()) return false; - // Stop generating message/query traffic from the validation messages. + // Stop generating query during suspension. if (suspended()) return true; + // An unconfirmable block height must not land here. // These can come out of order, advance in order synchronously. switch (event_) { case chase::blocks: { // TODO: value is branch point. - ////BC_ASSERT(std::holds_alternative(value)); - ////POST(do_validated, std::get(value)); + BC_ASSERT(std::holds_alternative(value)); + POST(do_validated, std::get(value)); break; } case chase::valid: { - // value is individual height. - ////BC_ASSERT(std::holds_alternative(value)); - ////POST(do_validated, std::get(value)); + // value is validated block height. + BC_ASSERT(std::holds_alternative(value)); + + // TODO: height may be premature due to concurrent download. + const auto height = std::get(value); + if (concurrent_ /*|| is_current(archive().to_candidate(height))*/) + { + POST(do_validated, height); + } + break; } case chase::stop: @@ -110,10 +122,9 @@ bool chaser_confirm::handle_event(const code&, chase event_, // confirm // ---------------------------------------------------------------------------- // Blocks are either confirmed (blocks first) or validated/confirmed -// (headers first) at this point. An unconfirmable block may not land here. -// Candidate chain reorganizations will result in reported heights moving -// in any direction. Each is treated as independent and only one representing -// a stronger chain is considered. +// (headers first) here. Candidate chain reorganizations will result in +// reported heights moving in any direction. Each is treated as independent and +// only one representing a stronger chain is considered. // Compute relative work, set fork_ and fork_point_. void chaser_confirm::do_validated(height_t height) NOEXCEPT diff --git a/src/chasers/chaser_validate.cpp b/src/chasers/chaser_validate.cpp index 1babda5e..969bac6f 100644 --- a/src/chasers/chaser_validate.cpp +++ b/src/chasers/chaser_validate.cpp @@ -35,16 +35,6 @@ using namespace system::neutrino; using namespace database; using namespace std::placeholders; -// TODO: dynamically manage the blocklog size to establish desired CPU usage. -// In this build we are evaluating an unconfigurable backlog of blocks based -// on their cumulative tx count. Value loosely approximates 1024 full blocks. -// Since validation is being deferred until download is current, there is no -// material issue with starving the CPU. The backlog here is filled when the -// validator is starved, but that should consume the CPU. Splitting download, -// populate, and validate mitigates thrashing that is otherwise likely on low -// resource machines. This can be made more dynamic to optimize big machines. -constexpr auto validation_window = 5'000_size * 1024_size; - // TODO: update specialized fault codes, reintegrate neutrino. // Shared pointer is required to keep the race object alive in bind closure. @@ -52,12 +42,23 @@ BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR) BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED) BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) +// maximum_backlog is the limit of ASIO backlog in blocks. +// There is almost no cost the the backlog, as it's on an independent +// threadpool and contains only the header link value. It's better to avoid +// a costly query to get the tx count (for example) and allow the amount of +// actual work that is queued to vary significantly. The maximum_concurrency +// setting is overloaded for the purpose of limiting the backlog. + chaser_validate::chaser_validate(full_node& node) NOEXCEPT : chaser(node), + prepopulate_(node.config().node.prepopulate), + concurrent_(node.config().node.concurrent_validation), + maximum_backlog_(node.config().node.maximum_concurrency_()), initial_subsidy_(node.config().bitcoin.initial_subsidy()), subsidy_interval_(node.config().bitcoin.subsidy_interval_blocks), threadpool_(std::max(node.config().node.threads, 1_u32), - network::thread_priority::high) + node.config().node.priority_validation ? + network::thread_priority::high : network::thread_priority::normal) { } @@ -85,12 +86,12 @@ void chaser_validate::stop() NOEXCEPT } bool chaser_validate::handle_event(const code&, chase event_, - event_value) NOEXCEPT + event_value value) NOEXCEPT { if (closed()) return false; - // Stop generating message/query traffic from the candidate chain. + // Stop generating query during suspension. if (suspended()) return true; @@ -100,30 +101,43 @@ bool chaser_validate::handle_event(const code&, chase event_, { // Track downloaded. // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - ////case chase::start: - ////case chase::bump: - ////{ - //// POST(do_bump, height_t{}); - //// break; - ////} - ////case chase::checked: - ////{ - //// BC_ASSERT(std::holds_alternative(value)); - //// POST(do_checked, std::get(value)); - //// break; - ////} - ////case chase::regressed: - ////{ - //// BC_ASSERT(std::holds_alternative(value)); - //// POST(do_regressed, std::get(value)); - //// break; - ////} - ////case chase::disorganized: - ////{ - //// BC_ASSERT(std::holds_alternative(value)); - //// POST(do_regressed, std::get(value)); - //// break; - ////} + case chase::start: + case chase::bump: + { + // TODO: currency? + if (concurrent_ /*|| is_current(archive().to_candidate(height))*/) + { + POST(do_bump, height_t{}); + } + + break; + } + case chase::checked: + { + // value is checked block height. + BC_ASSERT(std::holds_alternative(value)); + + // TODO: height may be premature due to concurrent download. + const auto height = std::get(value); + if (concurrent_ /*|| is_current(archive().to_candidate(height))*/) + { + POST(do_checked, height); + } + + break; + } + case chase::regressed: + { + BC_ASSERT(std::holds_alternative(value)); + POST(do_regressed, std::get(value)); + break; + } + case chase::disorganized: + { + BC_ASSERT(std::holds_alternative(value)); + POST(do_regressed, std::get(value)); + break; + } // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ case chase::stop: { @@ -169,7 +183,7 @@ void chaser_validate::do_bump(height_t) NOEXCEPT // Validate checked blocks starting immediately after last validated. // Bypass until next event if validation backlog is full. for (auto height = add1(position()); - (validation_backlog_ < validation_window) && !closed(); ++height) + (validation_backlog_ < maximum_backlog_) && !closed(); ++height) { const auto link = query.to_candidate(height); const auto ec = query.get_block_state(link); @@ -180,8 +194,8 @@ void chaser_validate::do_bump(height_t) NOEXCEPT if (ec == database::error::unassociated) return; - // complete_block always follows and decrements. - validation_backlog_ += query.get_tx_count(link); + // The size of the job is not relevant to the backlog cost. + ++validation_backlog_; // Causes a reorganization (should have been encountered by headers). if (ec == database::error::block_unconfirmable) @@ -202,8 +216,7 @@ void chaser_validate::do_bump(height_t) NOEXCEPT // Report backlog, should generally not exceed dowload window. fire(events::block_buffered, validation_backlog_); - boost::asio::post(threadpool_.service(), - BIND(validate_block, link)); + boost::asio::post(threadpool_.service(), BIND(validate_block, link)); } } @@ -227,8 +240,10 @@ void chaser_validate::validate_block(const header_link& link) NOEXCEPT return; } - // TODO: performance test with and without self-population. - ////block->populate(); + // TODO: hardwire after performance evaluation with and without. + if (prepopulate_) + block->populate(); + if (!query.populate(*block)) { POST(complete_block, database::error::integrity, link, ctx.height); @@ -261,8 +276,8 @@ void chaser_validate::complete_block(const code& ec, const header_link& link, { BC_ASSERT(stranded()); - // Probably cheaper to requery this than to pass it. - validation_backlog_ -= archive().get_tx_count(link); + // The size of the job is not relevant to the backlog cost. + --validation_backlog_; if (ec) { @@ -278,13 +293,11 @@ void chaser_validate::complete_block(const code& ec, const header_link& link, return; } - // Trigger confirmation now that validations are current. - if (is_current(link)) - notify(ec, chase::valid, possible_wide_cast(height)); + notify(ec, chase::valid, possible_wide_cast(height)); - // Prevent stall. + // Prevent stall by posting internal event, avoid hitting external handlers. if (is_zero(validation_backlog_)) - do_bump(height_t{}); + handle_event(ec, chase::bump, height_t{}); } // neutrino From 82d1a75ffff3747aa6017433d1649f20a2134712 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 18:17:31 -0400 Subject: [PATCH 11/16] Disable validator events::block_buffered. --- src/chasers/chaser_validate.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/chasers/chaser_validate.cpp b/src/chasers/chaser_validate.cpp index 969bac6f..47acf8c4 100644 --- a/src/chasers/chaser_validate.cpp +++ b/src/chasers/chaser_validate.cpp @@ -215,7 +215,7 @@ void chaser_validate::do_bump(height_t) NOEXCEPT } // Report backlog, should generally not exceed dowload window. - fire(events::block_buffered, validation_backlog_); + ////fire(events::block_buffered, validation_backlog_); boost::asio::post(threadpool_.service(), BIND(validate_block, link)); } } From 264bfbd5a94a2e7a641d387a1743a70358039c77 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Wed, 30 Oct 2024 18:18:17 -0400 Subject: [PATCH 12/16] Make confirm_chaser::enqueue_block void. --- .../bitcoin/node/chasers/chaser_confirm.hpp | 2 +- src/chasers/chaser_confirm.cpp | 82 ++++++++++--------- 2 files changed, 45 insertions(+), 39 deletions(-) diff --git a/include/bitcoin/node/chasers/chaser_confirm.hpp b/include/bitcoin/node/chasers/chaser_confirm.hpp index 5bafdaa7..3dbd47fc 100644 --- a/include/bitcoin/node/chasers/chaser_confirm.hpp +++ b/include/bitcoin/node/chasers/chaser_confirm.hpp @@ -54,7 +54,7 @@ class BCN_API chaser_confirm virtual void do_reorganize(size_t height) NOEXCEPT; virtual void do_organize(size_t height) NOEXCEPT; - virtual bool enqueue_block(const database::header_link& link) NOEXCEPT; + virtual void enqueue_block(const database::header_link& link) NOEXCEPT; virtual void confirm_tx(const database::context& ctx, const database::tx_link& link, const race::ptr& racer) NOEXCEPT; virtual void handle_tx(const code& ec, const database::tx_link& tx, diff --git a/src/chasers/chaser_confirm.cpp b/src/chasers/chaser_confirm.cpp index 8017bf1a..1327db6b 100644 --- a/src/chasers/chaser_confirm.cpp +++ b/src/chasers/chaser_confirm.cpp @@ -223,30 +223,20 @@ void chaser_confirm::do_organize(size_t height) NOEXCEPT if (!bypass) { - // database::error::unassociated - // database::error::block_unconfirmable - // database::error::block_confirmable - // database::error::block_valid - // database::error::unknown_state - // database::error::unvalidated const auto ec = query.get_block_state(link); - // Previously unconfirmable block. - if (ec == database::error::block_unconfirmable) + if (ec == database::error::block_valid) { - notify(ec, chase::unconfirmable, link); - fire(events::block_unconfirmable, height); - - // Roll back previously confirmed blocks. - if (!roll_back(popped_, fork_point_, sub1(height))) - fault(error::node_roll_back); + if (!query.set_strong(link)) + { + fault(error::set_strong); + return; + } - reset(); + enqueue_block(link); return; } - - // Previously evaluated and set confirmable block. - if (ec == database::error::block_confirmable) + else if (ec == database::error::block_confirmable) { // Required of all confirmed, and before checking confirmable. // Checked blocks are set at download, cannot be unset (reorged). @@ -257,34 +247,49 @@ void chaser_confirm::do_organize(size_t height) NOEXCEPT return; } - confirmable = true; + // falls through (previously confirmable, reported as bypass) } - } + else if (ec == database::error::block_unconfirmable) + { + notify(ec, chase::unconfirmable, link); + fire(events::block_unconfirmable, height); - if (bypass || confirmable) - { - notify(error::success, chase::confirmable, height); - ////fire(events::confirm_bypassed, height); + // Roll back previously confirmed blocks. + if (!roll_back(popped_, fork_point_, sub1(height))) + fault(error::node_roll_back); - if (!set_organized(link, height)) + reset(); + return; + } + else { - fault(error::set_organized); + // With or without an error code, shouldn't be here. + // database::error::block_valid [canonical state ] + // database::error::block_confirmable [resurrected state] + // database::error::block_unconfirmable [shouldn't be here] ? + // database::error::unknown_state [shouldn't be here] + // database::error::unassociated [shouldn't be here] + // database::error::unvalidated [shouldn't be here] + fault(error::node_confirm); return; } - - POST(next_block, add1(height)); - return; } - if (!enqueue_block(link)) + notify(error::success, chase::confirmable, height); + fire(events::confirm_bypassed, height); + + if (!set_organized(link, height)) { - fault(error::node_confirm); + fault(error::set_organized); return; } + + POST(next_block, add1(height)); + return; } // DISTRUBUTE WORK UNITS -bool chaser_confirm::enqueue_block(const header_link& link) NOEXCEPT +void chaser_confirm::enqueue_block(const header_link& link) NOEXCEPT { BC_ASSERT(stranded()); const auto& query = archive(); @@ -292,31 +297,32 @@ bool chaser_confirm::enqueue_block(const header_link& link) NOEXCEPT context ctx{}; const auto txs = query.to_transactions(link); if (txs.empty() || !query.get_context(ctx, link)) - return false; + { + POST(confirm_block, database::error::integrity, link, size_t{}); + return; + } code ec{}; const auto height = ctx.height; if ((ec = query.unspent_duplicates(txs.front(), ctx))) { POST(confirm_block, ec, link, height); - return true; + return; } if (is_one(txs.size())) { POST(confirm_block, ec, link, height); - return true; + return; } const auto racer = std::make_shared(sub1(txs.size())); racer->start(BIND(handle_txs, _1, _2, link, height)); - ////fire(events::block_buffered, height); + fire(events::block_buffered, height); for (auto tx = std::next(txs.begin()); tx != txs.end(); ++tx) boost::asio::post(threadpool_.service(), BIND(confirm_tx, ctx, *tx, racer)); - - return true; } // START WORK UNIT From 8c7f56ebe1759301a3f0b6d30a77c7157c03fc59 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Thu, 31 Oct 2024 01:43:59 -0400 Subject: [PATCH 13/16] Remove dead code. --- src/chasers/chaser_confirm.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/chasers/chaser_confirm.cpp b/src/chasers/chaser_confirm.cpp index 1327db6b..2794f390 100644 --- a/src/chasers/chaser_confirm.cpp +++ b/src/chasers/chaser_confirm.cpp @@ -216,7 +216,6 @@ void chaser_confirm::do_organize(size_t height) NOEXCEPT return; auto& query = archive(); - bool confirmable = false; const auto& link = fork_.back(); const auto bypass = is_under_checkpoint(height) || query.is_milestone(link); From 56cfcaa3c4981ce3ceee8d629045ff2ea7dfbb94 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Thu, 31 Oct 2024 01:44:08 -0400 Subject: [PATCH 14/16] Comment. --- src/chasers/chaser_validate.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/chasers/chaser_validate.cpp b/src/chasers/chaser_validate.cpp index 47acf8c4..f119aa12 100644 --- a/src/chasers/chaser_validate.cpp +++ b/src/chasers/chaser_validate.cpp @@ -246,6 +246,7 @@ void chaser_validate::validate_block(const header_link& link) NOEXCEPT if (!query.populate(*block)) { + // This could instead be a case of invalid milestone. POST(complete_block, database::error::integrity, link, ctx.height); return; } From 3f906b45d85e75717ebd49a152a96d6e3dc96c5c Mon Sep 17 00:00:00 2001 From: evoskuil Date: Thu, 31 Oct 2024 01:44:21 -0400 Subject: [PATCH 15/16] Style. --- src/protocols/protocol_block_in_31800.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/protocols/protocol_block_in_31800.cpp b/src/protocols/protocol_block_in_31800.cpp index ea24b70e..1a3604b4 100644 --- a/src/protocols/protocol_block_in_31800.cpp +++ b/src/protocols/protocol_block_in_31800.cpp @@ -352,7 +352,7 @@ bool protocol_block_in_31800::handle_receive_block(const code& ec, // ........................................................................ const auto size = block->serialized_size(true); - const chain::transactions_cptr txs_ptr{ block->transactions_ptr() }; + const auto& txs_ptr = block->transactions_ptr(); // This invokes set_strong when checked. if (const auto code = query.set_code(*txs_ptr, link, size, checked)) From aef7f62c5fdc4ac00d290c5725012c3fd1882506 Mon Sep 17 00:00:00 2001 From: evoskuil Date: Thu, 31 Oct 2024 12:45:33 -0400 Subject: [PATCH 16/16] Fix vscode workspace and settings files from rebase. --- .vscode/settings.json | 6 ------ builds/vscode/node.code-workspace | 9 --------- 2 files changed, 15 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 20cdf0a7..a6763c99 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,10 +1,4 @@ { -<<<<<<< HEAD - "cmake.sourceDirectory": "/home/nixmini/Repository/Source/libbitcoin-node/builds/cmake", - "cmake.useCMakePresets": "always" -} -======= "cmake.sourceDirectory": "${workspaceFolder}/builds/cmake", "cmake.useCMakePresets": "always" } ->>>>>>> e3e1a43d (Regenerate artifacts.) diff --git a/builds/vscode/node.code-workspace b/builds/vscode/node.code-workspace index 818f3c0a..7f9d330b 100644 --- a/builds/vscode/node.code-workspace +++ b/builds/vscode/node.code-workspace @@ -1,5 +1,4 @@ { -<<<<<<< HEAD "folders": [ { "path": "../../../libbitcoin-system" @@ -13,14 +12,6 @@ { "path": "../../../libbitcoin-node" } - ], - "settings": {} -======= - "folders": [ - { - "path": "../../../libbitcoin-node" - } ], "settings": {} ->>>>>>> e3e1a43d (Regenerate artifacts.) }