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

Block processor cleanup (#4165)

Browse source 
* Removing unused function.
* Removing duplicate functionality in block_processor::add_local.
* Removing usages of unchecked_info in block_processor.
This commit is contained in:
clemahieu 2023-03-02 11:33:28 +00:00 • committed by GitHub
commit 97abf643c8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 28 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

11
nano/nano_node/entry.cpp
View file

@ -1793,7 +1793,7 @@ int main (int argc, char * const * argv)
auto begin (std::chrono::high_resolution_clock::now ()); auto begin (std::chrono::high_resolution_clock::now ());
uint64_t block_count (0); uint64_t block_count (0);
size_t count (0); size_t count (0);
std::deque<nano::unchecked_info> epoch_open_blocks; std::deque<std::shared_ptr<nano::block>> epoch_open_blocks;
{ {
auto node_flags = nano::inactive_node_flag_defaults (); auto node_flags = nano::inactive_node_flag_defaults ();
nano::update_flags (node_flags, vm); nano::update_flags (node_flags, vm);
@ -1819,12 +1819,11 @@ int main (int argc, char * const * argv)
{ {
std::cout << boost::str (boost::format ("%1% blocks retrieved") % count) << std::endl; std::cout << boost::str (boost::format ("%1% blocks retrieved") % count) << std::endl;
} }
nano::unchecked_info unchecked_info (block); node.node->block_processor.add (block);
node.node->block_processor.add (unchecked_info);
if (block->type () == nano::block_type::state && block->previous ().is_zero () && source_node->ledger.is_epoch_link (block->link ())) if (block->type () == nano::block_type::state && block->previous ().is_zero () && source_node->ledger.is_epoch_link (block->link ()))
{ {
// Epoch open blocks can be rejected without processed pending blocks to account, push it later again // Epoch open blocks can be rejected without processed pending blocks to account, push it later again
epoch_open_blocks.push_back (unchecked_info); epoch_open_blocks.push_back (block);
} }
// Retrieving previous block hash // Retrieving previous block hash
hash = block->previous (); hash = block->previous ();
@ -1839,9 +1838,9 @@ int main (int argc, char * const * argv)
// Add epoch open blocks again if required // Add epoch open blocks again if required
if (node.node->block_processor.size () == 0) if (node.node->block_processor.size () == 0)
{ {
for (auto & unchecked_info : epoch_open_blocks) for (auto & block : epoch_open_blocks)
{ {
node.node->block_processor.add (unchecked_info); node.node->block_processor.add (block);
} }
} }
// Message each 60 seconds // Message each 60 seconds

74
nano/node/blockprocessor.cpp
View file

@ -89,27 +89,18 @@ bool nano::block_processor::half_full ()
return size () >= node.flags.block_processor_full_size / 2; return size () >= node.flags.block_processor_full_size / 2;
} }
void nano::block_processor::add (std::shared_ptr<nano::block> const & block_a) void nano::block_processor::add (std::shared_ptr<nano::block> const & block)
{
nano::unchecked_info info (block_a);
add (info);
}
void nano::block_processor::add (nano::unchecked_info const & info_a)
{ {
if (full ()) if (full ())
{ {
node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::overfill); node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::overfill);
return; return;
} }
if (node.network_params.work.validate_entry (*info_a.block)) // true => error if (node.network_params.work.validate_entry (*block)) // true => error
{ {
node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::insufficient_work); node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::insufficient_work);
return; return;
} }
auto const & block = info_a.block;
if (block->type () == nano::block_type::state || block->type () == nano::block_type::open) if (block->type () == nano::block_type::state || block->type () == nano::block_type::open)
{ {
state_block_signature_verification.add ({ block }); state_block_signature_verification.add ({ block });
@ -118,28 +109,12 @@ void nano::block_processor::add (nano::unchecked_info const & info_a)
{ {
{ {
nano::lock_guard<nano::mutex> guard{ mutex }; nano::lock_guard<nano::mutex> guard{ mutex };
blocks.emplace_back (info_a); blocks.emplace_back (block);
} }
condition.notify_all (); condition.notify_all ();
} }
} }
void nano::block_processor::add_local (nano::unchecked_info const & info_a)
{
if (full ())
{
node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::overfill);
return;
}
if (node.network_params.work.validate_entry (*info_a.block)) // true => error
{
node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::insufficient_work);
return;
}
state_block_signature_verification.add ({ info_a.block });
}
void nano::block_processor::force (std::shared_ptr<nano::block> const & block_a) void nano::block_processor::force (std::shared_ptr<nano::block> const & block_a)
{ {
{ {
@ -252,27 +227,27 @@ void nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock
{ {
node.logger.always_log (boost::str (boost::format ("%1% blocks (+ %2% state blocks) (+ %3% forced) in processing queue") % blocks.size () % state_block_signature_verification.size () % forced.size ())); node.logger.always_log (boost::str (boost::format ("%1% blocks (+ %2% state blocks) (+ %3% forced) in processing queue") % blocks.size () % state_block_signature_verification.size () % forced.size ()));
} }
nano::unchecked_info info; std::shared_ptr<nano::block> block;
nano::block_hash hash (0); nano::block_hash hash (0);
bool force (false); bool force (false);
if (forced.empty ()) if (forced.empty ())
{ {
info = blocks.front (); block = blocks.front ();
blocks.pop_front (); blocks.pop_front ();
hash = info.block->hash (); hash = block->hash ();
} }
else else
{ {
info = nano::unchecked_info (forced.front ()); block = forced.front ();
forced.pop_front (); forced.pop_front ();
hash = info.block->hash (); hash = block->hash ();
force = true; force = true;
number_of_forced_processed++; number_of_forced_processed++;
} }
lock_a.unlock (); lock_a.unlock ();
if (force) if (force)
{ {
auto successor (node.ledger.successor (transaction, info.block->qualified_root ())); auto successor = node.ledger.successor (transaction, block->qualified_root ());
if (successor != nullptr && successor->hash () != hash) if (successor != nullptr && successor->hash () != hash)
{ {
// Replace our block with the winner and roll back any dependent blocks // Replace our block with the winner and roll back any dependent blocks
@ -303,7 +278,7 @@ void nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock
} }
} }
number_of_blocks_processed++; number_of_blocks_processed++;
process_one (transaction, post_events, info, force); process_one (transaction, post_events, block, force);
lock_a.lock (); lock_a.lock ();
} }
awaiting_write = false; awaiting_write = false;
@ -343,13 +318,12 @@ void nano::block_processor::process_live (nano::transaction const & transaction_
} }
} }
nano::process_return nano::block_processor::process_one (nano::write_transaction const & transaction_a, block_post_events & events_a, nano::unchecked_info info_a, bool const forced_a, nano::block_origin const origin_a) nano::process_return nano::block_processor::process_one (nano::write_transaction const & transaction_a, block_post_events & events_a, std::shared_ptr<nano::block> block, bool const forced_a, nano::block_origin const origin_a)
{ {
nano::process_return result; nano::process_return result;
auto block (info_a.block);
auto hash (block->hash ()); auto hash (block->hash ());
result = node.ledger.process (transaction_a, *block); result = node.ledger.process (transaction_a, *block);
events_a.events.emplace_back ([this, result, block = info_a.block] (nano::transaction const & tx) { events_a.events.emplace_back ([this, result, block] (nano::transaction const & tx) {
processed.notify (tx, result, *block); processed.notify (tx, result, *block);
}); });
switch (result.code) switch (result.code)
@ -362,7 +336,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
block->serialize_json (block_string, node.config.logging.single_line_record ()); block->serialize_json (block_string, node.config.logging.single_line_record ());
node.logger.try_log (boost::str (boost::format ("Processing block %1%: %2%") % hash.to_string () % block_string)); node.logger.try_log (boost::str (boost::format ("Processing block %1%: %2%") % hash.to_string () % block_string));
} }
events_a.events.emplace_back ([this, hash, block = info_a.block, result, origin_a] (nano::transaction const & post_event_transaction_a) { events_a.events.emplace_back ([this, hash, block, result, origin_a] (nano::transaction const & post_event_transaction_a) {
process_live (post_event_transaction_a, hash, block, result, origin_a); process_live (post_event_transaction_a, hash, block, result, origin_a);
}); });
queue_unchecked (transaction_a, hash); queue_unchecked (transaction_a, hash);
@ -383,10 +357,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{ {
node.logger.try_log (boost::str (boost::format ("Gap previous for: %1%") % hash.to_string ())); node.logger.try_log (boost::str (boost::format ("Gap previous for: %1%") % hash.to_string ()));
} }
node.unchecked.put (block->previous (), block);
debug_assert (info_a.modified () != 0);
node.unchecked.put (block->previous (), info_a);
events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); });
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous);
break; break;
@ -397,10 +368,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{ {
node.logger.try_log (boost::str (boost::format ("Gap source for: %1%") % hash.to_string ())); node.logger.try_log (boost::str (boost::format ("Gap source for: %1%") % hash.to_string ()));
} }
node.unchecked.put (node.ledger.block_source (transaction_a, *block), block);
debug_assert (info_a.modified () != 0);
node.unchecked.put (node.ledger.block_source (transaction_a, *(block)), info_a);
events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); });
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source);
break; break;
@ -411,10 +379,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
{ {
node.logger.try_log (boost::str (boost::format ("Gap pending entries for epoch open: %1%") % hash.to_string ())); node.logger.try_log (boost::str (boost::format ("Gap pending entries for epoch open: %1%") % hash.to_string ()));
} }
node.unchecked.put (block->account (), block); // Specific unchecked key starting with epoch open block account public key
debug_assert (info_a.modified () != 0);
node.unchecked.put (block->account (), info_a); // Specific unchecked key starting with epoch open block account public key
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source);
break; break;
} }
@ -508,13 +473,6 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction
return result; return result;
} }
nano::process_return nano::block_processor::process_one (nano::write_transaction const & transaction_a, block_post_events & events_a, std::shared_ptr<nano::block> const & block_a)
{
nano::unchecked_info info (block_a);
auto result (process_one (transaction_a, events_a, info));
return result;
}
void nano::block_processor::queue_unchecked (nano::write_transaction const & transaction_a, nano::hash_or_account const & hash_or_account_a) void nano::block_processor::queue_unchecked (nano::write_transaction const & transaction_a, nano::hash_or_account const & hash_or_account_a)
{ {
node.unchecked.trigger (hash_or_account_a); node.unchecked.trigger (hash_or_account_a);

8
nano/node/blockprocessor.hpp
View file

@ -46,8 +46,6 @@ public:
std::size_t size (); std::size_t size ();
bool full (); bool full ();
bool half_full (); bool half_full ();
void add_local (nano::unchecked_info const & info_a);
void add (nano::unchecked_info const &);
void add (std::shared_ptr<nano::block> const &); void add (std::shared_ptr<nano::block> const &);
void force (std::shared_ptr<nano::block> const &); void force (std::shared_ptr<nano::block> const &);
void wait_write (); void wait_write ();
@ -55,8 +53,8 @@ public:
bool have_blocks_ready (); bool have_blocks_ready ();
bool have_blocks (); bool have_blocks ();
void process_blocks (); void process_blocks ();
nano::process_return process_one (nano::write_transaction const &, block_post_events &, nano::unchecked_info, bool const = false, nano::block_origin const = nano::block_origin::remote); nano::process_return process_one (nano::write_transaction const &, block_post_events &, std::shared_ptr<nano::block> block, bool const = false, nano::block_origin const = nano::block_origin::remote);
nano::process_return process_one (nano::write_transaction const &, block_post_events &, std::shared_ptr<nano::block> const &);
std::atomic<bool> flushing{ false }; std::atomic<bool> flushing{ false };
// Delay required for average network propagartion before requesting confirmation // Delay required for average network propagartion before requesting confirmation
static std::chrono::milliseconds constexpr confirmation_request_delay{ 1500 }; static std::chrono::milliseconds constexpr confirmation_request_delay{ 1500 };
@ -71,7 +69,7 @@ private:
bool active{ false }; bool active{ false };
bool awaiting_write{ false }; bool awaiting_write{ false };
std::chrono::steady_clock::time_point next_log; std::chrono::steady_clock::time_point next_log;
std::deque<nano::unchecked_info> blocks; std::deque<std::shared_ptr<nano::block>> blocks;
std::deque<std::shared_ptr<nano::block>> forced; std::deque<std::shared_ptr<nano::block>> forced;
nano::condition_variable condition; nano::condition_variable condition;
nano::node & node; nano::node & node;

3
nano/node/bootstrap/bootstrap_attempt.cpp
View file

@ -113,8 +113,7 @@ bool nano::bootstrap_attempt::process_block (std::shared_ptr<nano::block> const
} }
else else
{ {
nano::unchecked_info info (block_a); node->block_processor.add (block_a);
node->block_processor.add (info);
} }
return stop_pull; return stop_pull;
} }

3
nano/node/bootstrap/bootstrap_lazy.cpp
View file

@ -266,8 +266,7 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptr<nano::blo
} }
lazy_block_state_backlog_check (block_a, hash); lazy_block_state_backlog_check (block_a, hash);
lock.unlock (); lock.unlock ();
nano::unchecked_info info (block_a); node->block_processor.add (block_a);
node->block_processor.add (info);
} }
// Force drop lazy bootstrap connection for long bulk_pull // Force drop lazy bootstrap connection for long bulk_pull
if (pull_blocks_processed > max_blocks) if (pull_blocks_processed > max_blocks)

4
nano/node/node.cpp
View file

@ -208,7 +208,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co
{ {
unchecked.use_memory = [this] () { return ledger.bootstrap_weight_reached (); }; unchecked.use_memory = [this] () { return ledger.bootstrap_weight_reached (); };
unchecked.satisfied = [this] (nano::unchecked_info const & info) { unchecked.satisfied = [this] (nano::unchecked_info const & info) {
this->block_processor.add (info); this->block_processor.add (info.block);
}; };
inactive_vote_cache.rep_weight_query = [this] (nano::account const & rep) { inactive_vote_cache.rep_weight_query = [this] (nano::account const & rep) {
@ -614,7 +614,7 @@ void nano::node::process_local_async (std::shared_ptr<nano::block> const & block
// Add block hash as recently arrived to trigger automatic rebroadcast and election // Add block hash as recently arrived to trigger automatic rebroadcast and election
block_arrival.add (block_a->hash ()); block_arrival.add (block_a->hash ());
// Set current time to trigger automatic rebroadcast and election // Set current time to trigger automatic rebroadcast and election
block_processor.add_local (block_a); block_processor.add (block_a);
} }
void nano::node::start () void nano::node::start ()