From d5abebb83edc0ba56e7f5a70c6d691f05a572f72 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 12 Sep 2023 17:53:05 +0100 Subject: [PATCH 1/3] Start/stop schedulers within nano::scheduler::component. --- nano/node/node.cpp | 10 +++------ nano/node/scheduler/component.cpp | 35 +++++++++++++++++++++++++++--- nano/node/scheduler/component.hpp | 17 +++++++++++++-- nano/node/scheduler/hinted.hpp | 7 +++--- nano/node/scheduler/optimistic.hpp | 6 ++--- nano/node/scheduler/priority.cpp | 5 ----- nano/node/scheduler/priority.hpp | 12 +++++----- nano/rpc_test/rpc.cpp | 2 +- 8 files changed, 65 insertions(+), 29 deletions(-) diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 35d9303458..95e9971901 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -576,7 +576,7 @@ std::unique_ptr nano::collect_container_info (no composite->add_component (collect_container_info (node.confirmation_height_processor, "confirmation_height_processor")); composite->add_component (collect_container_info (node.distributed_work, "distributed_work")); composite->add_component (collect_container_info (node.aggregator, "request_aggregator")); - composite->add_component (node.scheduler.priority.collect_container_info ("priority_scheduler")); + composite->add_component (node.scheduler.collect_container_info ("scheduler")); composite->add_component (node.inactive_vote_cache.collect_container_info ("inactive_vote_cache")); composite->add_component (collect_container_info (node.generator, "vote_generator")); composite->add_component (collect_container_info (node.final_generator, "vote_generator_final")); @@ -688,10 +688,8 @@ void nano::node::start () active.start (); generator.start (); final_generator.start (); - scheduler.optimistic.start (); - scheduler.priority.start (); + scheduler.start (); backlog.start (); - scheduler.hinted.start (); bootstrap_server.start (); if (!flags.disable_ascending_bootstrap) { @@ -723,9 +721,7 @@ void nano::node::stop () block_processor.stop (); aggregator.stop (); vote_processor.stop (); - scheduler.priority.stop (); - scheduler.optimistic.stop (); - scheduler.hinted.stop (); + scheduler.stop (); active.stop (); generator.stop (); final_generator.stop (); diff --git a/nano/node/scheduler/component.cpp b/nano/node/scheduler/component.cpp index 5303f52fa8..33fa7dc1ff 100644 --- a/nano/node/scheduler/component.cpp +++ b/nano/node/scheduler/component.cpp @@ -5,11 +5,40 @@ #include nano::scheduler::component::component (nano::node & node) : + hinted_impl{ std::make_unique (nano::scheduler::hinted::config{ node.config }, node, node.inactive_vote_cache, node.active, node.online_reps, node.stats) }, optimistic_impl{ std::make_unique (node.config.optimistic_scheduler, node, node.ledger, node.active, node.network_params.network, node.stats) }, priority_impl{ std::make_unique (node, node.stats) }, - hinted_impl{ std::make_unique (nano::scheduler::hinted::config{ node.config }, node, node.inactive_vote_cache, node.active, node.online_reps, node.stats) }, - priority{ *priority_impl }, hinted{ *hinted_impl }, - optimistic{ *optimistic_impl } + optimistic{ *optimistic_impl }, + priority{ *priority_impl } +{ +} + +nano::scheduler::component::~component () +{ +} + +void nano::scheduler::component::start () { + hinted.start (); + optimistic.start (); + priority.start (); +} + +void nano::scheduler::component::stop () +{ + hinted.stop (); + optimistic.stop (); + priority.stop (); +} + +std::unique_ptr nano::scheduler::component::collect_container_info (std::string const & name) +{ + nano::unique_lock lock{ mutex }; + + auto composite = std::make_unique (name); + //composite->add_component (hinted.collect_container_info ("hinted")); + //composite->add_component (optimistic.collect_container_info ("optimistic")); + composite->add_component (priority.collect_container_info ("priority")); + return composite; } diff --git a/nano/node/scheduler/component.hpp b/nano/node/scheduler/component.hpp index 0af9b41c1c..7768fba36c 100644 --- a/nano/node/scheduler/component.hpp +++ b/nano/node/scheduler/component.hpp @@ -1,9 +1,13 @@ #pragma once +#include + #include +#include namespace nano { +class container_info_component; class node; } namespace nano::scheduler @@ -14,15 +18,24 @@ class priority; class component { + std::unique_ptr hinted_impl; std::unique_ptr optimistic_impl; std::unique_ptr priority_impl; - std::unique_ptr hinted_impl; + nano::mutex mutex; public: explicit component (nano::node & node); + ~component (); + + // Starts all schedulers + void start (); + // Stops all schedulers + void stop (); + + std::unique_ptr collect_container_info (std::string const & name); - nano::scheduler::priority & priority; nano::scheduler::hinted & hinted; nano::scheduler::optimistic & optimistic; + nano::scheduler::priority & priority; }; } diff --git a/nano/node/scheduler/hinted.hpp b/nano/node/scheduler/hinted.hpp index a35b6588e6..ba344095d2 100644 --- a/nano/node/scheduler/hinted.hpp +++ b/nano/node/scheduler/hinted.hpp @@ -22,6 +22,10 @@ namespace nano::scheduler */ class hinted final { + friend class component; + void start (); + void stop (); + public: // Config struct config final { @@ -34,9 +38,6 @@ class hinted final hinted (config const &, nano::node &, nano::vote_cache &, nano::active_transactions &, nano::online_reps &, nano::stats &); ~hinted (); - void start (); - void stop (); - /* * Notify about changes in AEC vacancy */ diff --git a/nano/node/scheduler/optimistic.hpp b/nano/node/scheduler/optimistic.hpp index 2cc802ea43..3c16c72059 100644 --- a/nano/node/scheduler/optimistic.hpp +++ b/nano/node/scheduler/optimistic.hpp @@ -46,15 +46,15 @@ class optimistic_config final }; class optimistic final { + friend class component; + void start (); + void stop (); struct entry; public: optimistic (optimistic_config const &, nano::node &, nano::ledger &, nano::active_transactions &, nano::network_constants const & network_constants, nano::stats &); ~optimistic (); - void start (); - void stop (); - /** * Called from backlog population to process accounts with unconfirmed blocks */ diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index 0ee92f4643..c8e9e0f2dc 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -93,11 +93,6 @@ bool nano::scheduler::priority::empty () const return empty_locked (); } -std::size_t nano::scheduler::priority::priority_queue_size () const -{ - return buckets->size (); -} - bool nano::scheduler::priority::priority_queue_predicate () const { return node.active.vacancy () > 0 && !buckets->empty (); diff --git a/nano/node/scheduler/priority.hpp b/nano/node/scheduler/priority.hpp index 1358286713..b798f7a400 100644 --- a/nano/node/scheduler/priority.hpp +++ b/nano/node/scheduler/priority.hpp @@ -8,11 +8,13 @@ #include #include #include +#include #include namespace nano { class block; +class container_info_component; class node; } @@ -21,13 +23,15 @@ namespace nano::scheduler class buckets; class priority final { + friend class component; + void start (); + void stop (); + std::unique_ptr collect_container_info (std::string const & name); + public: priority (nano::node &, nano::stats &); ~priority (); - void start (); - void stop (); - // Manualy start an election for a block // Call action with confirmed block, may be different than what we started with void manual (std::shared_ptr const &, boost::optional const & = boost::none, nano::election_behavior = nano::election_behavior::normal); @@ -39,8 +43,6 @@ class priority final void notify (); std::size_t size () const; bool empty () const; - std::size_t priority_queue_size () const; - std::unique_ptr collect_container_info (std::string const &); private: // Dependencies nano::node & node; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 3c01236e3c..8468ffb788 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -6968,5 +6968,5 @@ TEST (node, election_scheduler_container_info) request.put ("action", "stats"); request.put ("type", "objects"); auto response = wait_response (system, rpc_ctx, request); - auto es = response.get_child ("node").get_child ("priority_scheduler"); + auto es = response.get_child ("node").get_child ("scheduler"); } From b10ab55e69252e804b386fef33088acad31c7d03 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 12 Sep 2023 18:35:12 +0100 Subject: [PATCH 2/3] Splitting manual scheduler in to its own file. This changes the order in which elections are scheduled. Both manual and prioritized elections are scheduled in parallel. Previously, manually scheduled elections would always be started before general prioritized elections. --- nano/core_test/active_transactions.cpp | 5 +- nano/core_test/node.cpp | 5 +- nano/node/CMakeLists.txt | 2 + nano/node/node.cpp | 3 +- nano/node/scheduler/component.cpp | 6 ++ nano/node/scheduler/component.hpp | 5 +- nano/node/scheduler/manual.cpp | 94 ++++++++++++++++++++++++++ nano/node/scheduler/manual.hpp | 46 +++++++++++++ nano/node/scheduler/priority.cpp | 35 ++-------- nano/node/scheduler/priority.hpp | 7 +- nano/rpc_test/rpc.cpp | 5 +- nano/slow_test/node.cpp | 9 +-- nano/test_common/testutil.cpp | 5 +- 13 files changed, 177 insertions(+), 50 deletions(-) create mode 100644 nano/node/scheduler/manual.cpp create mode 100644 nano/node/scheduler/manual.hpp diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 9842f8bf28..066fa04eae 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -1393,11 +1394,11 @@ TEST (active_transactions, fifo) ASSERT_EQ (nano::process_result::progress, node.process (*receive2).code); // Ensure first transaction becomes active - node.scheduler.priority.manual (receive1); + node.scheduler.manual.push (receive1); ASSERT_TIMELY (5s, node.active.election (receive1->qualified_root ()) != nullptr); // Ensure second transaction becomes active - node.scheduler.priority.manual (receive2); + node.scheduler.manual.push (receive2); ASSERT_TIMELY (5s, node.active.election (receive2->qualified_root ()) != nullptr); // Ensure excess transactions get trimmed diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 7b8468bf9c..ab4408a53d 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -987,7 +988,7 @@ TEST (node, fork_open_flip) // give block open1 to node1, manually trigger an election for open1 and ensure it is in the ledger node1.process_active (open1); ASSERT_TIMELY (5s, node1.block (open1->hash ()) != nullptr); - node1.scheduler.priority.manual (open1); + node1.scheduler.manual.push (open1); ASSERT_TIMELY (5s, (election = node1.active.election (open1->qualified_root ())) != nullptr); election->transition_active (); @@ -1000,7 +1001,7 @@ TEST (node, fork_open_flip) // ensure open2 is in node2 ledger (and therefore has sideband) and manually trigger an election for open2 ASSERT_TIMELY (5s, node2.block (open2->hash ()) != nullptr); - node2.scheduler.priority.manual (open2); + node2.scheduler.manual.push (open2); ASSERT_TIMELY (5s, (election = node2.active.election (open2->qualified_root ())) != nullptr); election->transition_active (); diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index ccb4d4fe76..4e1f29cc02 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -202,6 +202,8 @@ add_library( scheduler/component.cpp scheduler/hinted.hpp scheduler/hinted.cpp + scheduler/manual.hpp + scheduler/manual.cpp scheduler/optimistic.hpp scheduler/optimistic.cpp scheduler/priority.hpp diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 95e9971901..5918036783 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -1261,7 +1262,7 @@ void nano::node::add_initial_peers () void nano::node::start_election (std::shared_ptr const & block) { - scheduler.priority.manual (block); + scheduler.manual.push (block); } bool nano::node::block_confirmed (nano::block_hash const & hash_a) diff --git a/nano/node/scheduler/component.cpp b/nano/node/scheduler/component.cpp index 33fa7dc1ff..f1462f3893 100644 --- a/nano/node/scheduler/component.cpp +++ b/nano/node/scheduler/component.cpp @@ -1,14 +1,17 @@ #include #include #include +#include #include #include nano::scheduler::component::component (nano::node & node) : hinted_impl{ std::make_unique (nano::scheduler::hinted::config{ node.config }, node, node.inactive_vote_cache, node.active, node.online_reps, node.stats) }, + manual_impl{ std::make_unique (node) }, optimistic_impl{ std::make_unique (node.config.optimistic_scheduler, node, node.ledger, node.active, node.network_params.network, node.stats) }, priority_impl{ std::make_unique (node, node.stats) }, hinted{ *hinted_impl }, + manual{ *manual_impl }, optimistic{ *optimistic_impl }, priority{ *priority_impl } { @@ -21,6 +24,7 @@ nano::scheduler::component::~component () void nano::scheduler::component::start () { hinted.start (); + manual.start (); optimistic.start (); priority.start (); } @@ -28,6 +32,7 @@ void nano::scheduler::component::start () void nano::scheduler::component::stop () { hinted.stop (); + manual.stop (); optimistic.stop (); priority.stop (); } @@ -38,6 +43,7 @@ std::unique_ptr nano::scheduler::component::coll auto composite = std::make_unique (name); //composite->add_component (hinted.collect_container_info ("hinted")); + composite->add_component (manual.collect_container_info ("manual")); //composite->add_component (optimistic.collect_container_info ("optimistic")); composite->add_component (priority.collect_container_info ("priority")); return composite; diff --git a/nano/node/scheduler/component.hpp b/nano/node/scheduler/component.hpp index 7768fba36c..257902438a 100644 --- a/nano/node/scheduler/component.hpp +++ b/nano/node/scheduler/component.hpp @@ -13,12 +13,14 @@ class node; namespace nano::scheduler { class hinted; +class manual; class optimistic; class priority; -class component +class component final { std::unique_ptr hinted_impl; + std::unique_ptr manual_impl; std::unique_ptr optimistic_impl; std::unique_ptr priority_impl; nano::mutex mutex; @@ -35,6 +37,7 @@ class component std::unique_ptr collect_container_info (std::string const & name); nano::scheduler::hinted & hinted; + nano::scheduler::manual & manual; nano::scheduler::optimistic & optimistic; nano::scheduler::priority & priority; }; diff --git a/nano/node/scheduler/manual.cpp b/nano/node/scheduler/manual.cpp new file mode 100644 index 0000000000..82ce43debb --- /dev/null +++ b/nano/node/scheduler/manual.cpp @@ -0,0 +1,94 @@ +#include +#include + +nano::scheduler::manual::manual (nano::node & node) : + node{ node } +{ +} + +nano::scheduler::manual::~manual () +{ + // Thread must be stopped before destruction + debug_assert (!thread.joinable ()); +} + +void nano::scheduler::manual::start () +{ + debug_assert (!thread.joinable ()); + + thread = std::thread{ [this] () { + nano::thread_role::set (nano::thread_role::name::election_scheduler); + run (); + } }; +} + +void nano::scheduler::manual::stop () +{ + { + nano::lock_guard lock{ mutex }; + stopped = true; + } + notify (); + nano::join_or_pass (thread); +} + +void nano::scheduler::manual::notify () +{ + condition.notify_all (); +} + +void nano::scheduler::manual::push (std::shared_ptr const & block_a, boost::optional const & previous_balance_a, nano::election_behavior election_behavior_a) +{ + nano::lock_guard lock{ mutex }; + queue.push_back (std::make_tuple (block_a, previous_balance_a, election_behavior_a)); + notify (); +} + +bool nano::scheduler::manual::predicate () const +{ + return !queue.empty (); +} + +void nano::scheduler::manual::run () +{ + nano::unique_lock lock{ mutex }; + while (!stopped) + { + condition.wait (lock, [this] () { + return stopped || predicate (); + }); + debug_assert ((std::this_thread::yield (), true)); // Introduce some random delay in debug builds + if (!stopped) + { + node.stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::loop); + + if (predicate ()) + { + auto const [block, previous_balance, election_behavior] = queue.front (); + queue.pop_front (); + lock.unlock (); + node.stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::insert_manual); + auto result = node.active.insert (block, election_behavior); + if (result.election != nullptr) + { + result.election->transition_active (); + } + } + else + { + lock.unlock (); + } + notify (); + lock.lock (); + } + } +} + +std::unique_ptr nano::scheduler::manual::collect_container_info (std::string const & name) +{ + nano::unique_lock lock{ mutex }; + + auto composite = std::make_unique (name); + composite->add_component (std::make_unique (container_info{ "queue", queue.size (), sizeof (decltype (queue)::value_type) })); + return composite; +} diff --git a/nano/node/scheduler/manual.hpp b/nano/node/scheduler/manual.hpp new file mode 100644 index 0000000000..3edfa1dc75 --- /dev/null +++ b/nano/node/scheduler/manual.hpp @@ -0,0 +1,46 @@ +#pragma once +#include +#include +#include + +#include + +#include +#include +#include + +namespace nano +{ +class block; +class node; +} + +namespace nano::scheduler +{ +class buckets; +class manual final +{ + std::deque, boost::optional, nano::election_behavior>> queue; + nano::node & node; + nano::mutex mutex; + nano::condition_variable condition; + bool stopped{ false }; + std::thread thread; + void notify (); + bool predicate () const; + void run (); + +public: + manual (nano::node & node); + ~manual (); + + void start (); + void stop (); + + // Manualy start an election for a block + // Call action with confirmed block, may be different than what we started with + void push (std::shared_ptr const &, boost::optional const & = boost::none, nano::election_behavior = nano::election_behavior::normal); + + std::unique_ptr collect_container_info (std::string const & name); +}; // class manual +} // nano::scheduler diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index c8e9e0f2dc..323a18c515 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -35,13 +35,6 @@ void nano::scheduler::priority::stop () nano::join_or_pass (thread); } -void nano::scheduler::priority::manual (std::shared_ptr const & block_a, boost::optional const & previous_balance_a, nano::election_behavior election_behavior_a) -{ - nano::lock_guard lock{ mutex }; - manual_queue.push_back (std::make_tuple (block_a, previous_balance_a, election_behavior_a)); - notify (); -} - bool nano::scheduler::priority::activate (nano::account const & account_a, nano::transaction const & transaction) { debug_assert (!account_a.is_zero ()); @@ -79,12 +72,12 @@ void nano::scheduler::priority::notify () std::size_t nano::scheduler::priority::size () const { nano::lock_guard lock{ mutex }; - return buckets->size () + manual_queue.size (); + return buckets->size (); } bool nano::scheduler::priority::empty_locked () const { - return buckets->empty () && manual_queue.empty (); + return buckets->empty (); } bool nano::scheduler::priority::empty () const @@ -93,42 +86,25 @@ bool nano::scheduler::priority::empty () const return empty_locked (); } -bool nano::scheduler::priority::priority_queue_predicate () const +bool nano::scheduler::priority::predicate () const { return node.active.vacancy () > 0 && !buckets->empty (); } -bool nano::scheduler::priority::manual_queue_predicate () const -{ - return !manual_queue.empty (); -} - void nano::scheduler::priority::run () { nano::unique_lock lock{ mutex }; while (!stopped) { condition.wait (lock, [this] () { - return stopped || priority_queue_predicate () || manual_queue_predicate (); + return stopped || predicate (); }); debug_assert ((std::this_thread::yield (), true)); // Introduce some random delay in debug builds if (!stopped) { stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::loop); - if (manual_queue_predicate ()) - { - auto const [block, previous_balance, election_behavior] = manual_queue.front (); - manual_queue.pop_front (); - lock.unlock (); - stats.inc (nano::stat::type::election_scheduler, nano::stat::detail::insert_manual); - auto result = node.active.insert (block, election_behavior); - if (result.election != nullptr) - { - result.election->transition_active (); - } - } - else if (priority_queue_predicate ()) + if (predicate ()) { auto block = buckets->top (); buckets->pop (); @@ -159,7 +135,6 @@ std::unique_ptr nano::scheduler::priority::colle nano::unique_lock lock{ mutex }; auto composite = std::make_unique (name); - composite->add_component (std::make_unique (container_info{ "manual_queue", manual_queue.size (), sizeof (decltype (manual_queue)::value_type) })); composite->add_component (buckets->collect_container_info ("buckets")); return composite; } diff --git a/nano/node/scheduler/priority.hpp b/nano/node/scheduler/priority.hpp index b798f7a400..13b32b950b 100644 --- a/nano/node/scheduler/priority.hpp +++ b/nano/node/scheduler/priority.hpp @@ -32,9 +32,6 @@ class priority final priority (nano::node &, nano::stats &); ~priority (); - // Manualy start an election for a block - // Call action with confirmed block, may be different than what we started with - void manual (std::shared_ptr const &, boost::optional const & = boost::none, nano::election_behavior = nano::election_behavior::normal); /** * Activates the first unconfirmed block of \p account_a * @return true if account was activated @@ -51,12 +48,10 @@ class priority final private: void run (); bool empty_locked () const; - bool priority_queue_predicate () const; - bool manual_queue_predicate () const; + bool predicate () const; std::unique_ptr buckets; - std::deque, boost::optional, nano::election_behavior>> manual_queue; bool stopped{ false }; nano::condition_variable condition; mutable nano::mutex mutex; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 8468ffb788..a48fe5454f 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -1556,7 +1557,7 @@ TEST (rpc, process_subtype_open) ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); auto const rpc_ctx = add_rpc (system, node1); - node1->scheduler.priority.manual (send); + node1->scheduler.manual.push (send); auto open = builder .state () .account (key.pub) @@ -1605,7 +1606,7 @@ TEST (rpc, process_subtype_receive) ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); auto const rpc_ctx = add_rpc (system, node1); - node1->scheduler.priority.manual (send); + node1->scheduler.manual.push (send); auto receive = builder .state () .account (nano::dev::genesis_key.pub) diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index c9dd6c09aa..d63b2ac154 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include @@ -677,7 +678,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) { auto block = node->block (last_open_hash); ASSERT_NE (nullptr, block); - node->scheduler.priority.manual (block); + node->scheduler.manual.push (block); std::shared_ptr election; ASSERT_TIMELY (10s, (election = node->active.election (block->qualified_root ())) != nullptr); election->force_confirm (); @@ -760,7 +761,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) // Confirm all of the accounts for (auto & open_block : open_blocks) { - node->scheduler.priority.manual (open_block); + node->scheduler.manual.push (open_block); std::shared_ptr election; ASSERT_TIMELY (10s, (election = node->active.election (open_block->qualified_root ())) != nullptr); election->force_confirm (); @@ -900,7 +901,7 @@ TEST (confirmation_height, long_chains) // Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts { - node->scheduler.priority.manual (receive1); + node->scheduler.manual.push (receive1); std::shared_ptr election; ASSERT_TIMELY (10s, (election = node->active.election (receive1->qualified_root ())) != nullptr); election->force_confirm (); @@ -2225,7 +2226,7 @@ TEST (node, wallet_create_block_confirm_conflicts) // Call block confirm on the top level send block which will confirm everything underneath on both accounts. { auto block = node->store.block.get (node->store.tx_begin_read (), latest); - node->scheduler.priority.manual (block); + node->scheduler.manual.push (block); std::shared_ptr election; ASSERT_TIMELY (10s, (election = node->active.election (block->qualified_root ())) != nullptr); election->force_confirm (); diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index f3aba3d3f4..05a6db689b 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -124,7 +125,7 @@ bool nano::test::activate (nano::node & node, std::vector hash // Block does not exist in the ledger yet return false; } - node.scheduler.priority.manual (disk_block); + node.scheduler.manual.push (disk_block); } return true; } @@ -205,7 +206,7 @@ std::shared_ptr nano::test::start_election (nano::test::system & block_l = node_a.block (hash_a); } - node_a.scheduler.priority.manual (block_l); + node_a.scheduler.manual.push (block_l); // wait for the election to appear std::shared_ptr election = node_a.active.election (block_l->qualified_root ()); From cc7b18b488751e26a0bc04564f98b0e9faf6d7c9 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Tue, 12 Sep 2023 18:40:52 +0100 Subject: [PATCH 3/3] Renaming scheduler threads to match how components are organized in the scheduler namespace --- nano/lib/thread_roles.cpp | 21 ++++++++++++--------- nano/lib/thread_roles.hpp | 9 +++++---- nano/node/scheduler/hinted.cpp | 2 +- nano/node/scheduler/manual.cpp | 2 +- nano/node/scheduler/optimistic.cpp | 2 +- nano/node/scheduler/priority.cpp | 2 +- 6 files changed, 21 insertions(+), 17 deletions(-) diff --git a/nano/lib/thread_roles.cpp b/nano/lib/thread_roles.cpp index b5198d3cd2..0824d23733 100644 --- a/nano/lib/thread_roles.cpp +++ b/nano/lib/thread_roles.cpp @@ -70,18 +70,12 @@ std::string nano::thread_role::get_string (nano::thread_role::name role) case nano::thread_role::name::db_parallel_traversal: thread_role_name_string = "DB par traversl"; break; - case nano::thread_role::name::election_scheduler: - thread_role_name_string = "Election Sched"; - break; case nano::thread_role::name::unchecked: thread_role_name_string = "Unchecked"; break; case nano::thread_role::name::backlog_population: thread_role_name_string = "Backlog"; break; - case nano::thread_role::name::election_hinting: - thread_role_name_string = "Hinting"; - break; case nano::thread_role::name::vote_generator_queue: thread_role_name_string = "Voting que"; break; @@ -94,8 +88,17 @@ std::string nano::thread_role::get_string (nano::thread_role::name role) case nano::thread_role::name::telemetry: thread_role_name_string = "Telemetry"; break; - case nano::thread_role::name::optimistic_scheduler: - thread_role_name_string = "Optimistic"; + case nano::thread_role::name::scheduler_hinted: + thread_role_name_string = "Sched Hinted"; + break; + case nano::thread_role::name::scheduler_manual: + thread_role_name_string = "Sched Manual"; + break; + case nano::thread_role::name::scheduler_optimistic: + thread_role_name_string = "Sched Opt"; + break; + case nano::thread_role::name::scheduler_priority: + thread_role_name_string = "Sched Priority"; break; default: debug_assert (false && "nano::thread_role::get_string unhandled thread role"); @@ -133,4 +136,4 @@ void nano::thread_role::set (nano::thread_role::name role) nano::thread_role::set_os_name (thread_role_name_string); current_thread_role = role; -} \ No newline at end of file +} diff --git a/nano/lib/thread_roles.hpp b/nano/lib/thread_roles.hpp index e5552fdc73..311ae58d1b 100644 --- a/nano/lib/thread_roles.hpp +++ b/nano/lib/thread_roles.hpp @@ -30,17 +30,18 @@ enum class name state_block_signature_verification, epoch_upgrader, db_parallel_traversal, - election_scheduler, unchecked, backlog_population, - election_hinting, vote_generator_queue, bootstrap_server, telemetry, - optimistic_scheduler, ascending_bootstrap, bootstrap_server_requests, bootstrap_server_responses, + scheduler_hinted, + scheduler_manual, + scheduler_optimistic, + scheduler_priority, }; /* @@ -63,4 +64,4 @@ std::string get_string (); * Internal only, should not be called directly */ void set_os_name (std::string const &); -} \ No newline at end of file +} diff --git a/nano/node/scheduler/hinted.cpp b/nano/node/scheduler/hinted.cpp index ba8ec51e10..6c5d4933bd 100644 --- a/nano/node/scheduler/hinted.cpp +++ b/nano/node/scheduler/hinted.cpp @@ -28,7 +28,7 @@ void nano::scheduler::hinted::start () debug_assert (!thread.joinable ()); thread = std::thread{ [this] () { - nano::thread_role::set (nano::thread_role::name::election_hinting); + nano::thread_role::set (nano::thread_role::name::scheduler_hinted); run (); } }; } diff --git a/nano/node/scheduler/manual.cpp b/nano/node/scheduler/manual.cpp index 82ce43debb..d409824559 100644 --- a/nano/node/scheduler/manual.cpp +++ b/nano/node/scheduler/manual.cpp @@ -17,7 +17,7 @@ void nano::scheduler::manual::start () debug_assert (!thread.joinable ()); thread = std::thread{ [this] () { - nano::thread_role::set (nano::thread_role::name::election_scheduler); + nano::thread_role::set (nano::thread_role::name::scheduler_manual); run (); } }; } diff --git a/nano/node/scheduler/optimistic.cpp b/nano/node/scheduler/optimistic.cpp index beb7d3353a..a00fa4d96c 100644 --- a/nano/node/scheduler/optimistic.cpp +++ b/nano/node/scheduler/optimistic.cpp @@ -29,7 +29,7 @@ void nano::scheduler::optimistic::start () debug_assert (!thread.joinable ()); thread = std::thread{ [this] () { - nano::thread_role::set (nano::thread_role::name::optimistic_scheduler); + nano::thread_role::set (nano::thread_role::name::scheduler_optimistic); run (); } }; } diff --git a/nano/node/scheduler/priority.cpp b/nano/node/scheduler/priority.cpp index 323a18c515..e4bd01392e 100644 --- a/nano/node/scheduler/priority.cpp +++ b/nano/node/scheduler/priority.cpp @@ -20,7 +20,7 @@ void nano::scheduler::priority::start () debug_assert (!thread.joinable ()); thread = std::thread{ [this] () { - nano::thread_role::set (nano::thread_role::name::election_scheduler); + nano::thread_role::set (nano::thread_role::name::scheduler_priority); run (); } }; }