diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index bdc61cc8e4..69a2b19180 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -11,6 +11,47 @@ #include #include +namespace +{ +void update_flags (nano::node_flags & flags_a, boost::program_options::variables_map const & vm) +{ + auto batch_size_it = vm.find ("batch_size"); + if (batch_size_it != vm.end ()) + { + flags_a.sideband_batch_size = batch_size_it->second.as (); + } + flags_a.disable_backup = (vm.count ("disable_backup") > 0); + flags_a.disable_lazy_bootstrap = (vm.count ("disable_lazy_bootstrap") > 0); + flags_a.disable_legacy_bootstrap = (vm.count ("disable_legacy_bootstrap") > 0); + flags_a.disable_wallet_bootstrap = (vm.count ("disable_wallet_bootstrap") > 0); + flags_a.disable_bootstrap_listener = (vm.count ("disable_bootstrap_listener") > 0); + flags_a.disable_unchecked_cleanup = (vm.count ("disable_unchecked_cleanup") > 0); + flags_a.disable_unchecked_drop = (vm.count ("disable_unchecked_drop") > 0); + flags_a.fast_bootstrap = (vm.count ("fast_bootstrap") > 0); + if (flags_a.fast_bootstrap) + { + flags_a.block_processor_batch_size = 256 * 1024; + flags_a.block_processor_full_size = 1024 * 1024; + flags_a.block_processor_verification_size = std::numeric_limits::max (); + } + auto block_processor_batch_size_it = vm.find ("block_processor_batch_size"); + if (block_processor_batch_size_it != vm.end ()) + { + flags_a.block_processor_batch_size = block_processor_batch_size_it->second.as (); + } + auto block_processor_full_size_it = vm.find ("block_processor_full_size"); + if (block_processor_full_size_it != vm.end ()) + { + flags_a.block_processor_full_size = block_processor_full_size_it->second.as (); + } + auto block_processor_verification_size_it = vm.find ("block_processor_verification_size"); + if (block_processor_verification_size_it != vm.end ()) + { + flags_a.block_processor_verification_size = block_processor_verification_size_it->second.as (); + } +} +} + int main (int argc, char * const * argv) { nano::set_umask (); @@ -32,6 +73,9 @@ int main (int argc, char * const * argv) ("disable_unchecked_drop", "Disables drop of unchecked table at startup") ("fast_bootstrap", "Increase bootstrap speed for high end nodes with higher limits") ("batch_size",boost::program_options::value (), "Increase sideband batch size, default 512") + ("block_processor_batch_size",boost::program_options::value (), "Increase block processor transaction batch write size, default 0 (limited by config block_processor_batch_max_time), 256k for fast_bootstrap") + ("block_processor_full_size",boost::program_options::value (), "Increase block processor allowed blocks queue size before dropping live network packets and holding bootstrap download, default 65536, 1 million for fast_bootstrap") + ("block_processor_verification_size",boost::program_options::value (), "Increase batch signature verification size in block processor, default 0 (limited by config signature_checker_threads), unlimited for fast_bootstrap") ("debug_block_count", "Display the number of block") ("debug_bootstrap_generate", "Generate bootstrap sequence of blocks") ("debug_dump_online_weight", "Dump online_weights table") @@ -102,19 +146,7 @@ int main (int argc, char * const * argv) { nano_daemon::daemon daemon; nano::node_flags flags; - auto batch_size_it = vm.find ("batch_size"); - if (batch_size_it != vm.end ()) - { - flags.sideband_batch_size = batch_size_it->second.as (); - } - flags.disable_backup = (vm.count ("disable_backup") > 0); - flags.disable_lazy_bootstrap = (vm.count ("disable_lazy_bootstrap") > 0); - flags.disable_legacy_bootstrap = (vm.count ("disable_legacy_bootstrap") > 0); - flags.disable_wallet_bootstrap = (vm.count ("disable_wallet_bootstrap") > 0); - flags.disable_bootstrap_listener = (vm.count ("disable_bootstrap_listener") > 0); - flags.disable_unchecked_cleanup = (vm.count ("disable_unchecked_cleanup") > 0); - flags.disable_unchecked_drop = (vm.count ("disable_unchecked_drop") > 0); - flags.fast_bootstrap = (vm.count ("fast_bootstrap") > 0); + update_flags (flags, vm); daemon.run (data_path, flags); } else if (vm.count ("debug_block_count")) @@ -856,7 +888,7 @@ int main (int argc, char * const * argv) else if (vm.count ("debug_profile_bootstrap")) { nano::inactive_node node2 (nano::unique_path (), 24001); - node2.node->flags.fast_bootstrap = (vm.count ("fast_bootstrap") > 0); + update_flags (node2.node->flags, vm); nano::genesis genesis; auto begin (std::chrono::high_resolution_clock::now ()); uint64_t block_count (0); diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index aa6b982833..fb1335f313 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -211,7 +211,7 @@ bool update_config (qt_wallet_config & config_a, boost::filesystem::path const & } } -int run_wallet (QApplication & application, int argc, char * const * argv, boost::filesystem::path const & data_path, nano::node_flags const & flags) +int run_wallet (QApplication & application, int argc, char * const * argv, boost::filesystem::path const & data_path) { nano_qt::eventloop_processor processor; boost::system::error_code error_chmod; @@ -243,6 +243,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost : std::function (nano::uint256_union const &, uint64_t)> (nullptr)); nano::alarm alarm (io_ctx); nano::node_init init; + nano::node_flags flags; node = std::make_shared (init, io_ctx, data_path, alarm, config.node, work, flags); if (!init.error ()) { @@ -369,21 +370,7 @@ int main (int argc, char * const * argv) { data_path = nano::working_path (); } - nano::node_flags flags; - auto batch_size_it = vm.find ("batch_size"); - if (batch_size_it != vm.end ()) - { - flags.sideband_batch_size = batch_size_it->second.as (); - } - flags.disable_backup = (vm.count ("disable_backup") > 0); - flags.disable_lazy_bootstrap = (vm.count ("disable_lazy_bootstrap") > 0); - flags.disable_legacy_bootstrap = (vm.count ("disable_legacy_bootstrap") > 0); - flags.disable_wallet_bootstrap = (vm.count ("disable_wallet_bootstrap") > 0); - flags.disable_bootstrap_listener = (vm.count ("disable_bootstrap_listener") > 0); - flags.disable_unchecked_cleanup = (vm.count ("disable_unchecked_cleanup") > 0); - flags.disable_unchecked_drop = (vm.count ("disable_unchecked_drop") > 0); - flags.fast_bootstrap = (vm.count ("fast_bootstrap") > 0); - result = run_wallet (application, argc, argv, data_path, flags); + result = run_wallet (application, argc, argv, data_path); } catch (std::exception const & e) { diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 903ac1bf0a..572db7a9ab 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -42,9 +42,8 @@ void nano::block_processor::flush () bool nano::block_processor::full () { - size_t full_size (node.flags.fast_bootstrap ? 1024 * 1024 : 65536); std::unique_lock lock (mutex); - return (blocks.size () + state_blocks.size ()) > full_size; + return (blocks.size () + state_blocks.size ()) > node.flags.block_processor_full_size; } void nano::block_processor::add (std::shared_ptr block_a, uint64_t origination) @@ -231,7 +230,7 @@ void nano::block_processor::process_batch (std::unique_lock & lock_a lock_a.lock (); timer_l.start (); // Limit state blocks verification time - size_t max_verification_batch (node.flags.fast_bootstrap ? std::numeric_limits::max () : 2048 * (node.config.signature_checker_threads + 1)); + size_t max_verification_batch (node.flags.block_processor_verification_size != 0 ? node.flags.block_processor_verification_size : 2048 * (node.config.signature_checker_threads + 1)); if (!state_blocks.empty ()) { auto transaction (node.store.tx_begin_read ()); @@ -247,7 +246,7 @@ void nano::block_processor::process_batch (std::unique_lock & lock_a // Processing blocks auto first_time (true); unsigned number_of_blocks_processed (0), number_of_forced_processed (0); - while ((!blocks.empty () || !forced.empty ()) && (timer_l.before_deadline (node.config.block_processor_batch_max_time) || (node.flags.fast_bootstrap && number_of_blocks_processed < 256 * 1024))) + while ((!blocks.empty () || !forced.empty ()) && (timer_l.before_deadline (node.config.block_processor_batch_max_time) || (number_of_blocks_processed < node.flags.block_processor_batch_size))) { auto log_this_record (false); if (node.config.logging.timing_logging ()) diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index d67024152c..26aed77d4d 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -419,16 +419,3 @@ nano::account nano::node_config::random_representative () auto result (preconfigured_representatives[index]); return result; } - -nano::node_flags::node_flags () : -disable_backup (false), -disable_lazy_bootstrap (false), -disable_legacy_bootstrap (false), -disable_wallet_bootstrap (false), -disable_bootstrap_listener (false), -disable_unchecked_cleanup (false), -disable_unchecked_drop (true), -fast_bootstrap (false), -sideband_batch_size (512) -{ -} diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index 4222a188c6..45f4fbca5d 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -68,15 +68,17 @@ class node_config class node_flags { public: - node_flags (); - bool disable_backup; - bool disable_lazy_bootstrap; - bool disable_legacy_bootstrap; - bool disable_wallet_bootstrap; - bool disable_bootstrap_listener; - bool disable_unchecked_cleanup; - bool disable_unchecked_drop; - bool fast_bootstrap; - size_t sideband_batch_size; + bool disable_backup{ false }; + bool disable_lazy_bootstrap{ false }; + bool disable_legacy_bootstrap{ false }; + bool disable_wallet_bootstrap{ false }; + bool disable_bootstrap_listener{ false }; + bool disable_unchecked_cleanup{ false }; + bool disable_unchecked_drop{ true }; + bool fast_bootstrap{ false }; + size_t sideband_batch_size{ 512 }; + size_t block_processor_batch_size{ 0 }; + size_t block_processor_full_size{ 65536 }; + size_t block_processor_verification_size{ 0 }; }; }