Implement P2300 bulk adapter for HPX executors

libs/core/async_cuda/include/hpx/async_cuda/transform_stream.hpp

@@ -295,17 +295,25 @@ namespace hpx::cuda::experimental {
             using invoke_function_transformation =
                 invoke_function_transformation_helper<Args...>::type;
 
+#if defined(HPX_CLANG_VERSION)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
             template <typename Self, typename Env>
-            static consteval auto get_completion_signatures()
-                -> hpx::execution::experimental::
-                    transform_completion_signatures_of<std::decay_t<S>, Env,
-                        hpx::execution::experimental::completion_signatures<
-                            hpx::execution::experimental::set_error_t(
-                                std::exception_ptr)>,
-                        invoke_function_transformation>
+            static consteval auto get_completion_signatures() -> hpx::
+                execution::experimental::transform_completion_signatures<
+                    hpx::execution::experimental::completion_signatures_of_t<
+                        std::decay_t<S>, Env>,
+                    hpx::execution::experimental::completion_signatures<
+                        hpx::execution::experimental::set_error_t(
+                            std::exception_ptr)>,
+                    invoke_function_transformation>
             {
                 return {};
             }
+#if defined(HPX_CLANG_VERSION)
+#pragma clang diagnostic pop
+#endif
 
             constexpr auto get_env() const noexcept
             {

libs/core/async_mpi/include/hpx/async_mpi/transform_mpi.hpp

@@ -185,19 +185,26 @@ namespace hpx::mpi::experimental {
                 hpx::execution::experimental::completion_signatures<>;
 
             // clang-format off
+#if defined(HPX_CLANG_VERSION)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
             template <typename Env>
             friend auto tag_invoke(
                 hpx::execution::experimental::get_completion_signatures_t,
                 transform_mpi_sender const&, Env const&)
-            ->  hpx::execution::experimental::transform_completion_signatures_of<
-                    Sender, Env,
+            ->  hpx::execution::experimental::transform_completion_signatures<
+                    hpx::execution::experimental::completion_signatures_of_t<Sender, Env>,
                     hpx::execution::experimental::completion_signatures<
                         hpx::execution::experimental::set_error_t(std::exception_ptr)
                     >,
                     invoke_function_transformation,
                     default_set_error,
                     no_set_stopped_signature
                 >;
+#if defined(HPX_CLANG_VERSION)
+#pragma clang diagnostic pop
+#endif
             // clang-format on
 
             template <typename R>

libs/core/executors/CMakeLists.txt

@@ -26,6 +26,9 @@ set(executors_headers
     hpx/executors/execution_policy_parameters.hpp
     hpx/executors/execution_policy_scheduling_property.hpp
     hpx/executors/execution_policy.hpp
+    hpx/executors/executor_scheduler.hpp
+    hpx/executors/executor_scheduler_bulk.hpp
+    hpx/executors/fwd/executor_scheduler_fwd.hpp
     hpx/executors/explicit_scheduler_executor.hpp
     hpx/executors/fork_join_executor.hpp
     hpx/executors/limiting_executor.hpp

libs/core/executors/include/hpx/executors/executor_scheduler.hpp

@@ -0,0 +1,142 @@
+//  Copyright (c) 2026 The STE||AR-Group
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  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)
+
+/// \file parallel/executors/executor_scheduler.hpp
+
+#pragma once
+
+#include <hpx/config.hpp>
+#include <hpx/executors/fwd/executor_scheduler_fwd.hpp>
+#include <hpx/modules/errors.hpp>
+#include <hpx/modules/execution.hpp>
+#include <hpx/modules/execution_base.hpp>
+
+#include <concepts>
+#include <exception>
+#include <type_traits>
+#include <utility>
+
+namespace hpx::execution::experimental {
+    ///////////////////////////////////////////////////////////////////////////
+    HPX_CXX_CORE_EXPORT template <typename Executor, typename Receiver>
+    struct executor_operation_state
+    {
+        HPX_NO_UNIQUE_ADDRESS std::decay_t<Executor> exec_;
+        HPX_NO_UNIQUE_ADDRESS std::decay_t<Receiver> receiver_;
+
+        template <typename Exec, typename Recv>
+        executor_operation_state(Exec&& exec, Recv&& recv)
+          : exec_(HPX_FORWARD(Exec, exec))
+          , receiver_(HPX_FORWARD(Recv, recv))
+        {
+        }
+
+        executor_operation_state(executor_operation_state&&) = delete;
+        executor_operation_state(executor_operation_state const&) = delete;
+        executor_operation_state& operator=(
+            executor_operation_state&&) = delete;
+        executor_operation_state& operator=(
+            executor_operation_state const&) = delete;
+
+        ~executor_operation_state() = default;
+
+        friend void tag_invoke(start_t, executor_operation_state& os) noexcept
+        {
+            hpx::detail::try_catch_exception_ptr(
+                [&]() {
+                    hpx::parallel::execution::post(os.exec_, [&os]() mutable {
+                        hpx::execution::experimental::set_value(
+                            HPX_MOVE(os.receiver_));
+                    });
+                },
+                [&](std::exception_ptr ep) {
+                    hpx::execution::experimental::set_error(
+                        HPX_MOVE(os.receiver_), HPX_MOVE(ep));
+                });
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    HPX_CXX_CORE_EXPORT template <typename Executor>
+    struct executor_sender
+    {
+        using sender_concept = hpx::execution::experimental::sender_t;
+
+        HPX_NO_UNIQUE_ADDRESS std::decay_t<Executor> exec_;
+
+        using completion_signatures =
+            hpx::execution::experimental::completion_signatures<
+                hpx::execution::experimental::set_value_t(),
+                hpx::execution::experimental::set_error_t(std::exception_ptr)>;
+
+        template <typename Env>
+        friend auto tag_invoke(
+            hpx::execution::experimental::get_completion_signatures_t,
+            executor_sender const&, Env) noexcept -> completion_signatures;
+
+        friend constexpr auto tag_invoke(
+            hpx::execution::experimental::get_completion_scheduler_t<
+                hpx::execution::experimental::set_value_t>,
+            executor_sender const& s) noexcept
+        {
+            return executor_scheduler<Executor>{s.exec_};
+        }
+
+        template <typename Receiver>
+        friend executor_operation_state<Executor, Receiver> tag_invoke(
+            connect_t, executor_sender&& s, Receiver&& receiver)
+        {
+            return {HPX_MOVE(s.exec_), HPX_FORWARD(Receiver, receiver)};
+        }
+
+        template <typename Receiver>
+        friend executor_operation_state<Executor, Receiver> tag_invoke(
+            connect_t, executor_sender const& s, Receiver&& receiver)
+        {
+            return {s.exec_, HPX_FORWARD(Receiver, receiver)};
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    HPX_CXX_CORE_EXPORT template <typename Executor>
+    struct executor_scheduler
+    {
+        using executor_type = std::decay_t<Executor>;
+
+        HPX_NO_UNIQUE_ADDRESS executor_type exec_;
+
+        constexpr executor_scheduler() = default;
+
+        template <typename Exec>
+            requires(!std::is_same_v<std::decay_t<Exec>, executor_scheduler>)
+        explicit executor_scheduler(Exec&& exec)
+          : exec_(HPX_FORWARD(Exec, exec))
+        {
+        }
+
+        constexpr bool operator==(executor_scheduler const& rhs) const noexcept
+        {
+            return exec_ == rhs.exec_;
+        }
+
+        constexpr bool operator!=(executor_scheduler const& rhs) const noexcept
+        {
+            return !(*this == rhs);
+        }
+
+        friend executor_sender<Executor> tag_invoke(
+            schedule_t, executor_scheduler&& sched)
+        {
+            return {HPX_MOVE(sched.exec_)};
+        }
+
+        friend executor_sender<Executor> tag_invoke(
+            schedule_t, executor_scheduler const& sched)
+        {
+            return {sched.exec_};
+        }
+    };
+}    // namespace hpx::execution::experimental