grpc 1.60.0 → 1.62.0

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

@@ -24,6 +24,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
 
@@ -38,6 +39,7 @@
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/trace.h"
 #include "src/core/lib/resource_quota/arena.h"
 
@@ -51,6 +53,8 @@
 // There's a thought of fuzzing the two implementations against each other as
 // a correctness check of both, but that's not implemented yet.
 
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_party_state;
+
 #define GRPC_PARTY_SYNC_USING_ATOMICS
 // #define GRPC_PARTY_SYNC_USING_MUTEX
 
@@ -76,13 +80,17 @@ class PartySyncUsingAtomics {
       : state_(kOneRef * initial_refs) {}
 
   void IncrementRefCount() {
-    state_.fetch_add(kOneRef, std::memory_order_relaxed);
+    const uint64_t prev_state =
+        state_.fetch_add(kOneRef, std::memory_order_relaxed);
+    LogStateChange("IncrementRefCount", prev_state, prev_state + kOneRef);
   }
   GRPC_MUST_USE_RESULT bool RefIfNonZero();
   // Returns true if the ref count is now zero and the caller should call
   // PartyOver
   GRPC_MUST_USE_RESULT bool Unref() {
-    uint64_t prev_state = state_.fetch_sub(kOneRef, std::memory_order_acq_rel);
+    const uint64_t prev_state =
+        state_.fetch_sub(kOneRef, std::memory_order_acq_rel);
+    LogStateChange("Unref", prev_state, prev_state - kOneRef);
     if ((prev_state & kRefMask) == kOneRef) {
       return UnreffedLast();
     }
@@ -91,7 +99,9 @@ class PartySyncUsingAtomics {
   void ForceImmediateRepoll(WakeupMask mask) {
     // Or in the bit for the currently polling participant.
     // Will be grabbed next round to force a repoll of this promise.
-    state_.fetch_or(mask, std::memory_order_relaxed);
+    const uint64_t prev_state =
+        state_.fetch_or(mask, std::memory_order_relaxed);
+    LogStateChange("ForceImmediateRepoll", prev_state, prev_state | mask);
   }
 
   // Run the update loop: poll_one_participant is called with an integral index
@@ -100,10 +110,13 @@ class PartySyncUsingAtomics {
   template <typename F>
   GRPC_MUST_USE_RESULT bool RunParty(F poll_one_participant) {
     uint64_t prev_state;
-    do {
+    iteration_.fetch_add(1, std::memory_order_relaxed);
+    for (;;) {
       // Grab the current state, and clear the wakeup bits & add flag.
       prev_state = state_.fetch_and(kRefMask | kLocked | kAllocatedMask,
                                     std::memory_order_acquire);
+      LogStateChange("Run", prev_state,
+                     prev_state & (kRefMask | kLocked | kAllocatedMask));
       GPR_ASSERT(prev_state & kLocked);
       if (prev_state & kDestroying) return true;
       // From the previous state, extract which participants we're to wakeup.
@@ -131,9 +144,27 @@ class PartySyncUsingAtomics {
       // TODO(ctiller): consider mitigations for the accidental wakeup on owning
       // waker creation case -- I currently expect this will be more expensive
       // than this quick loop.
-    } while (!state_.compare_exchange_weak(
-        prev_state, (prev_state & (kRefMask | kAllocatedMask)),
-        std::memory_order_acq_rel, std::memory_order_acquire));
+      if (wake_after_poll_ == 0) {
+        if (state_.compare_exchange_weak(
+                prev_state, (prev_state & (kRefMask | kAllocatedMask)),
+                std::memory_order_acq_rel, std::memory_order_acquire)) {
+          LogStateChange("Run:End", prev_state,
+                         prev_state & (kRefMask | kAllocatedMask));
+          return false;
+        }
+      } else {
+        if (state_.compare_exchange_weak(
+                prev_state,
+                (prev_state & (kRefMask | kAllocatedMask | kLocked)) |
+                    wake_after_poll_,
+                std::memory_order_acq_rel, std::memory_order_acquire)) {
+          LogStateChange("Run:EndIteration", prev_state,
+                         prev_state & (kRefMask | kAllocatedMask));
+          iteration_.fetch_add(1, std::memory_order_relaxed);
+          wake_after_poll_ = 0;
+        }
+      }
+    }
     return false;
   }
 
@@ -170,11 +201,14 @@ class PartySyncUsingAtomics {
     } while (!state_.compare_exchange_weak(
         state, (state | (allocated << kAllocatedShift)) + kOneRef,
         std::memory_order_acq_rel, std::memory_order_acquire));
+    LogStateChange("AddParticipantsAndRef", state,
+                   (state | (allocated << kAllocatedShift)) + kOneRef);
 
     store(slots);
 
     // Now we need to wake up the party.
     state = state_.fetch_or(wakeup_mask | kLocked, std::memory_order_release);
+    LogStateChange("AddParticipantsAndRef:Wakeup", state, state | kLocked);
 
     // If the party was already locked, we're done.
     return ((state & kLocked) == 0);
@@ -184,9 +218,23 @@ class PartySyncUsingAtomics {
   // Returns true if the caller should run the party.
   GRPC_MUST_USE_RESULT bool ScheduleWakeup(WakeupMask mask);
 
+  void WakeAfterPoll(WakeupMask mask) { wake_after_poll_ |= mask; }
+  uint32_t iteration() const {
+    return iteration_.load(std::memory_order_relaxed);
+  }
+
  private:
   bool UnreffedLast();
 
+  void LogStateChange(const char* op, uint64_t prev_state, uint64_t new_state,
+                      DebugLocation loc = {}) {
+    if (grpc_trace_party_state.enabled()) {
+      gpr_log(loc.file(), loc.line(), GPR_LOG_SEVERITY_DEBUG,
+              "Party %p %30s: %016" PRIx64 " -> %016" PRIx64, this, op,
+              prev_state, new_state);
+    }
+  }
+
   // State bits:
   // The atomic state_ field is composed of the following:
   //   - 24 bits for ref counts
@@ -223,6 +271,8 @@ class PartySyncUsingAtomics {
   static constexpr uint64_t kOneRef = 1ull << kRefShift;
 
   std::atomic<uint64_t> state_;
+  std::atomic<uint32_t> iteration_{0};
+  WakeupMask wake_after_poll_ = 0;
 };
 
 class PartySyncUsingMutex {
@@ -298,7 +348,7 @@ class Party : public Activity, private Wakeable {
     explicit Participant(absl::string_view name) : name_(name) {}
     // Poll the participant. Return true if complete.
     // Participant should take care of its own deallocation in this case.
-    virtual bool Poll() = 0;
+    virtual bool PollParticipantPromise() = 0;
 
     // Destroy the participant before finishing.
     virtual void Destroy() = 0;
@@ -330,6 +380,9 @@ class Party : public Activity, private Wakeable {
   void Spawn(absl::string_view name, Factory promise_factory,
              OnComplete on_complete);
 
+  template <typename Factory>
+  auto SpawnWaitable(absl::string_view name, Factory factory);
+
   void Orphan() final { Crash("unused"); }
 
   // Activity implementation: not allowed to be overridden by derived types.
@@ -353,6 +406,20 @@ class Party : public Activity, private Wakeable {
 
   Arena* arena() const { return arena_; }
 
+  // Return a promise that resolves to Empty{} when the current party poll is
+  // complete.
+  // This is useful for implementing batching and the like: we can hold some
+  // action until the rest of the party resolves itself.
+  auto AfterCurrentPoll() {
+    GPR_DEBUG_ASSERT(GetContext<Activity>() == this);
+    sync_.WakeAfterPoll(CurrentParticipant());
+    return [this, iteration = sync_.iteration()]() -> Poll<Empty> {
+      GPR_DEBUG_ASSERT(GetContext<Activity>() == this);
+      if (iteration == sync_.iteration()) return Pending{};
+      return Empty{};
+    };
+  }
+
   class BulkSpawner {
    public:
     explicit BulkSpawner(Party* party) : party_(party) {}
@@ -414,7 +481,7 @@ class Party : public Activity, private Wakeable {
       }
     }
 
-    bool Poll() override {
+    bool PollParticipantPromise() override {
       if (!started_) {
         auto p = factory_.Make();
         Destruct(&factory_);
@@ -441,6 +508,89 @@ class Party : public Activity, private Wakeable {
     bool started_ = false;
   };
 
+  template <typename SuppliedFactory>
+  class PromiseParticipantImpl final
+      : public RefCounted<PromiseParticipantImpl<SuppliedFactory>,
+                          NonPolymorphicRefCount>,
+        public Participant {
+    using Factory = promise_detail::OncePromiseFactory<void, SuppliedFactory>;
+    using Promise = typename Factory::Promise;
+    using Result = typename Promise::Result;
+
+   public:
+    PromiseParticipantImpl(absl::string_view name,
+                           SuppliedFactory promise_factory)
+        : Participant(name) {
+      Construct(&factory_, std::move(promise_factory));
+    }
+
+    ~PromiseParticipantImpl() {
+      switch (state_.load(std::memory_order_acquire)) {
+        case State::kFactory:
+          Destruct(&factory_);
+          break;
+        case State::kPromise:
+          Destruct(&promise_);
+          break;
+        case State::kResult:
+          Destruct(&result_);
+          break;
+      }
+    }
+
+    // Inside party poll: drive from factory -> promise -> result
+    bool PollParticipantPromise() override {
+      switch (state_.load(std::memory_order_relaxed)) {
+        case State::kFactory: {
+          auto p = factory_.Make();
+          Destruct(&factory_);
+          Construct(&promise_, std::move(p));
+          state_.store(State::kPromise, std::memory_order_relaxed);
+        }
+          ABSL_FALLTHROUGH_INTENDED;
+        case State::kPromise: {
+          auto p = promise_();
+          if (auto* r = p.value_if_ready()) {
+            Destruct(&promise_);
+            Construct(&result_, std::move(*r));
+            state_.store(State::kResult, std::memory_order_release);
+            waiter_.Wakeup();
+            this->Unref();
+            return true;
+          }
+          return false;
+        }
+        case State::kResult:
+          Crash(
+              "unreachable: promises should not be repolled after completion");
+      }
+    }
+
+    // Outside party poll: check whether the spawning party has completed this
+    // promise.
+    Poll<Result> PollCompletion() {
+      switch (state_.load(std::memory_order_acquire)) {
+        case State::kFactory:
+        case State::kPromise:
+          return Pending{};
+        case State::kResult:
+          return std::move(result_);
+      }
+    }
+
+    void Destroy() override { this->Unref(); }
+
+   private:
+    enum class State : uint8_t { kFactory, kPromise, kResult };
+    union {
+      GPR_NO_UNIQUE_ADDRESS Factory factory_;
+      GPR_NO_UNIQUE_ADDRESS Promise promise_;
+      GPR_NO_UNIQUE_ADDRESS Result result_;
+    };
+    Waker waiter_{GetContext<Activity>()->MakeOwningWaker()};
+    std::atomic<State> state_{State::kFactory};
+  };
+
   // Notification that the party has finished and this instance can be deleted.
   // Derived types should arrange to call CancelRemainingParticipants during
   // this sequence.
@@ -460,6 +610,7 @@ class Party : public Activity, private Wakeable {
 
   // Add a participant (backs Spawn, after type erasure to ParticipantFactory).
   void AddParticipants(Participant** participant, size_t count);
+  bool RunOneParticipant(int i);
 
   virtual grpc_event_engine::experimental::EventEngine* event_engine()
       const = 0;
@@ -483,6 +634,11 @@ class Party : public Activity, private Wakeable {
   std::atomic<Participant*> participants_[party_detail::kMaxParticipants] = {};
 };
 
+template <>
+struct ContextSubclass<Party> {
+  using Base = Activity;
+};
+
 template <typename Factory, typename OnComplete>
 void Party::BulkSpawner::Spawn(absl::string_view name, Factory promise_factory,
                                OnComplete on_complete) {
@@ -502,6 +658,17 @@ void Party::Spawn(absl::string_view name, Factory promise_factory,
                           std::move(on_complete));
 }
 
+template <typename Factory>
+auto Party::SpawnWaitable(absl::string_view name, Factory promise_factory) {
+  auto participant = MakeRefCounted<PromiseParticipantImpl<Factory>>(
+      name, std::move(promise_factory));
+  Participant* p = participant->Ref().release();
+  AddParticipants(&p, 1);
+  return [participant = std::move(participant)]() mutable {
+    return participant->PollCompletion();
+  };
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_PARTY_H

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

@@ -374,7 +374,7 @@ class Center : public InterceptorList<T> {
   const T& value() const { return value_; }
 
   std::string DebugTag() {
-    if (auto* activity = Activity::current()) {
+    if (auto* activity = GetContext<Activity>()) {
       return absl::StrCat(activity->DebugTag(), " PIPE[0x", absl::Hex(this),
                           "]: ");
     } else {
@@ -638,11 +638,6 @@ class PipeReceiver {
   friend struct Pipe<T>;
   explicit PipeReceiver(pipe_detail::Center<T>* center) : center_(center) {}
   RefCountedPtr<pipe_detail::Center<T>> center_;
-
-  // Make failure to destruct show up in ASAN builds.
-#ifndef NDEBUG
-  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
-#endif
 };
 
 namespace pipe_detail {
@@ -661,7 +656,7 @@ class Push {
     if (center_ == nullptr) {
       if (grpc_trace_promise_primitives.enabled()) {
         gpr_log(GPR_DEBUG, "%s Pipe push has a null center",
-                Activity::current()->DebugTag().c_str());
+                GetContext<Activity>()->DebugTag().c_str());
       }
       return false;
     }

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

@@ -186,25 +186,13 @@ class Poll<Pending>;
 template <class T>
 class Poll<Poll<T>>;
 
-template <typename T>
-bool operator==(const Poll<T>& a, const Poll<T>& b) {
-  if (a.pending() && b.pending()) return true;
-  if (a.ready() && b.ready()) return a.value() == b.value();
-  return false;
-}
-
-template <typename T, typename U>
-Poll<T> poll_cast(Poll<U> poll) {
-  if (poll.pending()) return Pending{};
-  return static_cast<T>(std::move(poll.value()));
-}
-
 // PollTraits tells us whether a type is Poll<> or some other type, and is
 // leveraged in the PromiseLike/PromiseFactory machinery to select the
 // appropriate implementation of those concepts based upon the return type of a
 // lambda, for example (via enable_if).
 template <typename T>
 struct PollTraits {
+  using Type = T;
   static constexpr bool is_poll() { return false; }
 };
 
@@ -214,6 +202,44 @@ struct PollTraits<Poll<T>> {
   static constexpr bool is_poll() { return true; }
 };
 
+template <typename T>
+bool operator==(const Poll<T>& a, const Poll<T>& b) {
+  if (a.pending() && b.pending()) return true;
+  if (a.ready() && b.ready()) return a.value() == b.value();
+  return false;
+}
+
+template <typename T, typename U, typename SfinaeVoid = void>
+struct PollCastImpl;
+
+template <typename T, typename U>
+struct PollCastImpl<T, Poll<U>> {
+  static Poll<T> Cast(Poll<U>&& poll) {
+    if (poll.pending()) return Pending{};
+    return static_cast<T>(std::move(poll.value()));
+  }
+};
+
+template <typename T, typename U>
+struct PollCastImpl<T, U, std::enable_if<!PollTraits<U>::is_poll()>> {
+  static Poll<T> Cast(U&& poll) { return Poll<T>(T(std::move(poll))); }
+};
+
+template <typename T>
+struct PollCastImpl<T, T> {
+  static Poll<T> Cast(T&& poll) { return Poll<T>(std::move(poll)); }
+};
+
+template <typename T>
+struct PollCastImpl<T, Poll<T>> {
+  static Poll<T> Cast(Poll<T>&& poll) { return std::move(poll); }
+};
+
+template <typename T, typename U>
+Poll<T> poll_cast(U poll) {
+  return PollCastImpl<T, U>::Cast(std::move(poll));
+}
+
 // Convert a poll to a string
 template <typename T, typename F>
 std::string PollToString(

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

@@ -89,6 +89,10 @@ auto WithResult(F f) ->
   return f;
 }
 
+template <typename Promise>
+using PromiseResult = typename PollTraits<
+    typename promise_detail::PromiseLike<Promise>::Result>::Type;
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_PROMISE_H

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

@@ -21,6 +21,7 @@
 
 #include <utility>
 
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/detail/seq_state.h"
@@ -39,6 +40,7 @@ struct SeqTraits {
     return next->Make(std::forward<T>(value));
   }
   static bool IsOk(const T&) { return true; }
+  static const char* ErrorString(const T&) { abort(); }
   template <typename R>
   static R ReturnValue(T&&) {
     abort();
@@ -57,8 +59,9 @@ struct SeqTraits {
 template <typename P, typename... Fs>
 class Seq {
  public:
-  explicit Seq(P&& promise, Fs&&... factories)
-      : state_(std::forward<P>(promise), std::forward<Fs>(factories)...) {}
+  explicit Seq(P&& promise, Fs&&... factories, DebugLocation whence)
+      : state_(std::forward<P>(promise), std::forward<Fs>(factories)...,
+               whence) {}
 
   auto operator()() { return state_.PollOnce(); }
 
@@ -94,16 +97,113 @@ struct SeqIterResultTraits {
 // Pass its result to the third, and run the returned promise.
 // etc
 // Return the final value.
-template <typename... Functors>
-promise_detail::Seq<Functors...> Seq(Functors... functors) {
-  return promise_detail::Seq<Functors...>(std::move(functors)...);
-}
-
 template <typename F>
 F Seq(F functor) {
   return functor;
 }
 
+template <typename F0, typename F1>
+promise_detail::Seq<F0, F1> Seq(F0 f0, F1 f1, DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1>(std::move(f0), std::move(f1), whence);
+}
+
+template <typename F0, typename F1, typename F2>
+promise_detail::Seq<F0, F1, F2> Seq(F0 f0, F1 f1, F2 f2,
+                                    DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2>(std::move(f0), std::move(f1),
+                                         std::move(f2), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3>
+promise_detail::Seq<F0, F1, F2, F3> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
+                                        DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4>
+promise_detail::Seq<F0, F1, F2, F3, F4> Seq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4,
+                                            DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4>(std::move(f0), std::move(f1),
+                                                 std::move(f2), std::move(f3),
+                                                 std::move(f4), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
+                                                F4 f4, F5 f5,
+                                                DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6> Seq(F0 f0, F1 f1, F2 f2, F3 f3,
+                                                    F4 f4, F5 f5, F6 f6,
+                                                    DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6, typename F7>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7> Seq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
+    DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), std::move(f7), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6, typename F7, typename F8>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8> Seq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8,
+    DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), std::move(f7), std::move(f8), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6, typename F7, typename F8, typename F9>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> Seq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8, F9 f9,
+    DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), std::move(f7), std::move(f8), std::move(f9),
+      whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6, typename F7, typename F8, typename F9,
+          typename F10>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> Seq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8, F9 f9,
+    F10 f10, DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), std::move(f7), std::move(f8), std::move(f9),
+      std::move(f10), whence);
+}
+
+template <typename F0, typename F1, typename F2, typename F3, typename F4,
+          typename F5, typename F6, typename F7, typename F8, typename F9,
+          typename F10, typename F11>
+promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> Seq(
+    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7, F8 f8, F9 f9,
+    F10 f10, F11 f11, DebugLocation whence = {}) {
+  return promise_detail::Seq<F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11>(
+      std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
+      std::move(f5), std::move(f6), std::move(f7), std::move(f8), std::move(f9),
+      std::move(f10), std::move(f11), whence);
+}
+
 // Execute a sequence of operations of unknown length.
 // Asynchronously:
 //   for (element in (begin, end)) {

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

@@ -54,7 +54,7 @@ Poll<absl::Status> Sleep::operator()() {
 }
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
-    : waker_(Activity::current()->MakeOwningWaker()),
+    : waker_(GetContext<Activity>()->MakeOwningWaker()),
       timer_handle_(GetContext<EventEngine>()->RunAfter(
           deadline - Timestamp::Now(), this)) {}