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

Removing empty constructor from network_constants.

Browse source
This commit is contained in:
clemahieu 2021-08-10 15:49:28 +01:00
commit a56a8d1eee
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
10 changed files with 24 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/core_test/distributed_work.cpp
View file

@ -10,7 +10,7 @@ TEST (distributed_work, stopped)
{
nano::system system (1);
system.nodes[0]->distributed_work.stop ();
ASSERT_TRUE (system.nodes[0]->distributed_work.make (nano::work_version::work_1, nano::block_hash (), {}, nano::network_constants ().publish_thresholds.base, {}));
ASSERT_TRUE (system.nodes[0]->distributed_work.make (nano::work_version::work_1, nano::block_hash (), {}, nano::dev::network_params.network.publish_thresholds.base, {}));
}
TEST (distributed_work, no_peers)
@ -43,7 +43,7 @@ TEST (distributed_work, no_peers_disabled)
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.work_threads = 0;
auto & node = *system.add_node (node_config);
ASSERT_TRUE (node.distributed_work.make (nano::work_version::work_1, nano::block_hash (), node.config.work_peers, nano::network_constants ().publish_thresholds.base, {}));
ASSERT_TRUE (node.distributed_work.make (nano::work_version::work_1, nano::block_hash (), node.config.work_peers, nano::dev::network_params.network.publish_thresholds.base, {}));
}
TEST (distributed_work, no_peers_cancel)

11
nano/core_test/fakes/work_peer.hpp
View file

@ -138,20 +138,17 @@ private:
void handle_generate (nano::block_hash const & hash_a)
{
static nano::network_constants constants;
if (type == work_peer_type::good)
{
auto hash = hash_a;
auto request_difficulty = constants.publish_thresholds.threshold_base (version);
auto this_l (shared_from_this ());
work_pool.generate (version, hash, request_difficulty, [this_l, hash] (boost::optional<uint64_t> work_a) {
auto request_difficulty = work_pool.network_constants.publish_thresholds.threshold_base (version);
work_pool.generate (version, hash, request_difficulty, [this_l = shared_from_this (), hash] (boost::optional<uint64_t> work_a) {
auto result = work_a.value_or (0);
static nano::network_constants constants;
auto result_difficulty (constants.publish_thresholds.difficulty (this_l->version, hash, result));
auto result_difficulty (this_l->work_pool.network_constants.publish_thresholds.difficulty (this_l->version, hash, result));
ptree::ptree message_l;
message_l.put ("work", nano::to_string_hex (result));
message_l.put ("difficulty", nano::to_string_hex (result_difficulty));
message_l.put ("multiplier", nano::to_string (nano::difficulty::to_multiplier (result_difficulty, constants.publish_thresholds.threshold_base (this_l->version))));
message_l.put ("multiplier", nano::to_string (nano::difficulty::to_multiplier (result_difficulty, this_l->work_pool.network_constants.publish_thresholds.threshold_base (this_l->version))));
message_l.put ("hash", hash.to_string ());
std::stringstream ostream;
ptree::write_json (ostream, message_l);

5
nano/lib/config.hpp
View file

@ -134,11 +134,6 @@ public:
class network_constants
{
public:
network_constants () :
network_constants (network_constants::active_network)
{
}
network_constants (nano::networks network_a) :
current_network (network_a),
publish_thresholds (is_live_network () ? nano::work_thresholds::publish_full : is_beta_network () ? nano::work_thresholds::publish_beta : is_test_network () ? nano::work_thresholds::publish_test : nano::work_thresholds::publish_dev)

3
nano/load_test/entry.cpp
View file

@ -360,8 +360,7 @@ int main (int argc, char * const * argv)
data_paths.push_back (std::move (data_path));
}
nano::network_constants network_constants;
auto current_network = network_constants.get_current_network_as_string ();
auto current_network = nano::dev::network_params.network.get_current_network_as_string ();
std::vector<std::unique_ptr<boost::process::child>> nodes;
std::vector<std::unique_ptr<boost::process::child>> rpc_servers;
for (auto const & data_path : data_paths)

19
nano/nano_node/entry.cpp
View file

@ -139,6 +139,7 @@ int main (int argc, char * const * argv)
}
}
nano::network_params network_params{ nano::network_constants::active_network };
auto data_path_it = vm.find ("data_path");
boost::filesystem::path data_path ((data_path_it != vm.end ()) ? data_path_it->second.as<std::string> () : nano::working_path ());
auto ec = nano::handle_node_options (vm);
@ -158,7 +159,7 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("compare_rep_weights"))
{
if (!nano::network_constants ().is_dev_network ())
if (nano::network_constants::active_network != nano::networks::nano_dev_network)
{
auto node_flags = nano::inactive_node_flag_defaults ();
nano::update_flags (node_flags, vm);
@ -339,9 +340,8 @@ int main (int argc, char * const * argv)
<< "Public: " << rep.pub.to_string () << "\n"
<< "Account: " << rep.pub.to_account () << "\n";
}
nano::network_constants network_constants;
nano::uint128_t balance (std::numeric_limits<nano::uint128_t>::max ());
nano::open_block genesis_block (reinterpret_cast<const nano::block_hash &> (genesis.pub), genesis.pub, genesis.pub, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, genesis.pub, network_constants.publish_thresholds.epoch_1));
nano::open_block genesis_block (reinterpret_cast<const nano::block_hash &> (genesis.pub), genesis.pub, genesis.pub, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, genesis.pub, network_params.network.publish_thresholds.epoch_1));
std::cout << genesis_block.to_json ();
std::cout.flush ();
nano::block_hash previous (genesis_block.hash ());
@ -353,7 +353,7 @@ int main (int argc, char * const * argv)
{
debug_assert (balance > weekly_distribution);
balance = balance < (weekly_distribution * 2) ? 0 : balance - weekly_distribution;
nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous, network_constants.publish_thresholds.epoch_1));
nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous, network_params.network.publish_thresholds.epoch_1));
previous = send.hash ();
std::cout << send.to_json ();
std::cout.flush ();
@ -455,7 +455,6 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_profile_generate"))
{
nano::network_constants network_constants;
uint64_t difficulty{ nano::work_thresholds::publish_full.base };
auto multiplier_it = vm.find ("multiplier");
if (multiplier_it != vm.end ())
@ -491,7 +490,7 @@ int main (int argc, char * const * argv)
pow_rate_limiter = std::chrono::nanoseconds (boost::lexical_cast<uint64_t> (pow_sleep_interval_it->second.as<std::string> ()));
}
nano::work_pool work{ network_constants, std::numeric_limits<unsigned>::max (), pow_rate_limiter };
nano::work_pool work{ network_params.network, std::numeric_limits<unsigned>::max (), pow_rate_limiter };
nano::change_block block (0, 0, nano::keypair ().prv, 0, 0);
if (!result)
{
@ -508,7 +507,6 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_profile_validate"))
{
nano::network_constants network_constants;
uint64_t difficulty{ nano::work_thresholds::publish_full.base };
std::cerr << "Starting validation profile" << std::endl;
auto start (std::chrono::steady_clock::now ());
@ -517,7 +515,7 @@ int main (int argc, char * const * argv)
uint64_t count{ 10000000U }; // 10M
for (uint64_t i (0); i < count; ++i)
{
valid = network_constants.publish_thresholds.value (hash, i) > difficulty;
valid = network_params.network.publish_thresholds.value (hash, i) > difficulty;
}
std::ostringstream oss (valid ? "true" : "false"); // IO forces compiler to not dismiss the variable
auto total_time (std::chrono::duration_cast<std::chrono::nanoseconds> (std::chrono::steady_clock::now () - start).count ());
@ -526,7 +524,6 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_opencl"))
{
nano::network_constants network_constants;
bool error (false);
nano::opencl_environment environment (error);
if (!error)
@ -610,8 +607,8 @@ int main (int argc, char * const * argv)
{
nano::logger_mt logger;
nano::opencl_config config (platform, device, threads);
auto opencl (nano::opencl_work::create (true, config, logger, network_constants.publish_thresholds));
nano::work_pool work_pool{ network_constants, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
auto opencl (nano::opencl_work::create (true, config, logger, network_params.network.publish_thresholds));
nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> &) {
return opencl->generate_work (version_a, root_a, difficulty_a);
}
: std::function<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> (nullptr) };

4
nano/nano_rpc/entry.cpp
View file

@ -39,9 +39,9 @@ void run (boost::filesystem::path const & data_path, std::vector<std::string> co
boost::system::error_code error_chmod;
nano::set_secure_perm_directory (data_path, error_chmod);
std::unique_ptr<nano::thread_runner> runner;
nano::network_constants network;
nano::rpc_config rpc_config{ network };
nano::network_params network_params{ nano::network_constants::active_network };
nano::rpc_config rpc_config{ network_params.network };
auto error = nano::read_rpc_config_toml (data_path, rpc_config, config_overrides);
if (!error)
{

2
nano/node/json_handler.cpp
View file

@ -60,7 +60,7 @@ void nano::json_handler::process_request (bool unsafe_a)
boost::property_tree::read_json (istream, request);
if (node_rpc_config.request_callback)
{
debug_assert (nano::network_constants ().is_dev_network ());
debug_assert (node.network_params.network.is_dev_network ());
node_rpc_config.request_callback (request);
}
action = request.get<std::string> ("action");

3
nano/node/node.cpp
View file

@ -1110,12 +1110,11 @@ int nano::node::price (nano::uint128_t const & balance_a, int amount_a)
uint64_t nano::node::default_difficulty (nano::work_version const version_a) const
{
nano::network_constants constants;
uint64_t result{ std::numeric_limits<uint64_t>::max () };
switch (version_a)
{
case nano::work_version::work_1:
result = constants.publish_thresholds.threshold_base (version_a);
result = network_params.network.publish_thresholds.threshold_base (version_a);
break;
default:
debug_assert (false && "Invalid version specified to default_difficulty");

8
nano/node/nodeconfig.cpp
View file

@ -351,7 +351,6 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
toml.get ("conf_height_processor_batch_min_time", conf_height_processor_batch_min_time_l);
conf_height_processor_batch_min_time = std::chrono::milliseconds (conf_height_processor_batch_min_time_l);
nano::network_constants network;
toml.get<double> ("max_work_generate_multiplier", max_work_generate_multiplier);
toml.get<uint32_t> ("max_queued_requests", max_queued_requests);
@ -392,7 +391,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
{
toml.get_error ().set ("io_threads must be non-zero");
}
if (active_elections_size <= 250 && !network.is_dev_network ())
if (active_elections_size <= 250 && !network_params.network.is_dev_network ())
{
toml.get_error ().set ("active_elections_size must be greater than 250");
}
@ -416,7 +415,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml)
{
toml.get_error ().set ((boost::format ("block_processor_batch_max_time value must be equal or larger than %1%ms") % network_params.node.process_confirmed_interval.count ()).str ());
}
if (max_pruning_age < std::chrono::seconds (5 * 60) && !network.is_dev_network ())
if (max_pruning_age < std::chrono::seconds (5 * 60) && !network_params.network.is_dev_network ())
{
toml.get_error ().set ("max_pruning_age must be greater than or equal to 5 minutes");
}
@ -684,7 +683,6 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco
json.get ("conf_height_processor_batch_min_time", conf_height_processor_batch_min_time_l);
conf_height_processor_batch_min_time = std::chrono::milliseconds (conf_height_processor_batch_min_time_l);
nano::network_constants network;
// Validate ranges
if (password_fanout < 16 || password_fanout > 1024 * 1024)
{
@ -694,7 +692,7 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco
{
json.get_error ().set ("io_threads must be non-zero");
}
if (active_elections_size <= 250 && !network.is_dev_network ())
if (active_elections_size <= 250 && !network_params.network.is_dev_network ())
{
json.get_error ().set ("active_elections_size must be greater than 250");
}

6
nano/test_common/system.cpp
View file

@ -202,11 +202,10 @@ uint64_t nano::system::work_generate_limited (nano::block_hash const & root_a, u
{
debug_assert (min_a > 0);
uint64_t result = 0;
static nano::network_constants constants;
do
{
result = *work.generate (root_a, min_a);
} while (constants.publish_thresholds.difficulty (nano::work_version::work_1, root_a, result) >= max_a);
} while (work.network_constants.publish_thresholds.difficulty (nano::work_version::work_1, root_a, result) >= max_a);
return result;
}
@ -220,7 +219,6 @@ std::unique_ptr<nano::state_block> nano::upgrade_epoch (nano::work_pool & pool_a
nano::state_block_builder builder;
std::error_code ec;
static nano::network_constants constants;
auto epoch = builder
.account (dev_genesis_key.pub)
.previous (latest)
@ -228,7 +226,7 @@ std::unique_ptr<nano::state_block> nano::upgrade_epoch (nano::work_pool & pool_a
.link (ledger_a.epoch_link (epoch_a))
.representative (dev_genesis_key.pub)
.sign (dev_genesis_key.prv, dev_genesis_key.pub)
.work (*pool_a.generate (latest, constants.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))))
.work (*pool_a.generate (latest, pool_a.network_constants.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))))
.build (ec);
bool error{ true };