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

state_block_signature_verification is currently coupled with unchecked_map by using unchecked_info in many of its function signatures. Define state_block_signature_verification::value type and convert usages of unchecked_info to this type. (#3729)

Browse source
This commit is contained in:
clemahieu 2022-02-23 22:42:38 +00:00 • committed by GitHub
commit 2a0ee9f2a8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 41 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

32
nano/node/blockprocessor.cpp
View file

@ -31,7 +31,7 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas
write_database_queue (write_database_queue_a),
state_block_signature_verification (node.checker, node.ledger.constants.epochs, node.config, node.logger, node.flags.block_processor_verification_size)
{
state_block_signature_verification.blocks_verified_callback = [this] (std::deque<nano::unchecked_info> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) {
state_block_signature_verification.blocks_verified_callback = [this] (std::deque<nano::state_block_signature_verification::value_type> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures) {
this->process_verified_state_blocks (items, verifications, hashes, blocks_signatures);
};
state_block_signature_verification.transition_inactive_callback = [this] () {
@ -105,10 +105,13 @@ void nano::block_processor::add (std::shared_ptr<nano::block> const & block_a)
void nano::block_processor::add (nano::unchecked_info const & info_a)
{
debug_assert (!node.network_params.work.validate_entry (*info_a.block));
if (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || info_a.block->type () == nano::block_type::open || !info_a.account.is_zero ()))
auto const & block = info_a.block;
auto const & account = info_a.account;
auto const & verified = info_a.verified;
debug_assert (!node.network_params.work.validate_entry (*block));
if (verified == nano::signature_verification::unknown && (block->type () == nano::block_type::state || block->type () == nano::block_type::open || !account.is_zero ()))
{
state_block_signature_verification.add (info_a);
state_block_signature_verification.add ({ block, account, verified });
}
else
{
@ -124,7 +127,7 @@ void nano::block_processor::add_local (nano::unchecked_info const & info_a)
{
release_assert (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || !info_a.account.is_zero ()));
debug_assert (!node.network_params.work.validate_entry (*info_a.block));
state_block_signature_verification.add (info_a);
state_block_signature_verification.add ({ info_a.block, info_a.account, info_a.verified });
}
void nano::block_processor::force (std::shared_ptr<nano::block> const & block_a)
@ -187,7 +190,7 @@ bool nano::block_processor::have_blocks ()
return have_blocks_ready () || state_block_signature_verification.size () != 0;
}
void nano::block_processor::process_verified_state_blocks (std::deque<nano::unchecked_info> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures)
void nano::block_processor::process_verified_state_blocks (std::deque<nano::state_block_signature_verification::value_type> & items, std::vector<int> const & verifications, std::vector<nano::block_hash> const & hashes, std::vector<nano::signature> const & blocks_signatures)
{
{
nano::unique_lock<nano::mutex> lk (mutex);
@ -195,30 +198,31 @@ void nano::block_processor::process_verified_state_blocks (std::deque<nano::unch
{
debug_assert (verifications[i] == 1 || verifications[i] == 0);
auto & item = items.front ();
if (!item.block->link ().is_zero () && node.ledger.is_epoch_link (item.block->link ()))
auto & [block, account, verified] = item;
if (!block->link ().is_zero () && node.ledger.is_epoch_link (block->link ()))
{
// Epoch blocks
if (verifications[i] == 1)
{
item.verified = nano::signature_verification::valid_epoch;
blocks.emplace_back (std::move (item));
verified = nano::signature_verification::valid_epoch;
blocks.emplace_back (block, account, verified);
}
else
{
// Possible regular state blocks with epoch link (send subtype)
item.verified = nano::signature_verification::unknown;
blocks.emplace_back (std::move (item));
verified = nano::signature_verification::unknown;
blocks.emplace_back (block, account, verified);
}
}
else if (verifications[i] == 1)
{
// Non epoch blocks
item.verified = nano::signature_verification::valid;
blocks.emplace_back (std::move (item));
verified = nano::signature_verification::valid;
blocks.emplace_back (block, account, verified);
}
else
{
requeue_invalid (hashes[i], item);
requeue_invalid (hashes[i], { block, account, verified });
}
items.pop_front ();
}

2
nano/node/blockprocessor.hpp
View file

@ -74,7 +74,7 @@ private:
void process_batch (nano::unique_lock<nano::mutex> &);
void process_live (nano::transaction const &, nano::block_hash const &, std::shared_ptr<nano::block> const &, nano::process_return const &, nano::block_origin const = nano::block_origin::remote);
void requeue_invalid (nano::block_hash const &, nano::unchecked_info const &);
void process_verified_state_blocks (std::deque<nano::unchecked_info> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &);
void process_verified_state_blocks (std::deque<nano::state_block_signature_verification::value_type> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &);
bool stopped{ false };
bool active{ false };
bool awaiting_write{ false };

30
nano/node/state_block_signature_verification.cpp
View file

@ -74,11 +74,11 @@ bool nano::state_block_signature_verification::is_active ()
return active;
}
void nano::state_block_signature_verification::add (nano::unchecked_info const & info_a)
void nano::state_block_signature_verification::add (value_type const & item)
{
{
nano::lock_guard<nano::mutex> guard (mutex);
state_blocks.emplace_back (info_a);
state_blocks.emplace_back (item);
}
condition.notify_one ();
}
@ -89,9 +89,9 @@ std::size_t nano::state_block_signature_verification::size ()
return state_blocks.size ();
}
std::deque<nano::unchecked_info> nano::state_block_signature_verification::setup_items (std::size_t max_count)
auto nano::state_block_signature_verification::setup_items (std::size_t max_count) -> std::deque<value_type>
{
std::deque<nano::unchecked_info> items;
std::deque<value_type> items;
if (state_blocks.size () <= max_count)
{
items.swap (state_blocks);
@ -108,7 +108,7 @@ std::deque<nano::unchecked_info> nano::state_block_signature_verification::setup
return items;
}
void nano::state_block_signature_verification::verify_state_blocks (std::deque<nano::unchecked_info> & items)
void nano::state_block_signature_verification::verify_state_blocks (std::deque<value_type> & items)
{
if (!items.empty ())
{
@ -131,23 +131,23 @@ void nano::state_block_signature_verification::verify_state_blocks (std::deque<n
signatures.reserve (size);
std::vector<int> verifications;
verifications.resize (size, 0);
for (auto & item : items)
for (auto const & [block, account, unused] : items)
{
hashes.push_back (item.block->hash ());
hashes.push_back (block->hash ());
messages.push_back (hashes.back ().bytes.data ());
lengths.push_back (sizeof (decltype (hashes)::value_type));
nano::account account (item.block->account ());
if (!item.block->link ().is_zero () && epochs.is_epoch_link (item.block->link ()))
nano::account account_l = block->account ();
if (!block->link ().is_zero () && epochs.is_epoch_link (block->link ()))
{
account = epochs.signer (epochs.epoch (item.block->link ()));
account_l = epochs.signer (epochs.epoch (block->link ()));
}
else if (!item.account.is_zero ())
else if (!account.is_zero ())
{
account = item.account;
account_l = account;
}
accounts.push_back (account);
accounts.push_back (account_l);
pub_keys.push_back (accounts.back ().bytes.data ());
blocks_signatures.push_back (item.block->block_signature ());
blocks_signatures.push_back (block->block_signature ());
signatures.push_back (blocks_signatures.back ().bytes.data ());
}
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
@ -163,6 +163,6 @@ void nano::state_block_signature_verification::verify_state_blocks (std::deque<n
std::unique_ptr<nano::container_info_component> nano::collect_container_info (state_block_signature_verification & state_block_signature_verification, std::string const & name)
{
auto composite = std::make_unique<container_info_composite> (name);
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "state_blocks", state_block_signature_verification.size (), sizeof (nano::unchecked_info) }));
composite->add_component (std::make_unique<container_info_leaf> (container_info{ "state_blocks", state_block_signature_verification.size (), sizeof (state_block_signature_verification::value_type) }));
return composite;
}

12
nano/node/state_block_signature_verification.hpp
View file

@ -17,14 +17,16 @@ class signature_checker;
class state_block_signature_verification
{
public:
using value_type = std::tuple<std::shared_ptr<nano::block>, nano::account, nano::signature_verification>;
state_block_signature_verification (nano::signature_checker &, nano::epochs &, nano::node_config &, nano::logger_mt &, uint64_t);
~state_block_signature_verification ();
void add (nano::unchecked_info const & info_a);
void add (value_type const & item);
std::size_t size ();
void stop ();
bool is_active ();
std::function<void (std::deque<nano::unchecked_info> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &)> blocks_verified_callback;
std::function<void (std::deque<value_type> &, std::vector<int> const &, std::vector<nano::block_hash> const &, std::vector<nano::signature> const &)> blocks_verified_callback;
std::function<void ()> transition_inactive_callback;
private:
@ -36,13 +38,13 @@ private:
nano::mutex mutex{ mutex_identifier (mutexes::state_block_signature_verification) };
bool stopped{ false };
bool active{ false };
std::deque<nano::unchecked_info> state_blocks;
std::deque<value_type> state_blocks;
nano::condition_variable condition;
std::thread thread;
void run (uint64_t block_processor_verification_size);
std::deque<nano::unchecked_info> setup_items (std::size_t);
void verify_state_blocks (std::deque<nano::unchecked_info> &);
std::deque<value_type> setup_items (std::size_t);
void verify_state_blocks (std::deque<value_type> &);
};
std::unique_ptr<nano::container_info_component> collect_container_info (state_block_signature_verification & state_block_signature_verification, std::string const & name);