grpc 1.70.1 → 1.72.0

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

@@ -21,6 +21,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <limits>
 #include <string>
 #include <utility>
 
@@ -34,6 +35,7 @@
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/util/check_class_size.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/ref_counted.h"
@@ -41,24 +43,124 @@
 
 namespace grpc_core {
 
+// Terms Used:
+//
+// Concurrent promises: Promises that may be in progress at a given instant
+// of time, but they may or may not execute simultaneously.
+// Parallel promises: Two or more Promises that are getting executed
+// simultaneously at the same instant of time.
+//
+// Promise Party
+// A Promise Party forms the execution environment for Promises. It runs up
+// to sixteen concurrent party participants and ensures none of the participants
+// run in parallel with each other.
+//
+// Party Participant
+// One Promise Party has 16 Participant slots. Each Participant slot can hold
+// one of the three
+// 1. A Promise
+// 2. Or a Promise Factory
+// 3. or any type of Participant object, such as SpawnSerializer.
+//
+// Using a Party
+// A party should be used when
+// 1. You need many promises to be run in a way that is concurrent but not
+// parallel.
+// 2. These promises have their own complex sleep and wake mechanisms.
+// 3. You need a way to run the pending promises to completion by repolling them
+// as needed.
+//
+// Creating a new Party
+// A Party must only be created using Party::Make function.
+//
+// Spawning a promise on a Party
+// 1. A promise can be spawned on a party using either Spawn or SpawnWaitable
+// method.
+// 2. If you want to bulk spawn promises on a party before any thread
+// starts executing them, use Party::WakeupHold.
+//
+// Execution of Spawned Promises
+// A Participant spawned on a party will get executed by that party.
+// Whenever the party wakes up, it will execute all unresolved Party
+// Participants at least once. After any Party Participant is resolved, its slot
+// is freed up to make place for new participants.
+//
+// When these Party Participants are executed (polled), they can either
+// 1. Resolve by returning a value
+// 2. Return Pending{}
+// 3. Wait for a certain event to happen using either a Notification or a Latch.
+//
+// When a promise factory is passed as a Party Participant, the promise factory
+// is used to generate the promise once, and then the promise is executed once
+// each time the party is polled till it resolves.
+//
+// Sleep mechanism of a Party
+// A party will Sleep/Quiece if all Participants Spawned on the party are in any
+// of the following states
+// 1. Return Pending{}
+// 2. Resolve
+// 3. Are waiting because of a Latch.
+// If a party is currently running a Participant, it is said to be active/awake.
+// Otherwise it is said to be Sleeping or Quieced.
+//
+// Wake mechanism of a Party
+// To wake up a sleeping party you can use the Waker object. Once the Party is
+// woken, it will be executed as mentioned above.
+//
+// Party Cancellation
+// A Party can be cancelled using party_.reset() method.
+//
+// Guarantees of a Party
+// 1. All Participant spawned on one party are guaranteed to be run serially.
+// Their execution will not happen in parallel.
+// 2. If a promise is executed, its on_complete is guaranteed to be executed as
+// long as the party is not cancelled.
+// 3. Once a party is cancelled, Participants that were Spawned onto the party,
+// but not yet executed, will not get executed.
+// 4. Promise spawned on a party will never be repolled after it is resolved.
+// 5. A promise spawned on a party, can in turn spawn another promise either on
+// the same party or on another party. We allow nesting of Spawn function.
+// 6. A promise or promise factory that is passed to a Spawn function could
+// either be a single simple promise, or it could be a promise combinator such
+// as TrySeq, TryJoin, Loop or any such promise combinator. Nesting of these
+// promise combinators is allowed.
+// 7. You can re-use the same party to spawn new Participants as long as the
+// older Participants have been resolved.
+// 8. We guarantee safe working of up to 16 un-resolved participants
+// on a party at a time.
+//
+// Non-Guarantees of a Party
+// 1. Promises spawned on one party are not guaranteed to execute in the same
+// order. They can execute in any order. If you need the promises to be executed
+// in a specific order, use a SpawnSerializer. If that is not feasible for some
+// reason, then either consider the use of a promise combinator, or order the
+// execution of promises using Notifications or Latches.
+// 2. A party cannot guarantee which thread a party Participant will execute on.
+// It could either execute on the current thread, or an event engine thread or
+// any other thread.
+// 3. Say, we spawned promises P1_1, P1_2, P1_3 on party1. Then promise P1_1 in
+// turn spawns promise P2_1, P2_2, P2_3 on party2. In such cases, party1 and
+// party2 may either execute on the same thread, or they may both execute on
+// different threads. party1 and party2 may or may not run in parallel.
+
 namespace party_detail {
 
 // Number of bits reserved for wakeups gives us the maximum number of
-// participants.
+// participants. This can change in the future and we don't guarantee this
+// number to be 16 always.
 static constexpr size_t kMaxParticipants = 16;
 
 }  // namespace party_detail
 
-// A Party is an Activity with multiple participant promises.
 class Party : public Activity, private Wakeable {
  private:
   // Non-owning wakeup handle.
   class Handle;
 
-  // One participant in the party.
+  // One promise participant in the party.
   class Participant {
    public:
-    // Poll the participant. Return true if complete.
+    // Poll the participant promise. Return true if complete.
     // Participant should take care of its own deallocation in this case.
     virtual bool PollParticipantPromise() = 0;
 
@@ -79,6 +181,12 @@ class Party : public Activity, private Wakeable {
   Party(const Party&) = delete;
   Party& operator=(const Party&) = delete;
 
+  // A Party object must be created only by using this method.
+  static RefCountedPtr<Party> Make(RefCountedPtr<Arena> arena) {
+    auto* arena_ptr = arena.get();
+    return RefCountedPtr<Party>(arena_ptr->New<Party>(std::move(arena)));
+  }
+
   // When calling into a Party from outside the promises system we often would
   // like to perform more than one action.
   // This class tries to acquire the party lock just once - if it succeeds then
@@ -125,22 +233,89 @@ class Party : public Activity, private Wakeable {
     uint64_t prev_state_;
   };
 
-  static RefCountedPtr<Party> Make(RefCountedPtr<Arena> arena) {
-    auto* arena_ptr = arena.get();
-    return RefCountedPtr<Party>(arena_ptr->New<Party>(std::move(arena)));
-  }
+  // SpawnSerializer is a helper class to serialize the execution of multiple
+  // promises on a party.
+  //
+  // Provides the guarantee that given:
+  //   SpawnSerializer* serializer = party->MakeSpawnSerializer();
+  //   serializer->Spawn([] { /* promise 1 */; });
+  //   serializer->Spawn([] { /* promise 2 */; });
+  // 1. promise 1 will be resolved before promise 2 is started.
+  // 2. promise 1 and promise 2 will execute on `party`.
+  //
+  // It's possible to have multiple SpawnSerializer instances on a party.
+  // Once created, the SpawnSerializer is only valid until the party is
+  // released - note that SpawnSerializer itself does not hold a ref to the
+  // party.
+  //
+  // Each SpawnSerializer consumes one slot in the party's participant array for
+  // the lifetime of the party - that is that a SpawnSerializer counts as one of
+  // the sixteen promises executing on a Party.
+  //
+  // The promises spawned by SpawnSerializer *DO NOT* count towards the sixteen
+  // promise limit.
+  //
+  // The size of this type matters, and so we leverage private inheritance to
+  // minimize the number of pointers needed to be kept per instance.
+  class SpawnSerializer final : private Participant {
+   public:
+    // Spawn a promise into the party.
+    //
+    // The promise will be polled until it is resolved, or until the party is
+    // shut down.
+    //
+    // Later promises spawned by this serializer will not be polled until this
+    // promise is resolved, and then one at a time in the order they were
+    // spawned.
+    //
+    // Spawn itself is not thread safe: at most one thread can call Spawn at a
+    // time. Just as the execution of promises is serialized by this type, the
+    // spawning of promises is expected to be serialized by some external entity
+    // (usually this is a Seq running on a different party).
+    template <class Factory>
+    void Spawn(Factory factory) {
+      auto empty_completion = [](Empty) {};
+      next_.Push(new ParticipantImpl<Factory, decltype(empty_completion)>(
+          "SpawnSerializer", std::move(factory), empty_completion));
+      party_->WakeupFromState<false>(
+          party_->state_.load(std::memory_order_relaxed), wakeup_mask_);
+    }
+
+   private:
+    friend class Party;
+    friend class Arena;
+
+    bool PollParticipantPromise() override;
+    void Destroy() override;
+
+    explicit SpawnSerializer(Party* party)
+        : next_(party->arena()), party_(party) {}
+
+    // Queue of promises to be executed after the active promise resolves.
+    ArenaSpsc<Participant*, false> next_;
+    // The promise currently being executed.
+    Participant* active_ = nullptr;
+    // The wakeup mask for this serializers participant.
+    // Allows us to wake up the party when a new promise is added to the queue.
+    WakeupMask wakeup_mask_;
+    // The party this serializer is running on.
+    Party* const party_;
+  };
 
   // Spawn one promise into the party.
-  // The promise will be polled until it is resolved, or until the party is shut
-  // down.
-  // The on_complete callback will be called with the result of the promise if
-  // it completes.
-  // A maximum of sixteen promises can be spawned onto a party.
+  // The party can poll the promise until it is resolved, or until the party is
+  // shut down.
+  // The on_complete callback will be called with the result of the
+  // promise if it completes. Even if the promise returns a failed status,
+  // on_complete will be called.
   // promise_factory called to create the promise with the party lock taken;
-  // after the promise is created the factory is destroyed.
-  // This means that pointers or references to factory members will be
-  // invalidated after the promise is created - so the promise should not retain
-  // any of these.
+  // after the promise is created the factory is destroyed. This means that
+  // pointers or references to factory members will be invalidated after the
+  // promise is created - so the promise should not retain any of these.
+  // This function is thread safe. We can Spawn different promises onto the
+  // same party from different threads.
+  // A party can hold upto 16 unresolved promises at a time. However, this
+  // number might change in the future.
   template <typename Factory, typename OnComplete>
   void Spawn(absl::string_view name, Factory promise_factory,
              OnComplete on_complete);
@@ -184,6 +359,14 @@ class Party : public Activity, private Wakeable {
 
   Arena* arena() { return arena_.get(); }
 
+  SpawnSerializer* MakeSpawnSerializer() {
+    auto* const serializer = arena_->New<SpawnSerializer>(this);
+    const size_t slot = AddParticipant(serializer);
+    DCHECK_NE(slot, std::numeric_limits<size_t>::max());
+    serializer->wakeup_mask_ = 1ull << slot;
+    return serializer;
+  }
+
  protected:
   friend class Arena;
 
@@ -287,7 +470,7 @@ class Party : public Activity, private Wakeable {
           Construct(&promise_, std::move(p));
           state_.store(State::kPromise, std::memory_order_relaxed);
         }
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
         case State::kPromise: {
           auto p = promise_();
           if (auto* r = p.value_if_ready()) {
@@ -383,9 +566,10 @@ class Party : public Activity, private Wakeable {
       Unref();
       return;
     }
-    WakeupFromState(state_.load(std::memory_order_relaxed), wakeup_mask);
+    WakeupFromState<true>(state_.load(std::memory_order_relaxed), wakeup_mask);
   }
 
+  template <bool kReffed>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void WakeupFromState(
       uint64_t cur_state, WakeupMask wakeup_mask) {
     GRPC_LATENT_SEE_INNER_SCOPE("Party::WakeupFromState");
@@ -396,8 +580,13 @@ class Party : public Activity, private Wakeable {
         // If the party is locked, we need to set the wakeup bits, and then
         // we'll immediately unref. Since something is running this should never
         // bring the refcount to zero.
-        DCHECK_GT(cur_state & kRefMask, kOneRef);
-        auto new_state = (cur_state | wakeup_mask) - kOneRef;
+        if (kReffed) {
+          DCHECK_GT(cur_state & kRefMask, kOneRef);
+        } else {
+          DCHECK_GE(cur_state & kRefMask, kOneRef);
+        }
+        const uint64_t new_state =
+            (cur_state | wakeup_mask) - (kReffed ? kOneRef : 0);
         if (state_.compare_exchange_weak(cur_state, new_state,
                                          std::memory_order_release)) {
           LogStateChange("Wakeup", cur_state, cur_state | wakeup_mask);
@@ -406,9 +595,11 @@ class Party : public Activity, private Wakeable {
       } else {
         // If the party is not locked, we need to lock it and run.
         DCHECK_EQ(cur_state & kWakeupMask, 0u);
-        if (state_.compare_exchange_weak(cur_state, cur_state | kLocked,
+        const uint64_t new_state =
+            (cur_state | kLocked) + (kReffed ? 0 : kOneRef);
+        if (state_.compare_exchange_weak(cur_state, new_state,
                                          std::memory_order_acq_rel)) {
-          LogStateChange("WakeupAndRun", cur_state, cur_state | kLocked);
+          LogStateChange("WakeupAndRun", cur_state, new_state);
           wakeup_mask_ |= wakeup_mask;
           RunLockedAndUnref(this, cur_state);
           return;
@@ -421,8 +612,8 @@ class Party : public Activity, private Wakeable {
   void Drop(WakeupMask wakeup_mask) final;
 
   // Add a participant (backs Spawn, after type erasure to ParticipantFactory).
-  void AddParticipant(Participant* participant);
-  void DelayAddParticipant(Participant* participant);
+  size_t AddParticipant(Participant* participant);
+  void MaybeAsyncAddParticipant(Participant* participant);
 
   static uint64_t NextAllocationMask(uint64_t current_allocation_mask);
 
@@ -448,6 +639,8 @@ class Party : public Activity, private Wakeable {
   RefCountedPtr<Arena> arena_;
 };
 
+GRPC_CHECK_CLASS_SIZE(Party, 180);
+
 template <>
 struct ContextSubclass<Party> {
   using Base = Activity;
@@ -457,7 +650,7 @@ template <typename Factory, typename OnComplete>
 void Party::Spawn(absl::string_view name, Factory promise_factory,
                   OnComplete on_complete) {
   GRPC_TRACE_LOG(party_state, INFO) << "PARTY[" << this << "]: spawn " << name;
-  AddParticipant(new ParticipantImpl<Factory, OnComplete>(
+  MaybeAsyncAddParticipant(new ParticipantImpl<Factory, OnComplete>(
       name, std::move(promise_factory), std::move(on_complete)));
 }
 
@@ -467,7 +660,7 @@ 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();
-  AddParticipant(p);
+  MaybeAsyncAddParticipant(p);
   return [participant = std::move(participant)]() mutable {
     return participant->PollCompletion();
   };

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

@@ -20,14 +20,14 @@
 #include <stdlib.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/if.h"
@@ -189,7 +189,7 @@ class Center : public InterceptorList<T> {
   // Return Pending if there is no value.
   // Return the value if one was retrieved.
   // Return nullopt if the send end is closed and no value had been pushed.
-  Poll<absl::optional<T>> Next() {
+  Poll<std::optional<T>> Next() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Next");
     DCHECK_NE(refs_, 0);
     switch (value_state_) {
@@ -206,9 +206,9 @@ class Center : public InterceptorList<T> {
         return std::move(value_);
       case ValueState::kClosed:
       case ValueState::kCancelled:
-        return absl::nullopt;
+        return std::nullopt;
     }
-    GPR_UNREACHABLE_CODE(return absl::nullopt);
+    GPR_UNREACHABLE_CODE(return std::nullopt);
   }
 
   // Check if the pipe is closed for sending (if there is a value still queued
@@ -517,8 +517,8 @@ class Next {
   Next(Next&& other) noexcept = default;
   Next& operator=(Next&& other) noexcept = default;
 
-  Poll<absl::optional<T>> operator()() {
-    return center_ == nullptr ? absl::nullopt : center_->Next();
+  Poll<std::optional<T>> operator()() {
+    return center_ == nullptr ? std::nullopt : center_->Next();
   }
 
  private:
@@ -551,7 +551,7 @@ class PipeReceiver {
   // available.
   auto Next() {
     return Seq(pipe_detail::Next<T>(center_), [center = center_](
-                                                  absl::optional<T> value) {
+                                                  std::optional<T> value) {
       bool open = value.has_value();
       bool cancelled = center == nullptr ? true : center->cancelled();
       return If(
@@ -559,7 +559,7 @@ class PipeReceiver {
           [center = std::move(center), value = std::move(value)]() mutable {
             auto run = center->Run(std::move(value));
             return Map(std::move(run), [center = std::move(center)](
-                                           absl::optional<T> value) mutable {
+                                           std::optional<T> value) mutable {
               if (value.has_value()) {
                 center->value() = std::move(*value);
                 return NextResult<T>(std::move(center));
@@ -637,7 +637,7 @@ class Push {
           << " Pipe push has a null center";
       return false;
     }
-    if (auto* p = absl::get_if<T>(&state_)) {
+    if (auto* p = std::get_if<T>(&state_)) {
       auto r = center_->Push(p);
       if (auto* ok = r.value_if_ready()) {
         state_.template emplace<AwaitingAck>();
@@ -646,7 +646,7 @@ class Push {
         return Pending{};
       }
     }
-    DCHECK(absl::holds_alternative<AwaitingAck>(state_));
+    DCHECK(std::holds_alternative<AwaitingAck>(state_));
     return center_->PollAck();
   }
 
@@ -658,7 +658,7 @@ class Push {
       : center_(std::move(center)), state_(std::move(push)) {}
 
   RefCountedPtr<Center<T>> center_;
-  absl::variant<T, AwaitingAck> state_;
+  std::variant<T, AwaitingAck> state_;
 };
 
 }  // namespace pipe_detail

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

@@ -17,12 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/strings/str_format.h"
-#include "absl/types/optional.h"
+#include "absl/strings/str_join.h"
 #include "src/core/util/construct_destruct.h"
 
 namespace grpc_core {
@@ -135,8 +136,8 @@ class Poll {
   //
   // Why not optional<T>?
   //
-  // We have cases where we want to return absl::nullopt{} from a promise, and
-  // have that upgraded to a Poll<absl::nullopt_t> prior to a cast to some
+  // We have cases where we want to return std::nullopt{} from a promise, and
+  // have that upgraded to a Poll<std::nullopt_t> prior to a cast to some
   // Poll<optional<T>>.
   //
   // Since optional<nullopt_t> is not allowed, we'd not be allowed to make
@@ -152,6 +153,9 @@ class Poll {
   };
 };
 
+template <typename T>
+class Poll<T&&>;
+
 template <>
 class Poll<Empty> {
  public:
@@ -278,52 +282,53 @@ std::string PollToString(
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<T>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const T& value) {
+  absl::Format(&sink, "%v", value);
+}
+
+template <typename Sink, typename... Ts>
+void PollValueStringify(Sink& sink, const std::tuple<Ts...>& values) {
+  absl::Format(&sink, "(%v)", absl::StrJoin(values, ", "));
+}
+
+template <typename Sink, typename T>
+void PollValueStringify(Sink& sink, const std::optional<T>& value) {
+  if (!value.has_value()) {
+    sink.Append("nullopt");
     return;
   }
-  absl::Format(&sink, "%v", poll.value());
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<absl::StatusOr<T>>& poll) {
-  if (poll.pending()) {
-    absl::Format(&sink, "<<pending>>");
+void PollValueStringify(Sink& sink, const absl::StatusOr<T>& value) {
+  if (!value.ok()) {
+    PollValueStringify(sink, value.status());
     return;
   }
-  if (poll.value().ok()) {
-    absl::Format(&sink, "%v", *poll.value());
-  } else {
-    absl::Format(&sink, "%v", poll.value().status());
-  }
+  PollValueStringify(sink, *value);
 }
 
 template <typename Sink, typename T>
-void AbslStringify(Sink& sink, const Poll<absl::optional<T>>& poll) {
+void AbslStringify(Sink& sink, const Poll<T>& poll) {
   if (poll.pending()) {
     absl::Format(&sink, "<<pending>>");
     return;
   }
-  const auto& value = poll.value();
-  if (value.has_value()) {
-    absl::Format(&sink, "%v", value);
-  } else {
-    sink.append("nullopt");
-  }
+  PollValueStringify(sink, poll.value());
 }
 
 // Hack to get metadata printing
 template <typename Sink, typename T, typename Deleter>
 void AbslStringify(
-    Sink& sink, const Poll<absl::optional<std::unique_ptr<T, Deleter>>>& poll) {
+    Sink& sink, const Poll<std::optional<std::unique_ptr<T, Deleter>>>& poll) {
   if (poll.pending()) {
     absl::Format(&sink, "<<pending>>");
     return;
   }
   const auto& value = poll.value();
   if (value.has_value()) {
-    absl::Format(&sink, "%v", *value);
+    PollValueStringify(sink, *value);
   } else {
     sink.Append("nullopt");
   }

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

@@ -19,9 +19,9 @@
 
 #include <utility>
 
-namespace grpc_core {
+#include "src/core/lib/promise/detail/promise_like.h"
 
-namespace promise_detail {
+namespace grpc_core {
 
 template <typename A, typename B>
 class TwoPartyPrioritizedRace {
@@ -36,23 +36,25 @@ class TwoPartyPrioritizedRace {
     auto p = a_();
     if (p.ready()) return p;
     // Check the other promise.
-    p = b_();
-    if (p.ready()) {
-      // re-poll a to see if it's also completed.
-      auto q = a_();
-      if (q.ready()) {
-        // both are ready, but a is prioritized
-        return q;
-      }
+    auto q = b_();
+    if (!q.ready()) return q;
+    // re-poll a to see if it's also completed.
+    auto r = a_();
+    if (r.ready()) {
+      // both are ready, but a is prioritized
+      return r;
     }
-    return p;
+    return q;
   }
 
  private:
-  A a_;
-  B b_;
+  promise_detail::PromiseLike<A> a_;
+  promise_detail::PromiseLike<B> b_;
 };
 
+/// Run all the promises until one is non-pending.
+/// Once there's a non-pending promise, repoll all the promises before that.
+/// Return the result from the lexically first non-pending promise.
 template <typename... Promises>
 class PrioritizedRace;
 
@@ -78,16 +80,8 @@ class PrioritizedRace<Promise> {
   Promise promise_;
 };
 
-}  // namespace promise_detail
-
-/// Run all the promises until one is non-pending.
-/// Once there's a non-pending promise, repoll all the promises before that.
-/// Return the result from the lexically first non-pending promise.
 template <typename... Promises>
-promise_detail::PrioritizedRace<Promises...> PrioritizedRace(
-    Promises... promises) {
-  return promise_detail::PrioritizedRace<Promises...>(std::move(promises)...);
-}
+PrioritizedRace(Promises...) -> PrioritizedRace<Promises...>;
 
 }  // namespace grpc_core
 

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

@@ -17,12 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <type_traits>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -38,7 +37,7 @@ using Promise = absl::AnyInvocable<Poll<T>()>;
 // nothing.
 template <typename Promise>
 auto NowOrNever(Promise promise)
-    -> absl::optional<typename promise_detail::PromiseLike<Promise>::Result> {
+    -> std::optional<typename promise_detail::PromiseLike<Promise>::Result> {
   auto r = promise_detail::PromiseLike<Promise>(std::move(promise))();
   if (auto* p = r.value_if_ready()) {
     return std::move(*p);
@@ -84,12 +83,12 @@ struct ImmediateOkStatus {
 };
 
 // Typecheck that a promise returns the expected return type.
-// usage: auto promise = WithResult<int>([]() { return 3; });
+// usage: auto promise = AssertResultType<int>([]() { return 3; });
 // NOTE: there are tests in promise_test.cc that are commented out because they
 // should fail to compile. When modifying this code these should be uncommented
 // and their miscompilation verified.
 template <typename T, typename F>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto WithResult(F f) ->
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto AssertResultType(F f) ->
     typename std::enable_if<std::is_same<decltype(f()), Poll<T>>::value,
                             F>::type {
   return f;