Add explicit creation methods for task manager and runners

Particularly for the task manager, this ensures these objects are held
by a shared pointer and properly initialized.

Author: trflynn89

fly/task/task_manager.cpp

@@ -14,9 +14,25 @@ namespace {
 } // namespace
 
 //==================================================================================================
-TaskManager::TaskManager(std::uint32_t num_workers) noexcept :
+std::shared_ptr<TaskManager> TaskManager::create(std::uint32_t thread_count)
+{
+    // TaskManager has a private constructor, thus cannot be used with std::make_shared. This class
+    // is used to expose the private constructor locally.
+    struct TaskManagerImpl final : public TaskManager
+    {
+        explicit TaskManagerImpl(std::uint32_t thread_count) noexcept : TaskManager(thread_count)
+        {
+        }
+    };
+
+    auto task_manager = std::make_shared<TaskManagerImpl>(thread_count);
+    return task_manager->start() ? task_manager : nullptr;
+}
+
+//==================================================================================================
+TaskManager::TaskManager(std::uint32_t thread_count) noexcept :
     m_keep_running(false),
-    m_num_workers(num_workers)
+    m_thread_count(thread_count)
 {
 }
 
@@ -29,7 +45,7 @@ bool TaskManager::start()
     {
         std::shared_ptr<TaskManager> task_manager = shared_from_this();
 
-        for (std::uint32_t i = 0; i < m_num_workers; ++i)
+        for (std::uint32_t i = 0; i < m_thread_count; ++i)
         {
             m_futures.push_back(
                 std::async(std::launch::async, &TaskManager::worker_thread, task_manager));

fly/task/task_manager.hpp

@@ -32,11 +32,13 @@ class TaskManager : public std::enable_shared_from_this<TaskManager>
 
 public:
     /**
-     * Constructor.
+     * Create and start a task manager.
+     *
+     * @param thread_count Size of the thread pool for the task manager to own.
      *
-     * @param num_workers Number of worker threads to create.
+     * @return The created task manager.
      */
-    explicit TaskManager(std::uint32_t num_workers) noexcept;
+    static std::shared_ptr<TaskManager> create(std::uint32_t thread_count);
 
     /**
      * Create the worker threads and timer thread.
@@ -58,16 +60,6 @@ class TaskManager : public std::enable_shared_from_this<TaskManager>
      */
     bool stop();
 
-    /**
-     * Create a task runner, holding a weak reference to this task manager.
-     *
-     * @tparam TaskRunnerType The type of task runner to create.
-     *
-     * @return The created task runner.
-     */
-    template <typename TaskRunnerType>
-    std::shared_ptr<TaskRunnerType> create_task_runner();
-
 private:
     /**
      * Wrapper structure to associate a task with its task runner and the point in time that the
@@ -81,6 +73,13 @@ class TaskManager : public std::enable_shared_from_this<TaskManager>
         std::chrono::steady_clock::time_point m_schedule;
     };
 
+    /**
+     * Constructor.
+     *
+     * @param thread_count Size of the thread pool for the task manager to own.
+     */
+    explicit TaskManager(std::uint32_t thread_count) noexcept;
+
     /**
      * Post a task to be executed as soon as a worker thread is available.
      *
@@ -124,17 +123,7 @@ class TaskManager : public std::enable_shared_from_this<TaskManager>
 
     std::vector<std::future<void>> m_futures;
 
-    std::uint32_t m_num_workers;
+    std::uint32_t m_thread_count;
 };
 
-//==================================================================================================
-template <typename TaskRunnerType>
-std::shared_ptr<TaskRunnerType> TaskManager::create_task_runner()
-{
-    static_assert(std::is_base_of_v<TaskRunner, TaskRunnerType>);
-
-    const std::shared_ptr<TaskManager> task_manager = shared_from_this();
-    return std::shared_ptr<TaskRunnerType>(new TaskRunnerType(task_manager));
-}
-
 } // namespace fly

fly/task/task_runner.cpp

@@ -5,8 +5,8 @@
 namespace fly {
 
 //==================================================================================================
-TaskRunner::TaskRunner(std::weak_ptr<TaskManager> weak_task_manager) noexcept :
-    m_weak_task_manager(std::move(weak_task_manager))
+TaskRunner::TaskRunner(const std::shared_ptr<TaskManager> &task_manager) noexcept :
+    m_weak_task_manager(task_manager)
 {
 }
 
@@ -46,8 +46,25 @@ void TaskRunner::execute(TaskLocation &&location, Task &&task)
 }
 
 //==================================================================================================
-ParallelTaskRunner::ParallelTaskRunner(std::weak_ptr<TaskManager> weak_task_manager) noexcept :
-    TaskRunner(std::move(weak_task_manager))
+std::shared_ptr<ParallelTaskRunner>
+ParallelTaskRunner::create(const std::shared_ptr<TaskManager> &task_manager)
+{
+    // ParallelTaskRunner has a private constructor, thus cannot be used with std::make_shared. This
+    // class is used to expose the private constructor locally.
+    struct ParallelTaskRunnerImpl final : public ParallelTaskRunner
+    {
+        explicit ParallelTaskRunnerImpl(const std::shared_ptr<TaskManager> &task_manager) noexcept :
+            ParallelTaskRunner(task_manager)
+        {
+        }
+    };
+
+    return std::make_shared<ParallelTaskRunnerImpl>(task_manager);
+}
+
+//==================================================================================================
+ParallelTaskRunner::ParallelTaskRunner(const std::shared_ptr<TaskManager> &task_manager) noexcept :
+    TaskRunner(task_manager)
 {
 }
 
@@ -63,8 +80,27 @@ void ParallelTaskRunner::task_complete(TaskLocation &&)
 }
 
 //==================================================================================================
-SequencedTaskRunner::SequencedTaskRunner(std::weak_ptr<TaskManager> weak_task_manager) noexcept :
-    TaskRunner(std::move(weak_task_manager))
+std::shared_ptr<SequencedTaskRunner>
+SequencedTaskRunner::create(const std::shared_ptr<TaskManager> &task_manager)
+{
+    // SequencedTaskRunner has a private constructor, thus cannot be used with std::make_shared.
+    // This class is used to expose the private constructor locally.
+    struct SequencedTaskRunnerImpl final : public SequencedTaskRunner
+    {
+        explicit SequencedTaskRunnerImpl(const std::shared_ptr<TaskManager> &task_manager) noexcept
+            :
+            SequencedTaskRunner(task_manager)
+        {
+        }
+    };
+
+    return std::make_shared<SequencedTaskRunnerImpl>(task_manager);
+}
+
+//==================================================================================================
+SequencedTaskRunner::SequencedTaskRunner(const std::shared_ptr<TaskManager> &task_manager) noexcept
+    :
+    TaskRunner(task_manager)
 {
 }
 

fly/task/task_runner.hpp

@@ -296,9 +296,9 @@ class TaskRunner : public std::enable_shared_from_this<TaskRunner>
     /**
      * Private constructor. Task runners may only be created by the task manager.
      *
-     * @param weak_task_manager The task manager.
+     * @param task_manager The task manager.
      */
-    TaskRunner(std::weak_ptr<TaskManager> weak_task_manager) noexcept;
+    TaskRunner(const std::shared_ptr<TaskManager> &task_manager) noexcept;
 
     /**
      * Post a task for execution in accordance with the concrete task runner's policy.
@@ -440,10 +440,19 @@ class TaskRunner : public std::enable_shared_from_this<TaskRunner>
  */
 class ParallelTaskRunner : public TaskRunner
 {
-    friend class TaskManager;
+public:
+    /**
+     * Create a parallel task runner.
+     *
+     * @param task_manager The task manager this runner should interface with.
+     *
+     * @return The created task runner.
+     */
+    static std::shared_ptr<ParallelTaskRunner>
+    create(const std::shared_ptr<TaskManager> &task_manager);
 
 protected:
-    explicit ParallelTaskRunner(std::weak_ptr<TaskManager>) noexcept;
+    explicit ParallelTaskRunner(const std::shared_ptr<TaskManager> &task_manager) noexcept;
 
     /**
      * Post a task for execution immediately.
@@ -477,10 +486,19 @@ class ParallelTaskRunner : public TaskRunner
  */
 class SequencedTaskRunner : public TaskRunner
 {
-    friend class TaskManager;
+public:
+    /**
+     * Create a sequenced task runner.
+     *
+     * @param task_manager The task manager this runner should interface with.
+     *
+     * @return The created task runner.
+     */
+    static std::shared_ptr<SequencedTaskRunner>
+    create(const std::shared_ptr<TaskManager> &task_manager);
 
 protected:
-    explicit SequencedTaskRunner(std::weak_ptr<TaskManager>) noexcept;
+    explicit SequencedTaskRunner(const std::shared_ptr<TaskManager> &task_manager) noexcept;
 
     /**
      * Post a task for execution within this sequence. If a task is not already running, the task is

test/config/config_manager.cpp

@@ -48,8 +48,7 @@ class BadConfig : public fly::Config
 
 CATCH_TEST_CASE("ConfigManager", "[config]")
 {
-    auto task_runner =
-        fly::test::task_manager()->create_task_runner<fly::test::WaitableSequencedTaskRunner>();
+    auto task_runner = fly::test::WaitableSequencedTaskRunner::create(fly::test::task_manager());
 
     fly::test::PathUtil::ScopedTempDirectory config_path;
     std::filesystem::path config_file = config_path.file();

test/logger/logger.cpp

@@ -194,11 +194,7 @@ CATCH_TEST_CASE("Logger", "[logger]")
         // Run all of the log point tests with both synchronous and asynchronous loggers.
         const bool synchronous_logger = GENERATE(true, false);
 
-        auto task_manager = std::make_shared<fly::TaskManager>(1);
-        CATCH_REQUIRE(task_manager->start());
-
-        auto task_runner =
-            fly::test::task_manager()->create_task_runner<fly::SequencedTaskRunner>();
+        auto task_runner = fly::SequencedTaskRunner::create(fly::test::task_manager());
         auto sink = std::make_unique<QueueSink>(received_logs);
 
         auto logger = synchronous_logger ?

test/net/listen_socket.cpp

@@ -297,7 +297,7 @@ CATCH_TEMPLATE_TEST_CASE("AsyncListenSocket", "[net]", fly::net::IPv4Address, fl
     using ListenSocket = fly::net::ListenSocket<EndpointType>;
     using TcpSocket = fly::net::TcpSocket<EndpointType>;
 
-    auto task_runner = fly::test::task_manager()->create_task_runner<fly::SequencedTaskRunner>();
+    auto task_runner = fly::SequencedTaskRunner::create(fly::test::task_manager());
     auto socket_service = fly::net::SocketService::create(task_runner);
     fly::test::Signal signal;
 

test/net/socket_service.cpp

@@ -35,7 +35,7 @@ CATCH_TEMPLATE_TEST_CASE("SocketService", "[net]", fly::net::IPv4Address, fly::n
     using EndpointType = fly::net::Endpoint<IPAddressType>;
     using UdpSocket = fly::net::UdpSocket<EndpointType>;
 
-    auto task_runner = fly::test::task_manager()->create_task_runner<fly::SequencedTaskRunner>();
+    auto task_runner = fly::SequencedTaskRunner::create(fly::test::task_manager());
     auto socket_service = fly::net::SocketService::create(task_runner);
     fly::test::Signal signal;
 

test/net/tcp_socket.cpp

@@ -321,7 +321,7 @@ CATCH_TEMPLATE_TEST_CASE("AsyncTcpSocket", "[net]", fly::net::IPv4Address, fly::
     using ListenSocket = fly::net::ListenSocket<EndpointType>;
     using TcpSocket = fly::net::TcpSocket<EndpointType>;
 
-    auto task_runner = fly::test::task_manager()->create_task_runner<fly::SequencedTaskRunner>();
+    auto task_runner = fly::SequencedTaskRunner::create(fly::test::task_manager());
     auto socket_service = fly::net::SocketService::create(task_runner);
 
     const std::string message(fly::String::generate_random_string(1 << 10));

test/net/udp_socket.cpp

@@ -257,7 +257,7 @@ CATCH_TEMPLATE_TEST_CASE("AsyncUdpSocket", "[net]", fly::net::IPv4Address, fly::
     using EndpointType = fly::net::Endpoint<IPAddressType>;
     using UdpSocket = fly::net::UdpSocket<EndpointType>;
 
-    auto task_runner = fly::test::task_manager()->create_task_runner<fly::SequencedTaskRunner>();
+    auto task_runner = fly::SequencedTaskRunner::create(fly::test::task_manager());
     auto socket_service = fly::net::SocketService::create(task_runner);
 
     const std::string message(fly::String::generate_random_string(1 << 10));

test/path/path_monitor.cpp

@@ -46,8 +46,7 @@ class TestPathConfig : public fly::PathConfig
 
 CATCH_TEST_CASE("PathMonitor", "[path]")
 {
-    auto task_runner =
-        fly::test::task_manager()->create_task_runner<fly::test::WaitableSequencedTaskRunner>();
+    auto task_runner = fly::test::WaitableSequencedTaskRunner::create(fly::test::task_manager());
 
     auto monitor =
         std::make_shared<fly::PathMonitorImpl>(task_runner, std::make_shared<TestPathConfig>());

test/system/system_monitor.cpp

@@ -43,8 +43,7 @@ class TestSystemConfig : public fly::SystemConfig
 
 CATCH_TEST_CASE("SystemMonitor", "[system]")
 {
-    auto task_runner =
-        fly::test::task_manager()->create_task_runner<fly::test::WaitableSequencedTaskRunner>();
+    auto task_runner = fly::test::WaitableSequencedTaskRunner::create(fly::test::task_manager());
 
     auto monitor =
         std::make_shared<fly::SystemMonitorImpl>(task_runner, std::make_shared<TestSystemConfig>());