Merge pull request #1603 from ericniebler/promote-inline-scheduler

promote `inline_scheduler` to the `stdexec` namespace per P3552

Author: ericniebler

examples/nvexec/maxwell_cpu_st.cpp

@@ -53,7 +53,7 @@ auto main(int argc, char *argv[]) -> int {
   report_header();
 
   if (value(params, "run-inline-scheduler")) {
-    run_snr_on("CPU (snr inline)", exec::inline_scheduler{});
+    run_snr_on("CPU (snr inline)", stdexec::inline_scheduler{});
   }
 
   if (value(params, "run-cpp")) {

include/exec/async_scope.hpp

@@ -691,7 +691,7 @@ namespace exec {
       }
 
       [[nodiscard]]
-      auto query(get_scheduler_t) const noexcept -> __inln::__scheduler {
+      auto query(get_scheduler_t) const noexcept -> stdexec::inline_scheduler {
         return {};
       }
     };

include/exec/at_coroutine_exit.hpp

@@ -237,7 +237,7 @@ namespace exec {
 
         bool __is_unhandled_stopped_{false};
         std::tuple<_Ts&...> __args_{};
-        __any_scheduler __scheduler_{inline_scheduler{}};
+        __any_scheduler __scheduler_{stdexec::inline_scheduler{}};
       };
 
       __coro::coroutine_handle<__promise> __coro_;

include/exec/inline_scheduler.hpp

@@ -20,5 +20,5 @@
 namespace exec {
   // A simple scheduler that executes its continuation inline, on the
   // thread of the caller of start().
-  using inline_scheduler = stdexec::__inln::__scheduler;
+  using inline_scheduler [[deprecated("Use stdexec::inline_scheduler instead")]] = stdexec::inline_scheduler;
 } // namespace exec

include/exec/on_coro_disposition.hpp

@@ -183,7 +183,7 @@ namespace exec {
         using __get_disposition_callback_t = task_disposition (*)(void*) noexcept;
         __coro::coroutine_handle<> __parent_{};
         __get_disposition_callback_t __get_disposition_callback_{nullptr};
-        __any_scheduler __scheduler_{inline_scheduler{}};
+        __any_scheduler __scheduler_{stdexec::inline_scheduler{}};
       };
 
       __coro::coroutine_handle<__promise> __coro_;

include/exec/task.hpp

@@ -27,7 +27,6 @@
 
 #include "any_sender_of.hpp"
 #include "at_coroutine_exit.hpp"
-#include "inline_scheduler.hpp"
 #include "scope.hpp"
 
 STDEXEC_PRAGMA_PUSH()
@@ -96,7 +95,7 @@ namespace exec {
       static constexpr bool __with_scheduler = _SchedulerAffinity == __scheduler_affinity::__sticky;
 
       STDEXEC_ATTRIBUTE(no_unique_address)
-      __if_c<__with_scheduler, __any_scheduler, __ignore> __scheduler_{exec::inline_scheduler{}};
+      __if_c<__with_scheduler, __any_scheduler, __ignore> __scheduler_{stdexec::inline_scheduler{}};
       inplace_stop_token __stop_token_;
 
      public:
@@ -336,7 +335,7 @@ namespace exec {
       }
 
      private:
-      using __scheduler_t = __query_result_or_t<get_scheduler_t, _Context, inline_scheduler>;
+      using __scheduler_t = __query_result_or_t<get_scheduler_t, _Context, stdexec::inline_scheduler>;
 
       struct __final_awaitable {
         static constexpr auto await_ready() noexcept -> bool {

include/stdexec/__detail/__inline_scheduler.hpp

@@ -17,63 +17,73 @@
 
 #include "__execution_fwd.hpp"
 
-#include "__basic_sender.hpp"
-#include "__cpo.hpp"
 #include "__env.hpp"
 #include "__receivers.hpp"
 #include "__schedulers.hpp"
-#include "__utility.hpp"
 
 namespace stdexec {
-  namespace __inln {
-    struct __schedule_t { };
+  struct inline_scheduler {
+   private:
+    template <class _Receiver>
+    struct __opstate {
+      using __id = __opstate;
+      using __t = __opstate;
 
-    struct __scheduler {
-      using __t = __scheduler;
-      using __id = __scheduler;
+      using operation_state_concept = operation_state_t;
 
-      template <class _Tag = __schedule_t>
-      STDEXEC_ATTRIBUTE(nodiscard, host, device)
-      auto schedule() const noexcept {
-        return __make_sexpr<_Tag>();
-      }
-
-      [[nodiscard]]
-      auto query(get_forward_progress_guarantee_t) const noexcept -> forward_progress_guarantee {
-        return forward_progress_guarantee::weakly_parallel;
+      STDEXEC_ATTRIBUTE(host, device)
+      constexpr void start() noexcept {
+        stdexec::set_value(static_cast<_Receiver&&>(__rcvr_));
       }
 
-      auto operator==(const __scheduler&) const noexcept -> bool = default;
+      _Receiver __rcvr_;
     };
 
-    struct __env {
+    struct __attrs {
+      STDEXEC_ATTRIBUTE(nodiscard, host, device)
       static constexpr auto query(__is_scheduler_affine_t) noexcept -> bool {
         return true;
       }
 
-      [[nodiscard]]
-      constexpr auto query(get_completion_scheduler_t<set_value_t>) const noexcept -> __scheduler {
+      STDEXEC_ATTRIBUTE(nodiscard, host, device)
+      static constexpr auto query(get_completion_scheduler_t<set_value_t>) noexcept //
+        -> inline_scheduler {
         return {};
       }
     };
-  } // namespace __inln
 
-  template <>
-  struct __sexpr_impl<__inln::__schedule_t> : __sexpr_defaults {
-    static constexpr auto get_attrs = [](__ignore) noexcept {
-      return __inln::__env();
+    struct __sender {
+      using __id = __sender;
+      using __t = __sender;
+
+      using sender_concept = sender_t;
+      using completion_signatures = stdexec::completion_signatures<set_value_t()>;
+
+      template <class _Receiver>
+      STDEXEC_ATTRIBUTE(nodiscard, host, device)
+      static constexpr auto connect(_Receiver __rcvr) noexcept -> __opstate<_Receiver> {
+        return {static_cast<_Receiver&&>(__rcvr)};
+      }
+
+      STDEXEC_ATTRIBUTE(nodiscard, host, device)
+      static constexpr auto get_env() noexcept -> __attrs {
+        return {};
+      }
     };
 
-    static constexpr auto get_completion_signatures =
-      [](__ignore, __ignore = {}) noexcept -> completion_signatures<set_value_t()> {
+   public:
+    using __t = inline_scheduler;
+    using __id = inline_scheduler;
+
+    using scheduler_concept = scheduler_t;
+
+    STDEXEC_ATTRIBUTE(nodiscard, host, device)
+    static constexpr auto schedule() noexcept -> __sender {
       return {};
-    };
+    }
 
-    static constexpr auto start =
-      []<class _Receiver>(__ignore, _Receiver& __rcvr) noexcept -> void {
-      stdexec::set_value(static_cast<_Receiver&&>(__rcvr));
-    };
+    auto operator==(const inline_scheduler&) const noexcept -> bool = default;
   };
 
-  static_assert(__is_scheduler_affine<schedule_result_t<__inln::__scheduler>>);
+  static_assert(__is_scheduler_affine<schedule_result_t<inline_scheduler>>);
 } // namespace stdexec

include/stdexec/__detail/__on.hpp

@@ -146,7 +146,7 @@ namespace stdexec {
           // If __is_root_env<_Env> is true, then this sender has no parent, so there is
           // no need to restore the execution context. We can use the inline scheduler
           // as the scheduler if __env does not have one.
-          using __default_t = __if_c<__is_root_env<_Env>, __inln::__scheduler, __none_such>;
+          using __default_t = __if_c<__is_root_env<_Env>, inline_scheduler, __none_such>;
 
           // If scheduler<_Data> is true, then this sender was created with `on(sch, sndr)`.
           // In that case, the child sender is not a predecessor, so its completion

test/exec/test_any_sender.cpp

@@ -509,7 +509,7 @@ namespace {
 
   TEST_CASE("any scheduler with inline_scheduler", "[types][any_sender]") {
     static_assert(scheduler<my_scheduler<>>);
-    my_scheduler<> scheduler = exec::inline_scheduler();
+    my_scheduler<> scheduler = stdexec::inline_scheduler();
     my_scheduler<> copied = scheduler;
     CHECK(copied == scheduler);
 
@@ -528,7 +528,7 @@ namespace {
     using my_scheduler2 =
       my_scheduler<get_forward_progress_guarantee.signature<forward_progress_guarantee()>>;
     static_assert(scheduler<my_scheduler2>);
-    my_scheduler2 scheduler = exec::inline_scheduler();
+    my_scheduler2 scheduler = stdexec::inline_scheduler();
     my_scheduler2 copied = scheduler;
     CHECK(copied == scheduler);
 
@@ -540,7 +540,7 @@ namespace {
 
     CHECK(
       get_forward_progress_guarantee(scheduler)
-      == get_forward_progress_guarantee(exec::inline_scheduler()));
+      == get_forward_progress_guarantee(stdexec::inline_scheduler()));
 
     bool called = false;
     sync_wait(std::move(sched) | then([&] { called = true; }));
@@ -634,7 +634,7 @@ namespace {
       any_receiver_ref<completion_signatures<set_stopped_t(), set_error_t(std::exception_ptr)>>;
     using sender_t = receiver_ref::any_sender<>;
     using scheduler_t = sender_t::any_scheduler<>;
-    scheduler_t scheduler = exec::inline_scheduler();
+    scheduler_t scheduler = stdexec::inline_scheduler();
     {
       auto op = connect(schedule(scheduler), expect_void_receiver{});
       stdexec::start(op);
@@ -656,7 +656,7 @@ namespace {
       any_receiver_ref<completion_signatures<set_stopped_t(), set_error_t(std::exception_ptr)>>;
     using sender_t = receiver_ref::any_sender<>;
     using scheduler_t = sender_t::any_scheduler<>;
-    scheduler_t scheduler = exec::inline_scheduler();
+    scheduler_t scheduler = stdexec::inline_scheduler();
     auto sched = schedule(scheduler);
     scheduler = stopped_scheduler();
     {
@@ -744,7 +744,7 @@ namespace {
     using sender_t = receiver_ref::any_sender<>;
     using scheduler_t = sender_t::any_scheduler<>;
     {
-      scheduler_t scheduler = exec::inline_scheduler{};
+      scheduler_t scheduler = stdexec::inline_scheduler{};
       scheduler = counting_scheduler{};
       {
         auto op = connect(schedule(scheduler), expect_value_receiver<>{});

test/exec/test_task.cpp

@@ -174,8 +174,8 @@ namespace {
   }
 
   TEST_CASE("Use two inline schedulers", "[types][sticky][task]") {
-    scheduler auto scheduler1 = exec::inline_scheduler{};
-    scheduler auto scheduler2 = exec::inline_scheduler{};
+    scheduler auto scheduler1 = stdexec::inline_scheduler{};
+    scheduler auto scheduler2 = stdexec::inline_scheduler{};
     sync_wait(when_all(
       schedule(scheduler1) | then([] { __thread_id = 0; }),
       schedule(scheduler2) | then([] { __thread_id = 0; })));