Introduce nano::opencl_work::create_work_func

to simplify code around nano node construction.

nano/nano_node/daemon.cpp

@@ -99,13 +99,10 @@ void nano::daemon::run (std::filesystem::path const & data_path, nano::node_flag
 		}
 
 		boost::asio::io_context io_ctx;
-		auto opencl = nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work);
 		nano::opencl_work_func_t opencl_work_func;
-		if (opencl)
+		if (config.opencl_enable)
 		{
-			opencl_work_func = [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
-				return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a);
-			};
+			opencl_work_func = nano::opencl_work::create_work_func (config.opencl, logger, config.node.network_params.work);
 		}
 		nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl_work_func);
 		try

nano/nano_node/entry.cpp

@@ -615,7 +615,7 @@ int main (int argc, char * const * argv)
 						{
 							nano::logger logger;
 							nano::opencl_config config (platform, device, threads);
-							auto opencl = nano::opencl_work::create (true, config, logger, network_params.work);
+							auto opencl = nano::opencl_work::create (config, logger, network_params.work);
 							nano::opencl_work_func_t opencl_work_func;
 							if (opencl)
 							{

nano/nano_wallet/entry.cpp

@@ -128,13 +128,10 @@ int run_wallet (QApplication & application, int argc, char * const * argv, std::
 		std::shared_ptr<nano::node> node;
 		std::shared_ptr<nano_qt::wallet> gui;
 		nano::set_application_icon (application);
-		auto opencl = nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work);
 		nano::opencl_work_func_t opencl_work_func;
-		if (opencl)
+		if (config.opencl_enable)
 		{
-			opencl_work_func = [&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);
-			};
+			opencl_work_func = nano::opencl_work::create_work_func (config.opencl, logger, config.node.network_params.work);
 		}
 		nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl_work_func };
 		node = std::make_shared<nano::node> (io_ctx, data_path, config.node, work, flags);

nano/node/openclwork.cpp

@@ -522,26 +522,41 @@ boost::optional<uint64_t> nano::opencl_work::generate_work (nano::work_version c
 	return value;
 }
 
-std::unique_ptr<nano::opencl_work> nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logger & logger_a, nano::work_thresholds & work)
+std::unique_ptr<nano::opencl_work> nano::opencl_work::create (nano::opencl_config const & config_a, nano::logger & logger_a, nano::work_thresholds & work)
 {
-	std::unique_ptr<nano::opencl_work> result;
-	if (create_a)
+	// build opencl enviroment
+	bool error = false;
+	nano::opencl_environment environment (error);
+	if (error)
 	{
-		auto error (false);
+		logger_a.error (nano::log::type::opencl_work, "Failed to create OpenCL environment");
+		return nullptr;
+	}
 
-		nano::opencl_environment environment (error);
-		std::stringstream stream;
-		environment.dump (stream);
-		logger_a.info (nano::log::type::opencl_work, "OpenCL environment: {}", stream.str ());
+	// print opencl environment info
+	std::stringstream stream;
+	environment.dump (stream);
+	logger_a.info (nano::log::type::opencl_work, "OpenCL environment: {}", stream.str ());
 
-		if (!error)
-		{
-			result.reset (new nano::opencl_work (error, config_a, environment, logger_a, work));
-			if (error)
-			{
-				result.reset ();
-			}
-		}
+	// return work object or nullptr on failure
+	std::unique_ptr<nano::opencl_work> result (new nano::opencl_work (error, config_a, environment, logger_a, work));
+	if (error)
+	{
+		result.reset ();
 	}
 	return result;
 }
+
+// return a functor that generates work via opencl API or null on failure
+nano::opencl_work_func_t nano::opencl_work::create_work_func (nano::opencl_config const & config, nano::logger & logger, nano::work_thresholds & work)
+{
+	nano::opencl_work_func_t f;
+	auto opencl = nano::opencl_work::create (config, logger, work);
+	if (opencl)
+	{
+		f = [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic<int> & ticket_a) {
+			return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a);
+		};
+	}
+	return f;
+}

nano/node/openclwork.hpp

@@ -48,7 +48,8 @@ class opencl_work
 	~opencl_work ();
 	boost::optional<uint64_t> generate_work (nano::work_version const, nano::root const &, uint64_t const);
 	boost::optional<uint64_t> generate_work (nano::work_version const, nano::root const &, uint64_t const, std::atomic<int> &);
-	static std::unique_ptr<opencl_work> create (bool, nano::opencl_config const &, nano::logger &, nano::work_thresholds & work);
+	static std::unique_ptr<opencl_work> create (nano::opencl_config const &, nano::logger &, nano::work_thresholds & work);
+	static nano::opencl_work_func_t create_work_func (nano::opencl_config const &, nano::logger &, nano::work_thresholds & work);
 	nano::opencl_config const & config;
 	nano::mutex mutex;
 	cl_context context;