grpc 1.70.1 → 1.72.0

data/src/core/lib/promise/map.h

@@ -19,6 +19,7 @@
 #include <stddef.h>
 
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
 #include "absl/status/status.h"
@@ -31,23 +32,108 @@ namespace grpc_core {
 
 namespace promise_detail {
 
-// Implementation of mapping combinator - use this via the free function below!
-// Promise is the type of promise to poll on, Fn is a function that takes the
-// result of Promise and maps it to some new type.
-template <typename Promise, typename Fn, typename SfinaeVoid = void>
-class Map;
+template <typename Fn, typename Arg, typename SfinaeVoid = void>
+class WrappedFn;
 
+template <typename Fn, typename Arg>
+class WrappedFn<
+    Fn, Arg, std::enable_if_t<!std::is_void_v<std::invoke_result_t<Fn, Arg>>>> {
+ public:
+  using Result = RemoveCVRef<std::invoke_result_t<Fn, Arg>>;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit WrappedFn(Fn&& fn)
+      : fn_(std::move(fn)) {}
+  WrappedFn(const WrappedFn&) = delete;
+  WrappedFn& operator=(const WrappedFn&) = delete;
+  WrappedFn(WrappedFn&&) = default;
+  WrappedFn& operator=(WrappedFn&&) = default;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()(Arg&& arg) {
+    return fn_(std::forward<Arg>(arg));
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Fn fn_;
+};
+
+template <typename Fn, typename Arg>
+class WrappedFn<
+    Fn, Arg, std::enable_if_t<std::is_void_v<std::invoke_result_t<Fn, Arg>>>> {
+ public:
+  using Result = Empty;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit WrappedFn(Fn&& fn)
+      : fn_(std::move(fn)) {}
+  WrappedFn(const WrappedFn&) = delete;
+  WrappedFn& operator=(const WrappedFn&) = delete;
+  WrappedFn(WrappedFn&&) = default;
+  WrappedFn& operator=(WrappedFn&&) = default;
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Empty operator()(Arg&& arg) {
+    fn_(std::forward<Arg>(arg));
+    return Empty{};
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Fn fn_;
+};
+
+template <typename PromiseResult, typename Fn0, typename Fn1>
+class FusedFns {
+  using InnerResult =
+      decltype(std::declval<Fn0>()(std::declval<PromiseResult>()));
+
+ public:
+  using Result = typename WrappedFn<Fn1, InnerResult>::Result;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION FusedFns(Fn0 fn0, Fn1 fn1)
+      : fn0_(std::move(fn0)), fn1_(std::move(fn1)) {}
+  FusedFns(const FusedFns&) = delete;
+  FusedFns& operator=(const FusedFns&) = delete;
+  FusedFns(FusedFns&&) = default;
+  FusedFns& operator=(FusedFns&&) = default;
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Result operator()(PromiseResult arg) {
+    InnerResult inner_result = fn0_(std::move(arg));
+    return fn1_(std::move(inner_result));
+  }
+
+ private:
+  GPR_NO_UNIQUE_ADDRESS Fn0 fn0_;
+  GPR_NO_UNIQUE_ADDRESS WrappedFn<Fn1, InnerResult> fn1_;
+};
+
+}  // namespace promise_detail
+
+// Mapping combinator.
+//
+// Input:
+// 1. The first argument is a promise.
+// 2. The second argument is a synchronous function.
+// 3. The synchronous function MUST be callable with the result type of the
+// promise.
+// 4. If the promise returns void, the synchronous function MUST be callable
+// with Empty.
+//
+// Return:
+// Mapping combinator returns Poll<T> where T is the return type of the
+// synchronous function.
+// Note: If the synchronous function returns void, the result type of the
+// mapping combinator will be Poll<Empty>.
+//
+// Polling the mapping combinator works as follows:
+// 1. Poll the promise.
+// 2. If the promise is pending, return Pending{}.
+// 3. If the promise is ready, return the result of the synchronous function.
+// Note: If the first argument to the Map is a promise factory instead of a
+// promise, Map will pass the promise returned by the promise factory as a
+// parameter to the synchronous function.
+//
+// Example:
+// TEST(MapTest, Works) {
+//   Promise<int> x = Map([]() { return 42; }, [](int i) { return i / 2; });
+//   EXPECT_THAT(x(), IsReady(21));
+// }
 template <typename Promise, typename Fn>
-class Map<Promise, Fn,
-          absl::enable_if_t<!std::is_void<
-#if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-              std::invoke_result_t<Fn, typename PromiseLike<Promise>::Result>
-#else
-              typename std::result_of<Fn(
-                  typename PromiseLike<Promise>::Result)>::type
-#endif
-              >::value>> {
+class Map {
+  using PromiseType = promise_detail::PromiseLike<Promise>;
+
  public:
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise promise, Fn fn)
       : promise_(std::move(promise)), fn_(std::move(fn)) {}
@@ -59,9 +145,8 @@ class Map<Promise, Fn,
   // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
   Map& operator=(Map&& other) = default;
 
-  using PromiseResult = typename PromiseLike<Promise>::Result;
-  using Result =
-      RemoveCVRef<decltype(std::declval<Fn>()(std::declval<PromiseResult>()))>;
+  using PromiseResult = typename PromiseType::Result;
+  using Result = typename promise_detail::WrappedFn<Fn, PromiseResult>::Result;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
     Poll<PromiseResult> r = promise_();
@@ -72,24 +157,25 @@ class Map<Promise, Fn,
   }
 
  private:
-  PromiseLike<Promise> promise_;
-  Fn fn_;
+  template <typename SomeOtherPromise, typename SomeOtherFn>
+  friend class Map;
+
+  GPR_NO_UNIQUE_ADDRESS PromiseType promise_;
+  GPR_NO_UNIQUE_ADDRESS promise_detail::WrappedFn<Fn, PromiseResult> fn_;
 };
 
-template <typename Promise, typename Fn>
-class Map<Promise, Fn,
-          absl::enable_if_t<std::is_void<
-#if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-              std::invoke_result_t<Fn, typename PromiseLike<Promise>::Result>
-#else
-              typename std::result_of<Fn(
-                  typename PromiseLike<Promise>::Result)>::type
-#endif
-              >::value>> {
+template <typename Promise, typename Fn0, typename Fn1>
+class Map<Map<Promise, Fn0>, Fn1> {
+  using InnerMapFn = decltype(std::declval<Map<Promise, Fn0>>().fn_);
+  using FusedFn =
+      promise_detail::FusedFns<typename Map<Promise, Fn0>::PromiseResult,
+                               InnerMapFn, Fn1>;
+  using PromiseType = typename Map<Promise, Fn0>::PromiseType;
+
  public:
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise promise, Fn fn)
-      : promise_(std::move(promise)), fn_(std::move(fn)) {}
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Map<Promise, Fn0> map, Fn1 fn1)
+      : promise_(std::move(map.promise_)),
+        fn_(FusedFn(std::move(map.fn_), std::move(fn1))) {}
 
   Map(const Map&) = delete;
   Map& operator=(const Map&) = delete;
@@ -98,33 +184,27 @@ class Map<Promise, Fn,
   // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
   Map& operator=(Map&& other) = default;
 
-  using PromiseResult = typename PromiseLike<Promise>::Result;
-  using Result = Empty;
+  using PromiseResult = typename Map<Promise, Fn0>::PromiseResult;
+  using Result = typename FusedFn::Result;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
     Poll<PromiseResult> r = promise_();
     if (auto* p = r.value_if_ready()) {
-      fn_(std::move(*p));
-      return Empty{};
+      return fn_(std::move(*p));
     }
     return Pending();
   }
 
  private:
-  PromiseLike<Promise> promise_;
-  Fn fn_;
-};
+  template <typename SomeOtherPromise, typename SomeOtherFn>
+  friend class Map;
 
-}  // namespace promise_detail
+  GPR_NO_UNIQUE_ADDRESS PromiseType promise_;
+  GPR_NO_UNIQUE_ADDRESS FusedFn fn_;
+};
 
-// Mapping combinator.
-// Takes a promise, and a synchronous function to mutate its result, and
-// returns a promise.
 template <typename Promise, typename Fn>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline promise_detail::Map<Promise, Fn>
-Map(Promise promise, Fn fn) {
-  return promise_detail::Map<Promise, Fn>(std::move(promise), std::move(fn));
-}
+Map(Promise, Fn) -> Map<Promise, Fn>;
 
 // Maps a promise to a new promise that returns a tuple of the original result
 // and a bool indicating whether there was ever a Pending{} value observed from
@@ -139,7 +219,7 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto CheckDelayed(Promise promise) {
       delayed = true;
       return Pending{};
     }
-    return std::make_tuple(std::move(r.value()), delayed);
+    return std::tuple(std::move(r.value()), delayed);
   };
 }
 
@@ -197,6 +277,43 @@ auto AddErrorPrefix(absl::string_view prefix, Promise promise) {
   });
 }
 
+// Input : A promise that resolves to Type T
+// Returns : A Map promise which contains the input promise and then discards
+// the return value of the input promise. the main use case for DiscardResult is
+// when you need to pass a promise as a parameter, and it returns a status or
+// some value which cannot be discarded. If this value is not used, the compiler
+// gives an error. DiscardResult helps to discard the return value of the
+// promise.
+template <typename Promise>
+auto DiscardResult(Promise promise) {
+  return Map(std::move(promise), [](auto) {});
+}
+
+// Given a promise, and N values, return a tuple with the resolved promise
+// first, and then the N values stapled to it.
+template <typename Promise, typename... Values>
+auto Staple(Promise promise, Values&&... values) {
+  return Map(std::move(promise), [values = std::tuple(std::forward<Values>(
+                                      values)...)](auto first_value) mutable {
+    return std::tuple_cat(std::tuple(std::move(first_value)),
+                          std::move(values));
+  });
+}
+
+// Same as Staple, but assumes a StatusOr<X>, and returns X, Values.
+template <typename Promise, typename... Values>
+auto TryStaple(Promise promise, Values&&... values) {
+  return Map(
+      std::move(promise),
+      [values = std::tuple(std::forward<Values>(values)...)](
+          auto first_value) mutable
+          -> absl::StatusOr<std::tuple<decltype(*first_value), Values...>> {
+        if (!first_value.ok()) return first_value.status();
+        return std::tuple_cat(std::tuple(std::move(*first_value)),
+                              std::move(values));
+      });
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_MAP_H

data/src/core/lib/promise/party.cc

@@ -18,6 +18,7 @@
 
 #include <atomic>
 #include <cstdint>
+#include <limits>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
@@ -131,6 +132,9 @@ class Party::Handle final : public Wakeable {
   Party* party_ ABSL_GUARDED_BY(mu_);
 };
 
+///////////////////////////////////////////////////////////////////////////////
+// Party::Participant
+
 Wakeable* Party::Participant::MakeNonOwningWakeable(Party* party) {
   if (handle_ == nullptr) {
     handle_ = new Handle(party);
@@ -146,6 +150,41 @@ Party::Participant::~Participant() {
   }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// Party::SpawnSerializer
+
+bool Party::SpawnSerializer::PollParticipantPromise() {
+  if (active_ == nullptr) {
+    active_ = next_.Pop().value_or(nullptr);
+  }
+  while (active_ != nullptr) {
+    // If the active participant is incomplete, we are also incomplete.
+    if (!active_->PollParticipantPromise()) return false;
+    // Otherwise, yank the next participant from the queue.
+    active_ = next_.Pop().value_or(nullptr);
+  }
+  // If we have no active participant and no more participants in the queue, we
+  // can return. `true` here indicates this participant is done - we never
+  // return that value as we'd not be able to continue polling.
+  // TODO(ctiller): if ArenaSpsc had a way to signal 'first item added' to the
+  // queue, we could use that as a signal to re-add the participant and allow
+  // ourselves to be removed. Consider if that would help.
+  return false;
+}
+
+void Party::SpawnSerializer::Destroy() {
+  if (active_ != nullptr) {
+    active_->Destroy();
+  }
+  while (auto* p = next_.Pop().value_or(nullptr)) {
+    p->Destroy();
+  }
+  Destruct(this);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Party
+
 Party::~Party() {}
 
 void Party::CancelRemainingParticipants() {
@@ -198,7 +237,6 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
   Thread thd(
       "RunParty",
       [party, prev_state]() {
-        ApplicationCallbackExecCtx app_exec_ctx;
         ExecCtx exec_ctx;
         party->RunPartyAndUnref(prev_state);
       },
@@ -258,7 +296,6 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
       CHECK(event_engine != nullptr) << "; " << GRPC_DUMP_ARGS(party, arena);
       event_engine->Run([wakeup]() {
         GRPC_LATENT_SEE_PARENT_SCOPE("Party::RunLocked offload");
-        ApplicationCallbackExecCtx app_exec_ctx;
         ExecCtx exec_ctx;
         RunState{wakeup}.Run();
       });
@@ -281,11 +318,8 @@ void Party::RunPartyAndUnref(uint64_t prev_state) {
   DCHECK_EQ(prev_state & ~(kRefMask | kAllocatedMask), 0u)
       << "Party should have contained no wakeups on lock";
   prev_state |= kLocked;
-  absl::optional<ScopedTimeCache> time_cache;
 #if !TARGET_OS_IPHONE
-  if (IsTimeCachingInPartyEnabled()) {
-    time_cache.emplace();
-  }
+  ScopedTimeCache time_cache;
 #endif
   for (;;) {
     uint64_t keep_allocated_mask = kAllocatedMask;
@@ -394,7 +428,7 @@ uint64_t Party::NextAllocationMask(uint64_t current_allocation_mask) {
 }
 #endif
 
-void Party::AddParticipant(Participant* participant) {
+size_t Party::AddParticipant(Participant* participant) {
   GRPC_LATENT_SEE_INNER_SCOPE("Party::AddParticipant");
   uint64_t state = state_.load(std::memory_order_acquire);
   uint64_t allocated;
@@ -409,8 +443,7 @@ void Party::AddParticipant(Participant* participant) {
     allocated = (state & kAllocatedMask) >> kAllocatedShift;
     wakeup_mask = NextAllocationMask(allocated);
     if (GPR_UNLIKELY((wakeup_mask & kWakeupMask) == 0)) {
-      DelayAddParticipant(participant);
-      return;
+      return std::numeric_limits<size_t>::max();
     }
     DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "No available slots for new participant; allocated=" << allocated
@@ -429,19 +462,21 @@ void Party::AddParticipant(Participant* participant) {
       << " [participant=" << participant << "]";
   participants_[slot].store(participant, std::memory_order_release);
   // Now we need to wake up the party.
-  WakeupFromState(new_state, wakeup_mask);
+  WakeupFromState<true>(new_state, wakeup_mask);
+  return slot;
 }
 
-void Party::DelayAddParticipant(Participant* participant) {
+void Party::MaybeAsyncAddParticipant(Participant* participant) {
+  const size_t slot = AddParticipant(participant);
+  if (slot != std::numeric_limits<size_t>::max()) return;
   // We need to delay the addition of participants.
   IncrementRefCount();
   VLOG_EVERY_N_SEC(2, 10) << "Delaying addition of participant to party "
                           << this << " because it is full.";
   arena_->GetContext<grpc_event_engine::experimental::EventEngine>()->Run(
       [this, participant]() mutable {
-        ApplicationCallbackExecCtx app_exec_ctx;
         ExecCtx exec_ctx;
-        AddParticipant(participant);
+        MaybeAsyncAddParticipant(participant);
         Unref();
       });
 }
@@ -461,7 +496,6 @@ void Party::WakeupAsync(WakeupMask wakeup_mask) {
         arena_->GetContext<grpc_event_engine::experimental::EventEngine>()->Run(
             [this, prev_state]() {
               GRPC_LATENT_SEE_PARENT_SCOPE("Party::WakeupAsync");
-              ApplicationCallbackExecCtx app_exec_ctx;
               ExecCtx exec_ctx;
               RunLockedAndUnref(this, prev_state);
             });