rename exec::fork to exec::fork_join, fix msvc warnings (#1550)

Author: ericniebler

include/exec/fork.hpp include/exec/fork_join.hppinclude/exec/fork.hpp renamed to include/exec/fork_join.hpp

@@ -23,7 +23,7 @@
 namespace exec {
   struct PREDECESSOR_RESULTS_ARE_NOT_DECAY_COPYABLE { };
 
-  struct fork_t {
+  struct fork_join_t {
     template <class Sndr, class... Closures>
     struct _sndr_t;
 
@@ -135,12 +135,12 @@ namespace exec {
       using _env_t = stdexec::__call_result_t<stdexec::__env::__fwd_fn, stdexec::env_of_t<Rcvr>>;
       using _child_completions_t = stdexec::__completion_signatures_of_t<Sndr, _env_t>;
       using _domain_t = stdexec::__early_domain_of_t<Sndr, stdexec::__none_such>;
-      using _when_all_sndr_t = fork_t::_when_all_sndr_t<_child_completions_t, Closures, _domain_t>;
+      using _when_all_sndr_t = fork_join_t::_when_all_sndr_t<_child_completions_t, Closures, _domain_t>;
       using _child_opstate_t =
         stdexec::connect_result_t<Sndr, stdexec::__rcvr_ref_t<_opstate_t, _env_t>>;
       using _fork_opstate_t =
         stdexec::connect_result_t<_when_all_sndr_t, stdexec::__rcvr_ref_t<Rcvr>>;
-      using _cache_sndr_t = fork_t::_cache_sndr_t<_variant_t<_child_completions_t>, _domain_t>;
+      using _cache_sndr_t = fork_join_t::_cache_sndr_t<_variant_t<_child_completions_t>, _domain_t>;
 
       STDEXEC_ATTRIBUTE(host, device)
 
@@ -246,10 +246,10 @@ namespace exec {
   };
 
   template <>
-  struct fork_t::_env_t<stdexec::__none_such> { };
+  struct fork_join_t::_env_t<stdexec::__none_such> { };
 
   template <class Sndr, class... Closures>
-  struct fork_t::_sndr_t {
+  struct fork_join_t::_sndr_t {
     using sender_concept = stdexec::sender_t;
     using _closures_t = stdexec::__tuple_for<Closures...>;
 
@@ -267,7 +267,7 @@ namespace exec {
       } else if constexpr (!__decay_copyable_results_t::value) {
         return _ERROR_<
           _WHAT_<>(PREDECESSOR_RESULTS_ARE_NOT_DECAY_COPYABLE),
-          _IN_ALGORITHM_(exec::fork_t)
+          _IN_ALGORITHM_(exec::fork_join_t)
         >();
       } else {
         using _sndr_t = _when_all_sndr_t<_child_completions_t, _closures_t, _domain_t>;
@@ -297,10 +297,10 @@ namespace exec {
       return stdexec::__env::__fwd_fn{}(stdexec::get_env(sndr_));
     }
 
-    STDEXEC_ATTRIBUTE(no_unique_address) fork_t _tag_;
+    STDEXEC_ATTRIBUTE(no_unique_address) fork_join_t _tag_;
     stdexec::__tuple_for<Closures...> _closures_;
     Sndr sndr_;
   };
 
-  inline constexpr fork_t fork{};
+  inline constexpr fork_join_t fork_join{};
 } // namespace exec

include/exec/just_from.hpp

@@ -58,7 +58,7 @@ namespace exec {
       template <class... Ts>
         requires stdexec::__sigs::__is_compl_sig<_set_tag_t(Ts...)>
       auto
-        operator()(Ts&&... ts) const noexcept -> stdexec::completion_signatures<_set_tag_t(Ts...)> {
+        operator()(Ts&&...) const noexcept -> stdexec::completion_signatures<_set_tag_t(Ts...)> {
         return {};
       }
     };

include/exec/system_context.hpp

@@ -71,7 +71,7 @@ namespace exec {
         stdexec::set_stopped(std::forward<_Rcvr>(__rcvr_));
       }
 
-      [[no_unique_address]]
+      STDEXEC_ATTRIBUTE(no_unique_address)
       _Rcvr __rcvr_;
     };
 
@@ -412,10 +412,10 @@ namespace exec {
         __forward_args_helper_t)]{};
 
       /// The function to be executed to perform the bulk work.
-      [[no_unique_address]]
+      STDEXEC_ATTRIBUTE(no_unique_address)
       _Fn __fun_;
       /// The receiver object that receives completion from the work described by the sender.
-      [[no_unique_address]]
+      STDEXEC_ATTRIBUTE(no_unique_address)
       _Rcvr __rcvr_;
 
       /// Function that prepares the preallocated storage for calling the backend.
@@ -630,7 +630,7 @@ namespace exec {
     /// The size of the bulk operation.
     _Size __size_;
     /// The function to be executed to perform the bulk work.
-    [[no_unique_address]]
+    STDEXEC_ATTRIBUTE(no_unique_address)
     _Fn __fun_;
   };
 

include/stdexec/__detail/__env.hpp

@@ -678,7 +678,7 @@ namespace stdexec {
     using __scheduler_t = __decay_t<_Scheduler>;
     using __sched_domain_t = __query_result_or_t<get_domain_t, __scheduler_t, default_domain>;
     _Scheduler __sched_;
-    STDEXEC_ATTRIBUTE(no_unique_address) _LateDomain __late_domain_;
+    STDEXEC_ATTRIBUTE(no_unique_address) _LateDomain __late_domain_{};
 
     auto query(get_completion_scheduler_t<set_value_t>) const noexcept -> __scheduler_t {
       return __sched_;

include/stdexec/__detail/__read_env.hpp

@@ -120,7 +120,7 @@ namespace stdexec {
       };
 
       static constexpr auto submit =
-        []<class _Sender, class _Receiver>(const _Sender& __sndr, _Receiver __rcvr) noexcept
+        []<class _Sender, class _Receiver>(const _Sender&, _Receiver __rcvr) noexcept
         requires std::is_reference_v<__call_result_t<__data_of<_Sender>, env_of_t<_Receiver>>>
       {
         static_assert(sender_expr_for<_Sender, __read_env_t>);

include/stdexec/__detail/__sync_wait.hpp

@@ -59,6 +59,11 @@ namespace stdexec {
         return __loop_->get_scheduler();
       }
 
+      [[nodiscard]]
+      constexpr auto query(__root_t) const noexcept -> bool {
+        return true;
+      }
+
       // static constexpr auto query(__debug::__is_debug_env_t) noexcept -> bool {
       //   return true;
       // }

test/exec/test_fork.cpp

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "exec/fork.hpp"
+#include "exec/fork_join.hpp"
 #include "exec/just_from.hpp"
 #include "test_common/type_helpers.hpp"
 
@@ -23,13 +23,13 @@
 using namespace stdexec;
 
 namespace {
-  TEST_CASE("fork is a sender", "[adaptors][fork]") {
-    auto sndr = exec::fork(just(), then([] { }));
+  TEST_CASE("fork_join is a sender", "[adaptors][fork_join]") {
+    auto sndr = exec::fork_join(just(), then([] { }));
     STATIC_REQUIRE(sender<decltype(sndr)>);
   }
 
-  TEST_CASE("fork is a sender in empty env", "[adaptors][fork]") {
-    auto sndr = exec::fork(just(), then([] { }));
+  TEST_CASE("fork_join is a sender in empty env", "[adaptors][fork_join]") {
+    auto sndr = exec::fork_join(just(), then([] { }));
     STATIC_REQUIRE(sender_in<decltype(sndr), env<>>);
     STATIC_REQUIRE(
       set_equivalent<
@@ -38,7 +38,7 @@ namespace {
       >);
   }
 
-  TEST_CASE("fork broadcasts results to multiple continuations", "[adaptors][fork]") {
+  TEST_CASE("fork_join broadcasts results to multiple continuations", "[adaptors][fork_join]") {
     auto fn = [](auto sink) {
       sink(42);
       return completion_signatures<
@@ -47,7 +47,7 @@ namespace {
         set_value_t(int, int, int)
       >{};
     };
-    auto sndr = exec::fork(
+    auto sndr = exec::fork_join(
       exec::just_from(fn),
       then([](auto&&... is) {
         CHECK(sizeof...(is) == 1);

test/exec/test_system_context.cpp

@@ -15,8 +15,6 @@
  */
 
 #include <thread>
-#include <iostream>
-#include <chrono>
 
 #define STDEXEC_SYSTEM_CONTEXT_HEADER_ONLY 1
 
@@ -310,21 +308,21 @@ struct my_parallel_scheduler_backend_impl
 };
 
 struct my_inline_scheduler_backend_impl : scr::parallel_scheduler_backend {
-  void schedule(std::span<std::byte> s, scr::receiver& r) noexcept override {
+  void schedule(std::span<std::byte>, scr::receiver& r) noexcept override {
     r.set_value();
   }
 
   void schedule_bulk_chunked(
     uint32_t count,
-    std::span<std::byte> s,
+    std::span<std::byte>,
     scr::bulk_item_receiver& r) noexcept override {
     r.execute(0, count);
     r.set_value();
   }
 
   void schedule_bulk_unchunked(
     uint32_t count,
-    std::span<std::byte> s,
+    std::span<std::byte>,
     scr::bulk_item_receiver& r) noexcept override {
     for (uint32_t i = 0; i < count; ++i)
       r.execute(i, i + 1);

test/stdexec/algos/adaptors/test_bulk.cpp

@@ -1103,7 +1103,7 @@ namespace {
     // The customization will return a different value
     basic_inline_scheduler<my_domain> sched;
     auto snd = ex::just(std::string{"hello"})
-             | exec::on(sched, ex::bulk(ex::par, 1, [&called](int, std::string x) {
+             | exec::on(sched, ex::bulk(ex::par, 1, [&called](int, std::string) {
                           called = true;
                         }));
     wait_for_value(std::move(snd), std::string{"hijacked"});
@@ -1122,13 +1122,13 @@ namespace {
     // The customization will return a different value
     basic_inline_scheduler<my_domain2> sched;
     auto snd = ex::just(std::string{"hello"}) | ex::continues_on(sched)
-             | ex::bulk(ex::par, 1, [&called](int, std::string x) { called = true; });
+             | ex::bulk(ex::par, 1, [&called](int, std::string) { called = true; });
     wait_for_value(std::move(snd), std::string{"hijacked"});
     REQUIRE_FALSE(called);
 
     // bulk_chunked will still use the default implementation
     auto snd2 = ex::just(std::string{"hello"}) | ex::continues_on(sched)
-              | ex::bulk_chunked(ex::par, 1, [&called](int, int, std::string x) { called = true; });
+              | ex::bulk_chunked(ex::par, 1, [&called](int, int, std::string) { called = true; });
     wait_for_value(std::move(snd2), std::string{"hello"});
     REQUIRE(called);
   }