Rename coro::facade to coro::default_executor

Author: dobord

CMakeLists.txt

@@ -91,7 +91,7 @@ set(LIBCORO_SOURCE_FILES
     include/coro/coro.hpp
     include/coro/condition_variable.hpp src/condition_variable.cpp
     include/coro/event.hpp src/event.cpp
-    include/coro/facade.hpp src/facade.cpp
+    include/coro/default_executor.hpp src/default_executor.cpp
     include/coro/generator.hpp
     include/coro/latch.hpp
     include/coro/mutex.hpp src/mutex.cpp

README.md

@@ -801,7 +801,7 @@ struct Params
 
 int main()
 {
-    auto*                         scheduler = coro::facade::instance();
+    auto*                         scheduler = coro::default_executor::instance();
     std::vector<coro::task<void>> tasks{};
     auto                          params = std::make_shared<Params>();
     params->max_value                    = 20;

examples/coro_condition_variable.cpp

@@ -89,7 +89,7 @@ struct Params
 
 int main()
 {
-    auto*                         scheduler = coro::facade::instance();
+    auto*                         scheduler = coro::default_executor::instance();
     std::vector<coro::task<void>> tasks{};
     auto                          params = std::make_shared<Params>();
     params->max_value                    = 20;

include/coro/condition_variable.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "coro/facade.hpp"
+#include "coro/default_executor.hpp"
 #ifdef LIBCORO_FEATURE_NETWORKING
     #include "coro/io_scheduler.hpp"
 #else
@@ -156,7 +156,7 @@ class strategy_based_on_io_scheduler
 
 public:
     explicit strategy_based_on_io_scheduler(
-        std::shared_ptr<io_scheduler> io_scheduler = coro::facade::instance()->get_io_scheduler());
+        std::shared_ptr<io_scheduler> io_scheduler = coro::default_executor::instance()->get_io_scheduler());
 
     ~strategy_based_on_io_scheduler();
 

include/coro/coro.hpp

@@ -30,8 +30,8 @@
 #endif
 
 #include "coro/condition_variable.hpp"
+#include "coro/default_executor.hpp"
 #include "coro/event.hpp"
-#include "coro/facade.hpp"
 #include "coro/generator.hpp"
 #include "coro/latch.hpp"
 #include "coro/mutex.hpp"

include/coro/facade.hpp renamed to include/coro/default_executor.hpp

@@ -10,19 +10,19 @@ namespace coro
 {
 
 /**
- * Facade for universal access to default scheduler or default thread pool.
- * This facade supports the concept of coro::concepts::executor.
+ * Default executor for universal access to default scheduler or default thread pool.
+ * This coro::default_executor supports the concept of coro::concepts::executor.
  */
-class facade
+class default_executor
 {
 public:
-    facade();
+    default_executor();
 
     /**
-     * Getting a single instance of facade per process
-     * @return single instance of facade
+     * Getting a single instance of default_executor per process
+     * @return single instance of default_executor
      */
-    static facade* instance();
+    static default_executor* instance();
 
 #ifdef LIBCORO_FEATURE_NETWORKING
     [[nodiscard]] auto schedule() -> coro::io_scheduler::schedule_operation;
@@ -54,7 +54,7 @@ class facade
 
 #ifdef LIBCORO_FEATURE_NETWORKING
     /**
-     * Set up default coro::io_scheduler::options before constructing a single instance of the facade
+     * Set up default coro::io_scheduler::options before constructing a single instance of the default_executor
      * @param io_scheduler_options io_scheduler options
      */
     static void set_io_scheduler_options(io_scheduler::options io_scheduler_options);
@@ -65,7 +65,7 @@ class facade
     std::shared_ptr<io_scheduler> get_io_scheduler();
 #else
     /**
-     * Set up default coro::thread_pool::options before constructing a single instance of the facade
+     * Set up default coro::thread_pool::options before constructing a single instance of the default_executor
      * @param thread_pool_options thread_pool options
      */
     static void set_thread_pool_options(thread_pool::options thread_pool_options);

src/default_executor.cpp

@@ -0,0 +1,116 @@
+#include "coro/default_executor.hpp"
+#include <atomic>
+#include <memory>
+
+static std::atomic<coro::default_executor*> s_default_executor = {nullptr};
+
+#ifdef LIBCORO_FEATURE_NETWORKING
+coro::io_scheduler::options coro::default_executor::s_io_scheduler_options;
+#else
+coro::thread_pool::options coro::default_executor::s_thread_pool_options;
+#endif
+
+coro::default_executor* coro::default_executor::instance()
+{
+    auto* result = s_default_executor.load(std::memory_order::acquire);
+    if (!result)
+    {
+        auto ptr = std::make_unique<default_executor>();
+        if (s_default_executor.compare_exchange_strong(
+                result, ptr.get(), std::memory_order::release, std::memory_order::acquire))
+            result = ptr.release();
+    }
+    return result;
+}
+
+coro::default_executor::default_executor()
+{
+#ifdef LIBCORO_FEATURE_NETWORKING
+    m_io_scheduler = io_scheduler::make_shared(s_io_scheduler_options);
+#else
+    m_thread_pool = std::make_shared<thread_pool>(s_thread_pool_options);
+#endif
+}
+
+bool coro::default_executor::spawn(coro::task<void>&& task) noexcept
+{
+#ifdef LIBCORO_FEATURE_NETWORKING
+    return m_io_scheduler->spawn(std::move(task));
+#else
+    return m_thread_pool->spawn(std::move(task));
+#endif
+}
+
+bool coro::default_executor::resume(std::coroutine_handle<> handle)
+{
+#ifdef LIBCORO_FEATURE_NETWORKING
+    return m_io_scheduler->resume(handle);
+#else
+    return m_thread_pool->resume(handle);
+#endif
+}
+
+std::size_t coro::default_executor::size()
+{
+#ifdef LIBCORO_FEATURE_NETWORKING
+    return m_io_scheduler->size();
+#else
+    return m_thread_pool->size();
+#endif
+}
+
+bool coro::default_executor::empty()
+{
+#ifdef LIBCORO_FEATURE_NETWORKING
+    return m_io_scheduler->empty();
+#else
+    return m_thread_pool->empty();
+#endif
+}
+
+void coro::default_executor::shutdown()
+{
+#ifdef LIBCORO_FEATURE_NETWORKING
+    m_io_scheduler->shutdown();
+#else
+    m_thread_pool->shutdown();
+#endif
+}
+
+#ifdef LIBCORO_FEATURE_NETWORKING
+auto coro::default_executor::schedule() -> coro::io_scheduler::schedule_operation
+{
+    return m_io_scheduler->schedule();
+}
+#else
+auto coro::default_executor::schedule() -> coro::thread_pool::operation
+{
+    return m_thread_pool->schedule();
+}
+#endif
+
+#ifdef LIBCORO_FEATURE_NETWORKING
+
+void coro::default_executor::set_io_scheduler_options(io_scheduler::options io_scheduler_options)
+{
+    s_io_scheduler_options = io_scheduler_options;
+}
+
+std::shared_ptr<coro::io_scheduler> coro::default_executor::get_io_scheduler()
+{
+    return m_io_scheduler;
+}
+
+#else
+
+void coro::default_executor::set_thread_pool_options(thread_pool::options thread_pool_options)
+{
+    s_thread_pool_options = thread_pool_options;
+}
+
+std::shared_ptr<coro::thread_pool> coro::default_executor::get_thread_pool()
+{
+    return m_thread_pool;
+}
+
+#endif

src/facade.cpp

@@ -15,7 +15,7 @@ TEST_CASE("condition_variable single waiter", "[condition_variable]")
 
     std::cout << "condition_variable single waiter" << std::endl;
 
-    auto                     sched = coro::facade::instance()->get_io_scheduler();
+    auto                     sched = coro::default_executor::instance()->get_io_scheduler();
     coro::mutex              m;
     coro::condition_variable cv;
 
@@ -106,7 +106,7 @@ TEST_CASE("condition_variable one notifier and one waiter", "[condition_variable
 
     struct BaseParams
     {
-        std::shared_ptr<coro::io_scheduler> sched = coro::facade::instance()->get_io_scheduler();
+        std::shared_ptr<coro::io_scheduler> sched = coro::default_executor::instance()->get_io_scheduler();
         coro::mutex                         m;
         coro::condition_variable            cv{sched};
     };
@@ -156,7 +156,7 @@ TEST_CASE("condition_variable notify_all", "[condition_variable]")
 
     struct BaseParams
     {
-        std::shared_ptr<coro::io_scheduler> sched = coro::facade::instance()->get_io_scheduler();
+        std::shared_ptr<coro::io_scheduler> sched = coro::default_executor::instance()->get_io_scheduler();
         ;
         coro::mutex              m;
         coro::condition_variable cv{sched};
@@ -209,7 +209,7 @@ TEST_CASE("condition_variable for thread-safe-queue between producers and consum
 
     struct BaseParams
     {
-        coro::facade*            sched = coro::facade::instance();
+        coro::default_executor*  sched = coro::default_executor::instance();
         coro::mutex              m;
         coro::condition_variable cv;
         std::atomic_bool         cancel{false};