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

Use confirmation request count instead of announcement term (#2111)

Browse source
This commit is contained in:
cryptocode 2019-07-02 22:43:50 +02:00 • committed by GitHub
commit 71c3c389b0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 25 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/core_test/node.cpp
View file

@ -207,7 +207,7 @@ TEST (node, node_receive_quorum)
std::lock_guard<std::mutex> guard (system.nodes[0]->active.mutex); std::lock_guard<std::mutex> guard (system.nodes[0]->active.mutex);
auto info (system.nodes[0]->active.roots.find (nano::qualified_root (previous, previous))); auto info (system.nodes[0]->active.roots.find (nano::qualified_root (previous, previous)));
ASSERT_NE (system.nodes[0]->active.roots.end (), info); ASSERT_NE (system.nodes[0]->active.roots.end (), info);
done = info->election->announcements > nano::active_transactions::announcement_min; done = info->election->confirmation_request_count > nano::active_transactions::minimum_confirmation_request_count;
} }
ASSERT_NO_ERROR (system.poll ()); ASSERT_NO_ERROR (system.poll ());
} }
@ -2197,7 +2197,7 @@ TEST (node, confirm_quorum)
std::lock_guard<std::mutex> guard (system.nodes[0]->active.mutex); std::lock_guard<std::mutex> guard (system.nodes[0]->active.mutex);
auto info (system.nodes[0]->active.roots.find (nano::qualified_root (send1->hash (), send1->hash ()))); auto info (system.nodes[0]->active.roots.find (nano::qualified_root (send1->hash (), send1->hash ())));
ASSERT_NE (system.nodes[0]->active.roots.end (), info); ASSERT_NE (system.nodes[0]->active.roots.end (), info);
done = info->election->announcements > nano::active_transactions::announcement_min; done = info->election->confirmation_request_count > nano::active_transactions::minimum_confirmation_request_count;
} }
ASSERT_NO_ERROR (system.poll ()); ASSERT_NO_ERROR (system.poll ());
} }

26
nano/node/active_transactions.cpp
View file

@ -98,8 +98,8 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
std::unordered_set<nano::qualified_root> inactive; std::unordered_set<nano::qualified_root> inactive;
auto transaction (node.store.tx_begin_read ()); auto transaction (node.store.tx_begin_read ());
unsigned unconfirmed_count (0); unsigned unconfirmed_count (0);
unsigned unconfirmed_announcements (0); unsigned unconfirmed_request_count (0);
unsigned could_fit_delay = node.network_params.network.is_test_network () ? announcement_long - 1 : 1; unsigned could_fit_delay = node.network_params.network.is_test_network () ? high_confirmation_request_count - 1 : 1;
std::unordered_map<std::shared_ptr<nano::transport::channel>, std::vector<std::pair<nano::block_hash, nano::block_hash>>> requests_bundle; std::unordered_map<std::shared_ptr<nano::transport::channel>, std::vector<std::pair<nano::block_hash, nano::block_hash>>> requests_bundle;
std::deque<std::shared_ptr<nano::block>> rebroadcast_bundle; std::deque<std::shared_ptr<nano::block>> rebroadcast_bundle;
std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>>>> confirm_req_bundle; std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<std::shared_ptr<nano::transport::channel>>>>> confirm_req_bundle;
@ -109,7 +109,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
{ {
auto root (i->root); auto root (i->root);
auto election_l (i->election); auto election_l (i->election);
if ((election_l->confirmed || election_l->stopped) && election_l->announcements >= announcement_min - 1) if ((election_l->confirmed || election_l->stopped) && election_l->confirmation_request_count >= minimum_confirmation_request_count - 1)
{ {
if (election_l->confirmed) if (election_l->confirmed)
{ {
@ -119,12 +119,12 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
} }
else else
{ {
if (election_l->announcements > announcement_long) if (election_l->confirmation_request_count > high_confirmation_request_count)
{ {
++unconfirmed_count; ++unconfirmed_count;
unconfirmed_announcements += election_l->announcements; unconfirmed_request_count += election_l->confirmation_request_count;
// Log votes for very long unconfirmed elections // Log votes for very long unconfirmed elections
if (election_l->announcements % 50 == 1) if (election_l->confirmation_request_count % 50 == 1)
{ {
auto tally_l (election_l->tally (transaction)); auto tally_l (election_l->tally (transaction));
election_l->log_votes (tally_l); election_l->log_votes (tally_l);
@ -132,7 +132,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
/* Escalation for long unconfirmed elections /* Escalation for long unconfirmed elections
Start new elections for previous block & source Start new elections for previous block & source
if there are less than 100 active elections */ if there are less than 100 active elections */
if (election_l->announcements % announcement_long == 1 && roots_size < 100 && !node.network_params.network.is_test_network ()) if (election_l->confirmation_request_count % high_confirmation_request_count == 1 && roots_size < 100 && !node.network_params.network.is_test_network ())
{ {
bool escalated (false); bool escalated (false);
std::shared_ptr<nano::block> previous; std::shared_ptr<nano::block> previous;
@ -167,7 +167,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
} }
} }
} }
if (election_l->announcements < announcement_long || election_l->announcements % announcement_long == could_fit_delay) if (election_l->confirmation_request_count < high_confirmation_request_count || election_l->confirmation_request_count % high_confirmation_request_count == could_fit_delay)
{ {
if (node.ledger.could_fit (transaction, *election_l->status.winner)) if (node.ledger.could_fit (transaction, *election_l->status.winner))
{ {
@ -179,14 +179,14 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
} }
else else
{ {
if (election_l->announcements != 0) if (election_l->confirmation_request_count != 0)
{ {
election_l->stop (); election_l->stop ();
inactive.insert (root); inactive.insert (root);
} }
} }
} }
if (election_l->announcements % announcement_long == 1) if (election_l->confirmation_request_count % high_confirmation_request_count == 1)
{ {
auto rep_channels (std::make_shared<std::vector<std::shared_ptr<nano::transport::channel>>> ()); auto rep_channels (std::make_shared<std::vector<std::shared_ptr<nano::transport::channel>>> ());
auto reps (node.rep_crawler.representatives (std::numeric_limits<size_t>::max ())); auto reps (node.rep_crawler.representatives (std::numeric_limits<size_t>::max ()));
@ -274,7 +274,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
} }
} }
} }
++election_l->announcements; ++election_l->confirmation_request_count;
} }
lock_a.unlock (); lock_a.unlock ();
// Rebroadcast unconfirmed blocks // Rebroadcast unconfirmed blocks
@ -312,7 +312,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
long_unconfirmed_size = unconfirmed_count; long_unconfirmed_size = unconfirmed_count;
if (unconfirmed_count > 0) if (unconfirmed_count > 0)
{ {
node.logger.try_log (boost::str (boost::format ("%1% blocks have been unconfirmed averaging %2% announcements") % unconfirmed_count % (unconfirmed_announcements / unconfirmed_count))); node.logger.try_log (boost::str (boost::format ("%1% blocks have been unconfirmed averaging %2% confirmation requests") % unconfirmed_count % (unconfirmed_request_count / unconfirmed_count)));
} }
} }
@ -708,7 +708,7 @@ void nano::active_transactions::flush_lowest ()
if (count != 2) if (count != 2)
{ {
auto election = it->election; auto election = it->election;
if (election->announcements > announcement_long && !election->confirmed && !election->stopped && !node.wallets.watcher.is_watched (it->root)) if (election->confirmation_request_count > high_confirmation_request_count && !election->confirmed && !election->stopped && !node.wallets.watcher.is_watched (it->root))
{ {
it = decltype (it){ sorted_roots.erase (std::next (it).base ()) }; it = decltype (it){ sorted_roots.erase (std::next (it).base ()) };
election->stop (); election->stop ();

10
nano/node/active_transactions.hpp
View file

@ -119,12 +119,10 @@ public:
void add_confirmed (nano::election_status const &, nano::qualified_root const &); void add_confirmed (nano::election_status const &, nano::qualified_root const &);
nano::node & node; nano::node & node;
std::mutex mutex; std::mutex mutex;
// Maximum number of conflicts to vote on per interval, lowest root hash first // Minimum number of confirmation requests
static unsigned constexpr announcements_per_interval = 32; static unsigned constexpr minimum_confirmation_request_count = 2;
// Minimum number of block announcements // Threshold for considering confirmation request count high
static unsigned constexpr announcement_min = 2; static unsigned constexpr high_confirmation_request_count = 2;
// Threshold to start logging blocks haven't yet been confirmed
static unsigned constexpr announcement_long = 2;
size_t long_unconfirmed_size = 0; size_t long_unconfirmed_size = 0;
static size_t constexpr max_broadcast_queue = 1000; static size_t constexpr max_broadcast_queue = 1000;
boost::circular_buffer<double> multipliers_cb; boost::circular_buffer<double> multipliers_cb;

2
nano/node/blockprocessor.cpp
View file

@ -368,7 +368,7 @@ void nano::block_processor::process_live (nano::block_hash const & hash_a, std::
{ {
std::lock_guard<std::mutex> lock (node_l->active.mutex); std::lock_guard<std::mutex> lock (node_l->active.mutex);
auto existing (node_l->active.blocks.find (block_a->hash ())); auto existing (node_l->active.blocks.find (block_a->hash ()));
if (existing != node_l->active.blocks.end () && !existing->second->confirmed && !existing->second->stopped && existing->second->announcements == 0) if (existing != node_l->active.blocks.end () && !existing->second->confirmed && !existing->second->stopped && existing->second->confirmation_request_count == 0)
{ {
send_request = true; send_request = true;
} }

4
nano/node/election.cpp
View file

@ -14,7 +14,7 @@ election_start (std::chrono::steady_clock::now ()),
status ({ block_a, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), nano::election_status_type::ongoing }), status ({ block_a, 0, std::chrono::duration_cast<std::chrono::milliseconds> (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values<std::chrono::milliseconds>::zero (), nano::election_status_type::ongoing }),
confirmed (false), confirmed (false),
stopped (false), stopped (false),
announcements (0) confirmation_request_count (0)
{ {
last_votes.insert (std::make_pair (node.network_params.random.not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () })); last_votes.insert (std::make_pair (node.network_params.random.not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () }));
blocks.insert (std::make_pair (block_a->hash (), block_a)); blocks.insert (std::make_pair (block_a->hash (), block_a));
@ -46,7 +46,7 @@ void nano::election::confirm_once (nano::election_status_type type_a)
node_l->process_confirmed (status_l); node_l->process_confirmed (status_l);
confirmation_action_l (status_l.winner); confirmation_action_l (status_l.winner);
}); });
if (announcements > node.active.announcement_long) if (confirmation_request_count > node.active.high_confirmation_request_count)
{ {
--node.active.long_unconfirmed_size; --node.active.long_unconfirmed_size;
} }

2
nano/node/election.hpp
View file

@ -59,7 +59,7 @@ public:
std::atomic<bool> confirmed; std::atomic<bool> confirmed;
bool stopped; bool stopped;
std::unordered_map<nano::block_hash, nano::uint128_t> last_tally; std::unordered_map<nano::block_hash, nano::uint128_t> last_tally;
unsigned announcements; unsigned confirmation_request_count;
std::unordered_set<nano::block_hash> dependent_blocks; std::unordered_set<nano::block_hash> dependent_blocks;
}; };
} }

4
nano/node/json_handler.cpp
View file

@ -1629,7 +1629,7 @@ void nano::json_handler::confirmation_active ()
std::lock_guard<std::mutex> lock (node.active.mutex); std::lock_guard<std::mutex> lock (node.active.mutex);
for (auto i (node.active.roots.begin ()), n (node.active.roots.end ()); i != n; ++i) for (auto i (node.active.roots.begin ()), n (node.active.roots.end ()); i != n; ++i)
{ {
if (i->election->announcements >= announcements && !i->election->confirmed && !i->election->stopped) if (i->election->confirmation_request_count >= announcements && !i->election->confirmed && !i->election->stopped)
{ {
boost::property_tree::ptree entry; boost::property_tree::ptree entry;
entry.put ("", i->root.to_string ()); entry.put ("", i->root.to_string ());
@ -1706,7 +1706,7 @@ void nano::json_handler::confirmation_info ()
auto conflict_info (node.active.roots.find (root)); auto conflict_info (node.active.roots.find (root));
if (conflict_info != node.active.roots.end ()) if (conflict_info != node.active.roots.end ())
{ {
response_l.put ("announcements", std::to_string (conflict_info->election->announcements)); response_l.put ("announcements", std::to_string (conflict_info->election->confirmation_request_count));
auto election (conflict_info->election); auto election (conflict_info->election);
nano::uint128_t total (0); nano::uint128_t total (0);
response_l.put ("last_winner", election->status.winner->hash ().to_string ()); response_l.put ("last_winner", election->status.winner->hash ().to_string ());