dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Cleanup

Browse source
This commit is contained in:
Piotr Wójcik 2025-04-10 12:17:23 +02:00
commit 4b32ea1e38
6 changed files with 44 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

6
nano/lib/constants.hpp
View file

@ -84,7 +84,7 @@ public:
default_rpc_port (45000),
default_ipc_port (46000),
default_websocket_port (47000),
aec_loop_interval_ms (300), // Update AEC ~3 times per second
aec_loop_interval (300ms), // Update AEC ~3 times per second
cleanup_period (default_cleanup_period),
merge_period (std::chrono::milliseconds (250)),
keepalive_period (std::chrono::seconds (15)),
@ -120,7 +120,7 @@ public:
}
else if (is_dev_network ())
{
aec_loop_interval_ms = 20;
aec_loop_interval = 20ms;
cleanup_period = std::chrono::seconds (1);
merge_period = std::chrono::milliseconds (10);
keepalive_period = std::chrono::seconds (1);
@ -147,7 +147,7 @@ public:
uint16_t default_rpc_port;
uint16_t default_ipc_port;
uint16_t default_websocket_port;
unsigned aec_loop_interval_ms;
std::chrono::milliseconds aec_loop_interval;
std::chrono::seconds cleanup_period;
std::chrono::milliseconds cleanup_period_half () const

4
nano/lib/thread_roles.cpp
View file

@ -46,8 +46,8 @@ std::string nano::thread_role::get_string (nano::thread_role::name role)
case nano::thread_role::name::ledger_notifications:
thread_role_name_string = "Ledger notif";
break;
case nano::thread_role::name::request_loop:
thread_role_name_string = "Request loop";
case nano::thread_role::name::aec_loop:
thread_role_name_string = "AEC";
break;
case nano::thread_role::name::wallet_actions:
thread_role_name_string = "Wallet actions";

2
nano/lib/thread_roles.hpp
View file

@ -20,7 +20,7 @@ enum class name
vote_rebroadcasting,
block_processing,
ledger_notifications,
request_loop,
aec_loop,
wallet_actions,
bootstrap_initiator,
bootstrap_connections,

68
nano/node/active_elections.cpp
View file

@ -94,8 +94,8 @@ void nano::active_elections::start ()
debug_assert (!thread.joinable ());
thread = std::thread ([this] () {
nano::thread_role::set (nano::thread_role::name::request_loop);
request_loop ();
nano::thread_role::set (nano::thread_role::name::aec_loop);
run ();
});
}
@ -110,6 +110,27 @@ void nano::active_elections::stop ()
clear ();
}
void nano::active_elections::run ()
{
nano::unique_lock<nano::mutex> lock{ mutex };
while (!stopped)
{
auto const stamp = std::chrono::steady_clock::now ();
node.stats.inc (nano::stat::type::active, nano::stat::detail::loop);
tick_elections (lock);
debug_assert (lock.owns_lock ());
auto const min_sleep = node.network_params.network.aec_loop_interval / 2;
auto const wakeup = std::max (stamp + node.network_params.network.aec_loop_interval, std::chrono::steady_clock::now () + min_sleep);
condition.wait_until (lock, wakeup, [this, wakeup] {
return stopped || std::chrono::steady_clock::now () >= wakeup;
});
}
}
auto nano::active_elections::block_cemented (std::shared_ptr<nano::block> const & block, nano::block_hash const & confirmation_root, std::shared_ptr<nano::election> const & source_election) -> block_cemented_result
{
debug_assert (!mutex.try_lock ());
@ -245,14 +266,13 @@ int64_t nano::active_elections::vacancy (nano::election_behavior behavior) const
return std::min (election_vacancy (behavior), election_winners_vacancy ());
}
void nano::active_elections::request_confirm (nano::unique_lock<nano::mutex> & lock_a)
void nano::active_elections::tick_elections (nano::unique_lock<nano::mutex> & lock)
{
debug_assert (lock_a.owns_lock ());
debug_assert (lock.owns_lock ());
std::size_t const this_loop_target_l (roots.size ());
auto const elections_l{ list_active_impl (this_loop_target_l) };
auto const elections_l = list_active_impl ();
lock_a.unlock ();
lock.unlock ();
nano::confirmation_solicitor solicitor (node.network, node.config);
solicitor.prepare (node.rep_crawler.principal_representatives (std::numeric_limits<std::size_t>::max ()));
@ -279,7 +299,7 @@ void nano::active_elections::request_confirm (nano::unique_lock<nano::mutex> & l
}
solicitor.flush ();
lock_a.lock ();
lock.lock ();
}
void nano::active_elections::cleanup_election (nano::unique_lock<nano::mutex> & lock_a, std::shared_ptr<nano::election> election)
@ -342,20 +362,19 @@ void nano::active_elections::cleanup_election (nano::unique_lock<nano::mutex> &
}
}
std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active (std::size_t max_a)
std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active (std::size_t max_count)
{
nano::lock_guard<nano::mutex> guard{ mutex };
return list_active_impl (max_a);
return list_active_impl (max_count);
}
std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active_impl (std::size_t max_a) const
std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active_impl (std::size_t max_count) const
{
std::vector<std::shared_ptr<nano::election>> result_l;
result_l.reserve (std::min (max_a, roots.size ()));
result_l.reserve (std::min (max_count, roots.size ()));
{
auto & sorted_roots_l (roots.get<tag_sequenced> ());
std::size_t count_l{ 0 };
for (auto i = sorted_roots_l.begin (), n = sorted_roots_l.end (); i != n && count_l < max_a; ++i, ++count_l)
for (auto i = sorted_roots_l.begin (), n = sorted_roots_l.end (); i != n && result_l.size () < max_count; ++i)
{
result_l.push_back (i->election);
}
@ -363,27 +382,6 @@ std::vector<std::shared_ptr<nano::election>> nano::active_elections::list_active
return result_l;
}
void nano::active_elections::request_loop ()
{
nano::unique_lock<nano::mutex> lock{ mutex };
while (!stopped)
{
auto const stamp_l = std::chrono::steady_clock::now ();
node.stats.inc (nano::stat::type::active, nano::stat::detail::loop);
request_confirm (lock);
debug_assert (lock.owns_lock ());
if (!stopped)
{
auto const min_sleep_l = std::chrono::milliseconds (node.network_params.network.aec_loop_interval_ms / 2);
auto const wakeup_l = std::max (stamp_l + std::chrono::milliseconds (node.network_params.network.aec_loop_interval_ms), std::chrono::steady_clock::now () + min_sleep_l);
condition.wait_until (lock, wakeup_l, [&wakeup_l, &stopped = stopped] { return stopped || std::chrono::steady_clock::now () >= wakeup_l; });
}
}
}
nano::election_insertion_result nano::active_elections::insert (std::shared_ptr<nano::block> const & block_a, nano::election_behavior election_behavior_a, erased_callback_t erased_callback_a)
{
debug_assert (block_a);

7
nano/node/active_elections.hpp
View file

@ -129,8 +129,9 @@ public: // Events
nano::observer_set<> vacancy_updated;
private:
void request_loop ();
void request_confirm (nano::unique_lock<nano::mutex> &);
void run ();
void tick_elections (nano::unique_lock<nano::mutex> &);
// Erase all blocks from active and, if not confirmed, clear digests from network filters
void cleanup_election (nano::unique_lock<nano::mutex> & lock_a, std::shared_ptr<nano::election>);
@ -139,7 +140,7 @@ private:
void notify_observers (nano::secure::transaction const &, nano::election_status const & status, std::vector<nano::vote_with_weight_info> const & votes) const;
std::shared_ptr<nano::election> election_impl (nano::qualified_root const &) const;
std::vector<std::shared_ptr<nano::election>> list_active_impl (std::size_t max_count) const;
std::vector<std::shared_ptr<nano::election>> list_active_impl (std::size_t max_count = std::numeric_limits<std::size_t>::max ()) const;
private: // Dependencies
active_elections_config const & config;

2
nano/slow_test/node.cpp
View file

@ -1776,7 +1776,7 @@ TEST (node, mass_block_new)
nano::node_config node_config = system.default_config ();
node_config.backlog_scan.enable = false;
auto & node = *system.add_node (node_config);
node.network_params.network.aec_loop_interval_ms = 500;
node.network_params.network.aec_loop_interval = 500ms;
#ifndef NDEBUG
auto const num_blocks = 5000;