Pass logger to thread_runner

Exxenoz · May 13, 2024 · 2c6ed18 · 2c6ed18
1 parent 5eaa15e
commit 2c6ed18
Show file tree

Hide file tree

Showing 17 changed files with 56 additions and 51 deletions.
diff --git a/nano/core_test/async.cpp b/nano/core_test/async.cpp
@@ -1,4 +1,5 @@
 #include <nano/lib/async.hpp>
+#include <nano/lib/logging.hpp>
 #include <nano/lib/thread_runner.hpp>
 #include <nano/test_common/system.hpp>
 #include <nano/test_common/testutil.hpp>
@@ -11,14 +12,24 @@
 
 using namespace std::chrono_literals;
 
-TEST (async, sleep)
+namespace
+{
+class test_context
 {
-	auto io_ctx = std::make_shared<asio::io_context> ();
-	nano::thread_runner runner{ io_ctx, 1 };
+public:
+	std::shared_ptr<asio::io_context> io_ctx{ std::make_shared<asio::io_context> () };
+	nano::logger logger;
+	nano::thread_runner runner{ io_ctx, logger, 1 };
 	nano::async::strand strand{ io_ctx->get_executor () };
+};
+}
+
+TEST (async, sleep)
+{
+	test_context ctx;
 
 	auto fut = asio::co_spawn (
-	strand,
+	ctx.strand,
 	[&] () -> asio::awaitable<void> {
 		co_await nano::async::sleep_for (500ms);
 	},
@@ -30,14 +41,12 @@ TEST (async, sleep)
 
 TEST (async, cancellation)
 {
-	auto io_ctx = std::make_shared<asio::io_context> ();
-	nano::thread_runner runner{ io_ctx, 1 };
-	nano::async::strand strand{ io_ctx->get_executor () };
+	test_context ctx;
 
-	nano::async::cancellation cancellation{ strand };
+	nano::async::cancellation cancellation{ ctx.strand };
 
 	auto fut = asio::co_spawn (
-	strand,
+	ctx.strand,
 	[&] () -> asio::awaitable<void> {
 		co_await nano::async::sleep_for (10s);
 	},
@@ -54,17 +63,14 @@ TEST (async, cancellation)
 TEST (async, task)
 {
 	nano::test::system system;
+	test_context ctx;
 
-	auto io_ctx = std::make_shared<asio::io_context> ();
-	nano::thread_runner runner{ io_ctx, 1 };
-	nano::async::strand strand{ io_ctx->get_executor () };
-
-	nano::async::task task{ strand };
+	nano::async::task task{ ctx.strand };
 
 	// Default state, empty task
 	ASSERT_FALSE (task.joinable ());
 
-	task = nano::async::task (strand, [&] () -> asio::awaitable<void> {
+	task = nano::async::task (ctx.strand, [&] () -> asio::awaitable<void> {
 		co_await nano::async::sleep_for (500ms);
 	});
 
@@ -90,12 +96,9 @@ TEST (async, task)
 TEST (async, task_cancel)
 {
 	nano::test::system system;
+	test_context ctx;
 
-	auto io_ctx = std::make_shared<asio::io_context> ();
-	nano::thread_runner runner{ io_ctx, 1 };
-	nano::async::strand strand{ io_ctx->get_executor () };
-
-	nano::async::task task = nano::async::task (strand, [&] () -> asio::awaitable<void> {
+	nano::async::task task = nano::async::task (ctx.strand, [&] () -> asio::awaitable<void> {
 		co_await nano::async::sleep_for (10s);
 	});
 

diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp
@@ -27,7 +27,7 @@ TEST (socket, max_connections)
 	nano::inactive_node inactivenode (nano::unique_path (), node_flags);
 	auto node = inactivenode.node;
 
-	nano::thread_runner runner{ node->io_ctx_shared, 1 };
+	nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
 
 	auto server_port = system.get_available_port ();
 
@@ -135,7 +135,7 @@ TEST (socket, max_connections_per_ip)
 	auto node = inactivenode.node;
 	ASSERT_FALSE (node->flags.disable_max_peers_per_ip);
 
-	nano::thread_runner runner{ node->io_ctx_shared, 1 };
+	nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
 
 	auto server_port = system.get_available_port ();
 
@@ -252,7 +252,7 @@ TEST (socket, max_connections_per_subnetwork)
 	ASSERT_TRUE (node->flags.disable_max_peers_per_ip);
 	ASSERT_FALSE (node->flags.disable_max_peers_per_subnetwork);
 
-	nano::thread_runner runner{ node->io_ctx_shared, 1 };
+	nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
 
 	auto server_port = system.get_available_port ();
 	boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port };
@@ -311,7 +311,7 @@ TEST (socket, disabled_max_peers_per_ip)
 
 	ASSERT_TRUE (node->flags.disable_max_peers_per_ip);
 
-	nano::thread_runner runner{ node->io_ctx_shared, 1 };
+	nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
 
 	auto server_port = system.get_available_port ();
 
@@ -405,7 +405,7 @@ TEST (socket, drop_policy)
 	nano::inactive_node inactivenode (nano::unique_path (), node_flags);
 	auto node = inactivenode.node;
 
-	nano::thread_runner runner{ node->io_ctx_shared, 1 };
+	nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
 
 	std::vector<std::shared_ptr<nano::transport::socket>> connections;
 
@@ -473,7 +473,7 @@ TEST (socket, concurrent_writes)
 
 	// This gives more realistic execution than using system#poll, allowing writes to
 	// queue up and drain concurrently.
-	nano::thread_runner runner{ node->io_ctx_shared, 1 };
+	nano::thread_runner runner{ node->io_ctx_shared, nano::default_logger (), 1 };
 
 	constexpr size_t max_connections = 4;
 	constexpr size_t client_count = max_connections;

diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp
@@ -41,7 +41,7 @@ TEST (system, DISABLED_generate_send_existing)
 {
 	nano::test::system system (1);
 	auto & node1 (*system.nodes[0]);
-	nano::thread_runner runner (system.io_ctx, node1.config.io_threads);
+	nano::thread_runner runner (system.io_ctx, system.logger, node1.config.io_threads);
 	system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
 	nano::keypair stake_preserver;
 	auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true));
@@ -90,7 +90,7 @@ TEST (system, DISABLED_generate_send_new)
 {
 	nano::test::system system (1);
 	auto & node1 (*system.nodes[0]);
-	nano::thread_runner runner (system.io_ctx, node1.config.io_threads);
+	nano::thread_runner runner (system.io_ctx, system.logger, node1.config.io_threads);
 	system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
 	{
 		auto transaction (node1.ledger.tx_begin_read ());

diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp
@@ -828,7 +828,7 @@ TEST (wallet, send_race)
 TEST (wallet, password_race)
 {
 	nano::test::system system (1);
-	nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
+	nano::thread_runner runner (system.io_ctx, system.logger, system.nodes[0]->config.io_threads);
 	auto wallet = system.wallet (0);
 	std::thread thread ([&wallet] () {
 		for (int i = 0; i < 100; i++)
@@ -856,7 +856,7 @@ TEST (wallet, password_race)
 TEST (wallet, password_race_corrupt_seed)
 {
 	nano::test::system system (1);
-	nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
+	nano::thread_runner runner (system.io_ctx, system.logger, system.nodes[0]->config.io_threads);
 	auto wallet = system.wallet (0);
 	nano::raw_key seed;
 	{

diff --git a/nano/lib/thread_runner.cpp b/nano/lib/thread_runner.cpp
@@ -8,9 +8,10 @@
  * thread_runner
  */
 
-nano::thread_runner::thread_runner (std::shared_ptr<asio::io_context> io_ctx_a, unsigned num_threads_a, const nano::thread_role::name thread_role_a) :
+nano::thread_runner::thread_runner (std::shared_ptr<asio::io_context> io_ctx_a, nano::logger & logger_a, unsigned num_threads_a, const nano::thread_role::name thread_role_a) :
 	num_threads{ num_threads_a },
 	role{ thread_role_a },
+	logger{ logger_a },
 	io_ctx{ std::move (io_ctx_a) },
 	io_guard{ asio::make_work_guard (*io_ctx) }
 {

diff --git a/nano/lib/thread_runner.hpp b/nano/lib/thread_runner.hpp
@@ -14,10 +14,8 @@ namespace asio = boost::asio;
 
 class thread_runner final
 {
-	nano::logger logger;
-
 public:
-	thread_runner (std::shared_ptr<asio::io_context>, unsigned num_threads = nano::hardware_concurrency (), nano::thread_role::name thread_role = nano::thread_role::name::io);
+	thread_runner (std::shared_ptr<asio::io_context>, nano::logger &, unsigned num_threads = nano::hardware_concurrency (), nano::thread_role::name thread_role = nano::thread_role::name::io);
 	~thread_runner ();
 
 	/** Wait for IO threads to complete */
@@ -32,6 +30,7 @@ class thread_runner final
 
 	unsigned const num_threads;
 	nano::thread_role::name const role;
+	nano::logger & logger;
 	std::shared_ptr<asio::io_context> io_ctx;
 	asio::executor_work_guard<asio::io_context::executor_type> io_guard;
 	std::vector<boost::thread> threads;

diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp
@@ -719,7 +719,7 @@ int main (int argc, char * const * argv)
 		stop_rpc (ioc, primary_node_results);
 	});
 
-	nano::thread_runner runner (ioc_shared, simultaneous_process_calls);
+	nano::thread_runner runner (ioc_shared, nano::default_logger (), simultaneous_process_calls);
 	t.join ();
 	runner.join ();
 

diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp
@@ -72,6 +72,7 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag
 	nano::set_secure_perm_directory (data_path, error_chmod);
 
 	std::unique_ptr<nano::thread_runner> runner;
+
 	nano::network_params network_params{ nano::network_constants::active_network };
 	nano::daemon_config config{ data_path, network_params };
 	auto error = nano::read_node_config_toml (data_path, config, flags.config_overrides);
@@ -145,7 +146,7 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag
 				logger.info (nano::log::type::daemon, "Start time: {:%c} UTC", fmt::gmtime (dateTime));
 
 				// IO context runner should be started first and stopped last to allow asio handlers to execute during node start/stop
-				runner = std::make_unique<nano::thread_runner> (io_ctx, node->config.io_threads);
+				runner = std::make_unique<nano::thread_runner> (io_ctx, logger, node->config.io_threads);
 
 				node->start ();
 

diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp
@@ -1196,7 +1196,7 @@ int main (int argc, char * const * argv)
 				}
 			}
 			node1->start ();
-			nano::thread_runner runner1 (io_ctx1, node1->config.io_threads);
+			nano::thread_runner runner1 (io_ctx1, nano::default_logger (), node1->config.io_threads);
 
 			std::cout << boost::str (boost::format ("Processing %1% blocks\n") % (count * 2));
 			for (auto & block : blocks)
@@ -1243,7 +1243,7 @@ int main (int argc, char * const * argv)
 
 			auto node2 (std::make_shared<nano::node> (io_ctx2, path2, config2, work, flags, 1));
 			node2->start ();
-			nano::thread_runner runner2 (io_ctx2, node2->config.io_threads);
+			nano::thread_runner runner2 (io_ctx2, nano::default_logger (), node2->config.io_threads);
 			std::cout << boost::str (boost::format ("Processing %1% blocks (test node)\n") % (count * 2));
 			// Processing block
 			while (!blocks.empty ())

diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp
@@ -51,7 +51,7 @@ void run (std::filesystem::path const & data_path, std::vector<std::string> cons
 
 		std::shared_ptr<boost::asio::io_context> io_ctx = std::make_shared<boost::asio::io_context> ();
 
-		runner = std::make_unique<nano::thread_runner> (io_ctx, rpc_config.rpc_process.io_threads);
+		runner = std::make_unique<nano::thread_runner> (io_ctx, logger, rpc_config.rpc_process.io_threads);
 
 		try
 		{

diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp
@@ -124,7 +124,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std::
 
 		std::shared_ptr<boost::asio::io_context> io_ctx = std::make_shared<boost::asio::io_context> ();
 
-		nano::thread_runner runner (io_ctx, config.node.io_threads);
+		nano::thread_runner runner (io_ctx, logger, config.node.io_threads);
 
 		std::shared_ptr<nano::node> node;
 		std::shared_ptr<nano_qt::wallet> gui;

diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp
@@ -483,7 +483,7 @@ class socket_transport : public nano::ipc::transport
 		// A separate io_context for domain sockets may facilitate better performance on some systems.
 		if (concurrency_a > 0)
 		{
-			runner = std::make_unique<nano::thread_runner> (io_ctx, static_cast<unsigned> (concurrency_a));
+			runner = std::make_unique<nano::thread_runner> (io_ctx, server.logger, static_cast<unsigned> (concurrency_a));
 		}
 	}
 

diff --git a/nano/node/ipc/ipc_server.hpp b/nano/node/ipc/ipc_server.hpp
@@ -2,6 +2,7 @@
 
 #include <nano/lib/errors.hpp>
 #include <nano/lib/ipc.hpp>
+#include <nano/lib/logging.hpp>
 #include <nano/node/ipc/ipc_access_config.hpp>
 #include <nano/node/ipc/ipc_broker.hpp>
 #include <nano/node/node_rpc_config.hpp>
@@ -37,8 +38,11 @@ namespace ipc
 		nano::ipc::access & get_access ();
 		nano::error reload_access_config ();
 
+		nano::logger logger{ "ipc_server" };
+
 	private:
-		void setup_callbacks ();
+		void
+		setup_callbacks ();
 		std::shared_ptr<nano::ipc::broker> broker;
 		nano::ipc::access access;
 		std::unique_ptr<dsock_file_remover> file_remover;

diff --git a/nano/node/node.cpp b/nano/node/node.cpp
@@ -144,11 +144,11 @@ nano::node::node (std::shared_ptr<boost::asio::io_context> io_ctx_a, std::filesy
 	config{ config_a },
 	io_ctx_shared{ std::make_shared<boost::asio::io_context> () },
 	io_ctx{ *io_ctx_shared },
-	runner_impl{ std::make_unique<nano::thread_runner> (io_ctx_shared) },
+	logger{ make_logger_identifier (node_id) },
+	runner_impl{ std::make_unique<nano::thread_runner> (io_ctx_shared, logger, config.io_threads) },
 	runner{ *runner_impl },
 	node_initialized_latch (1),
 	network_params{ config.network_params },
-	logger{ make_logger_identifier (node_id) },
 	stats{ logger, config.stats_config },
 	workers{ config.background_threads, nano::thread_role::name::worker },
 	bootstrap_workers{ config.bootstrap_serving_threads, nano::thread_role::name::bootstrap_worker },
@@ -640,9 +640,6 @@ void nano::node::process_local_async (std::shared_ptr<nano::block> const & block
 
 void nano::node::start ()
 {
-	// Start the IO runner first
-	runner.start ();
-
 	long_inactivity_cleanup ();
 
 	network.start ();

diff --git a/nano/node/node.hpp b/nano/node/node.hpp
@@ -146,11 +146,11 @@ class node final : public std::enable_shared_from_this<node>
 	nano::node_config config;
 	std::shared_ptr<boost::asio::io_context> io_ctx_shared;
 	boost::asio::io_context & io_ctx;
+	nano::logger logger;
 	std::unique_ptr<nano::thread_runner> runner_impl;
 	nano::thread_runner & runner;
 	boost::latch node_initialized_latch;
 	nano::network_params & network_params;
-	nano::logger logger;
 	nano::stats stats;
 	nano::thread_pool workers;
 	nano::thread_pool bootstrap_workers;

diff --git a/nano/slow_test/bootstrap.cpp b/nano/slow_test/bootstrap.cpp
@@ -63,7 +63,7 @@ std::unique_ptr<rpc_wrapper> start_rpc (nano::test::system & system, nano::node
 TEST (bootstrap_ascending, profile)
 {
 	nano::test::system system;
-	nano::thread_runner runner{ system.io_ctx, 2 };
+	nano::thread_runner runner{ system.io_ctx, system.logger, 2 };
 	nano::networks network = nano::networks::nano_beta_network;
 	nano::network_params network_params{ network };
 

diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp
@@ -64,7 +64,7 @@ TEST (system, generate_mass_activity_long)
 	nano::node_config node_config = system.default_config ();
 	node_config.enable_voting = false; // Prevent blocks cementing
 	auto node = system.add_node (node_config);
-	nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
+	nano::thread_runner runner (system.io_ctx, system.logger, system.nodes[0]->config.io_threads);
 	system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
 	uint32_t count (1000000);
 	auto count_env_var = std::getenv ("SLOW_TEST_SYSTEM_GENERATE_MASS_ACTIVITY_LONG_COUNT");
@@ -90,7 +90,7 @@ TEST (system, receive_while_synchronizing)
 		nano::node_config node_config = system.default_config ();
 		node_config.enable_voting = false; // Prevent blocks cementing
 		auto node = system.add_node (node_config);
-		nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
+		nano::thread_runner runner (system.io_ctx, system.logger, system.nodes[0]->config.io_threads);
 		system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
 		uint32_t count (1000);
 		system.generate_mass_activity (count, *system.nodes[0]);
-Original file line number
+Diff line change
@@ Expand Up @@
     		std::shared_ptr<boost::asio::io_context> io_ctx = std::make_shared<boost::asio::io_context> ();
-    		runner = std::make_unique<nano::thread_runner> (io_ctx, rpc_config.rpc_process.io_threads);
+    		runner = std::make_unique<nano::thread_runner> (io_ctx, logger, rpc_config.rpc_process.io_threads);
     		try
     		{
@@ Expand Down @@