Add ExecutionContext concept and consoldiate test contexts

Author: vinniefalco

bench/bench.cpp

@@ -7,8 +7,8 @@
 // Official repository: https://github.com/cppalliance/capy
 //
 
+#include <boost/capy/concept/execution_context.hpp>
 #include <boost/capy/ex/run_async.hpp>
-#include <boost/capy/ex/execution_context.hpp>
 #include <boost/capy/ex/run.hpp>
 #include <boost/capy/ex/strand.hpp>
 #include <boost/capy/task.hpp>
@@ -21,48 +21,53 @@ using namespace boost::capy;
 
 //-----------------------------------------------
 //
-// Test Execution Context
+// Bench Execution Context
 //
 // A minimal execution context for benchmarking.
 //
 //-----------------------------------------------
 
-class test_context : public execution_context
+class bench_io_context : public execution_context
 {
 public:
-    ~test_context()
+    class executor_type;
+
+    ~bench_io_context()
     {
         shutdown();
         destroy();
     }
+
+    executor_type
+    get_executor() noexcept;
 };
 
 //-----------------------------------------------
 //
-// Test Executor
+// Bench Executor
 //
 // A minimal executor that satisfies the capy
 // Executor concept. Dispatches inline for
 // benchmarking pure coroutine overhead.
 //
 //-----------------------------------------------
 
-class test_executor
+class bench_io_context::executor_type
 {
-    test_context* ctx_;
+    bench_io_context* ctx_;
 
 public:
-    explicit test_executor(test_context& ctx) noexcept
+    explicit executor_type(bench_io_context& ctx) noexcept
         : ctx_(&ctx)
     {
     }
 
-    test_context& context() const noexcept
+    bench_io_context& context() const noexcept
     {
         return *ctx_;
     }
 
-    bool operator==(test_executor const& other) const noexcept
+    bool operator==(executor_type const& other) const noexcept
     {
         return ctx_ == other.ctx_;
     }
@@ -93,6 +98,15 @@ class test_executor
     }
 };
 
+inline bench_io_context::executor_type
+bench_io_context::get_executor() noexcept
+{
+    return executor_type(*this);
+}
+
+static_assert(Executor<bench_io_context::executor_type>);
+static_assert(ExecutionContext<bench_io_context>);
+
 //-----------------------------------------------
 //
 // Foreign Awaitable
@@ -251,14 +265,14 @@ int main()
 {
     constexpr std::size_t iterations = 1000000;
 
-    test_context ctx1;
-    test_context ctx2;
+    bench_io_context ctx1;
+    bench_io_context ctx2;
 
-    test_executor ex1(ctx1);
-    test_executor ex2(ctx2);
+    auto ex1 = ctx1.get_executor();
+    auto ex2 = ctx2.get_executor();
 
-    strand<test_executor> strand1(ex1);
-    strand<test_executor> strand2(ex2);
+    strand<bench_io_context::executor_type> strand1(ex1);
+    strand<bench_io_context::executor_type> strand2(ex2);
 
     foreign_awaitable foreign;
 

include/boost/capy/concept/execution_context.hpp

@@ -0,0 +1,55 @@
+//
+// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/capy
+//
+
+#ifndef BOOST_CAPY_CONCEPT_EXECUTION_CONTEXT_HPP
+#define BOOST_CAPY_CONCEPT_EXECUTION_CONTEXT_HPP
+
+#include <boost/capy/detail/config.hpp>
+#include <boost/capy/concept/executor.hpp>
+#include <boost/capy/ex/execution_context.hpp>
+
+#include <concepts>
+
+namespace boost {
+namespace capy {
+
+/** Concept for execution context types.
+
+    An execution context represents a place where function objects
+    are executed. A type meeting the ExecutionContext requirements
+    must be publicly derived from execution_context and provide
+    an associated executor type.
+
+    @par Required Operations
+
+    @li `X::executor_type` - A type meeting the Executor requirements.
+
+    @li `x.get_executor()` - Returns an executor object associated
+        with the execution context.
+
+    @par Destructor Semantics
+
+    The destructor destroys all unexecuted function objects that
+    were submitted via an executor associated with this context.
+
+    @tparam X The type to check for execution context conformance.
+*/
+template<class X>
+concept ExecutionContext =
+    std::derived_from<X, execution_context> &&
+    requires(X& x) {
+        typename X::executor_type;
+        requires Executor<typename X::executor_type>;
+        { x.get_executor() } noexcept -> std::same_as<typename X::executor_type>;
+    };
+
+} // capy
+} // boost
+
+#endif

include/boost/capy/test/run_blocking.hpp

@@ -11,8 +11,8 @@
 #define BOOST_CAPY_TEST_RUN_BLOCKING_HPP
 
 #include <boost/capy/coro.hpp>
+#include <boost/capy/concept/execution_context.hpp>
 #include <boost/capy/concept/executor.hpp>
-#include <boost/capy/ex/execution_context.hpp>
 #include <boost/capy/ex/run_async.hpp>
 #include <boost/capy/ex/system_context.hpp>
 
@@ -28,6 +28,28 @@ namespace boost {
 namespace capy {
 namespace test {
 
+struct inline_executor;
+
+/** Execution context for inline blocking execution.
+
+    This execution context is used with inline_executor for
+    blocking synchronous execution. It satisfies the
+    ExecutionContext concept requirements.
+
+    @see inline_executor
+    @see run_blocking
+*/
+class inline_context : public execution_context
+{
+public:
+    using executor_type = inline_executor;
+
+    inline_context() = default;
+
+    executor_type
+    get_executor() noexcept;
+};
+
 /** Synchronous executor that executes inline and disallows posting.
 
     This executor executes work synchronously on the calling thread
@@ -53,10 +75,9 @@ struct inline_executor
 
         @return A reference to a function-local static `inline_context`.
     */
-    execution_context&
+    inline_context&
     context() const noexcept
     {
-        struct inline_context : public execution_context {};
         static inline_context ctx;
         return ctx;
     }
@@ -97,7 +118,14 @@ struct inline_executor
     }
 };
 
+inline inline_context::executor_type
+inline_context::get_executor() noexcept
+{
+    return inline_executor{};
+}
+
 static_assert(Executor<inline_executor>);
+static_assert(ExecutionContext<inline_context>);
 
 //----------------------------------------------------------
 //

test/unit/concept/execution_context.cpp

@@ -0,0 +1,11 @@
+//
+// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/cppalliance/capy
+//
+
+// Test that header file is self-contained.
+#include <boost/capy/concept/execution_context.hpp>

test/unit/ex/async_event.cpp

@@ -31,7 +31,7 @@ namespace {
 struct queuing_executor
 {
     std::queue<coro>* queue_;
-    test_context* ctx_ = nullptr;
+    test_io_context* ctx_ = nullptr;
 
     explicit queuing_executor(std::queue<coro>& q)
         : queue_(&q)
@@ -45,7 +45,7 @@ struct queuing_executor
 
     execution_context& context() const noexcept
     {
-        return ctx_ ? *ctx_ : default_test_context();
+        return ctx_ ? *ctx_ : default_test_io_context();
     }
 
     void on_work_started() const noexcept {}