grpc 1.55.3 → 1.56.0.pre3

data/src/core/lib/json/json_object_loader.cc

@@ -22,6 +22,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
+#include <grpc/support/json.h>
+
 namespace grpc_core {
 namespace json_detail {
 
@@ -91,13 +93,11 @@ bool LoadNumber::IsNumber() const { return true; }
 
 void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
                         ValidationErrors* errors) const {
-  if (json.type() == Json::Type::kTrue) {
-    *static_cast<bool*>(dst) = true;
-  } else if (json.type() == Json::Type::kFalse) {
-    *static_cast<bool*>(dst) = false;
-  } else {
+  if (json.type() != Json::Type::kBoolean) {
     errors->AddError("is not a boolean");
+    return;
   }
+  *static_cast<bool*>(dst) = json.boolean();
 }
 
 void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
@@ -168,9 +168,8 @@ void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
   }
 }
 
-void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                            ValidationErrors* errors) const {
-  if (json.type() == Json::Type::kNull) return;
+void LoadWrapped::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                           ValidationErrors* errors) const {
   void* element = Emplace(dst);
   size_t starting_error_size = errors->size();
   ElementLoader()->LoadInto(json, args, element, errors);
@@ -191,7 +190,7 @@ bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".", element.name));
     const auto& it = json.object().find(element.name);
-    if (it == json.object().end()) {
+    if (it == json.object().end() || it->second.type() == Json::Type::kNull) {
       if (element.optional) continue;
       errors->AddError("field not present");
       continue;

data/src/core/lib/json/json_object_loader.h

@@ -253,14 +253,14 @@ class LoadMap : public LoaderInterface {
   virtual const LoaderInterface* ElementLoader() const = 0;
 };
 
-// Load an optional of some type.
-class LoadOptional : public LoaderInterface {
+// Load a wrapped value of some type.
+class LoadWrapped : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
                 ValidationErrors* errors) const override;
 
  protected:
-  ~LoadOptional() = default;
+  ~LoadWrapped() = default;
 
  private:
   virtual void* Emplace(void* dst) const = 0;
@@ -392,7 +392,7 @@ class AutoLoader<std::map<std::string, T>> final : public LoadMap {
 
 // Specializations of AutoLoader for absl::optional<>.
 template <typename T>
-class AutoLoader<absl::optional<T>> final : public LoadOptional {
+class AutoLoader<absl::optional<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
     return &static_cast<absl::optional<T>*>(dst)->emplace();
@@ -410,7 +410,7 @@ class AutoLoader<absl::optional<T>> final : public LoadOptional {
 
 // Specializations of AutoLoader for std::unique_ptr<>.
 template <typename T>
-class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
+class AutoLoader<std::unique_ptr<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
     auto& p = *static_cast<std::unique_ptr<T>*>(dst);
@@ -428,6 +428,26 @@ class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
   ~AutoLoader() = default;
 };
 
+// Specializations of AutoLoader for RefCountedPtr<>.
+template <typename T>
+class AutoLoader<RefCountedPtr<T>> final : public LoadWrapped {
+ public:
+  void* Emplace(void* dst) const final {
+    auto& p = *static_cast<RefCountedPtr<T>*>(dst);
+    p = MakeRefCounted<T>();
+    return p.get();
+  }
+  void Reset(void* dst) const final {
+    static_cast<RefCountedPtr<T>*>(dst)->reset();
+  }
+  const LoaderInterface* ElementLoader() const final {
+    return LoaderForType<T>();
+  }
+
+ private:
+  ~AutoLoader() = default;
+};
+
 // Implementation of aforementioned LoaderForType.
 // Simply keeps a static AutoLoader<T> and returns a pointer to that.
 template <typename T>
@@ -596,19 +616,6 @@ absl::StatusOr<T> LoadFromJson(
   return std::move(result);
 }
 
-template <typename T>
-absl::StatusOr<RefCountedPtr<T>> LoadRefCountedFromJson(
-    const Json& json, const JsonArgs& args = JsonArgs(),
-    absl::string_view error_prefix = "errors validating JSON") {
-  ValidationErrors errors;
-  auto result = MakeRefCounted<T>();
-  json_detail::LoaderForType<T>()->LoadInto(json, args, result.get(), &errors);
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
-  }
-  return std::move(result);
-}
-
 template <typename T>
 T LoadFromJson(const Json& json, const JsonArgs& args,
                ValidationErrors* errors) {

data/src/core/lib/json/json_reader.cc

@@ -35,6 +35,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/match.h"
@@ -107,8 +108,13 @@ class JsonReader {
 
     Json TakeAsJson() {
       return MatchMutable(
-          &data, [&](Json::Object* object) { return Json(std::move(*object)); },
-          [&](Json::Array* array) { return Json(std::move(*array)); });
+          &data,
+          [&](Json::Object* object) {
+            return Json::FromObject(std::move(*object));
+          },
+          [&](Json::Array* array) {
+            return Json::FromArray(std::move(*array));
+          });
     }
   };
 
@@ -307,26 +313,26 @@ void JsonReader::SetKey() {
 
 void JsonReader::SetString() {
   Json* value = CreateAndLinkValue();
-  *value = std::move(string_);
+  *value = Json::FromString(std::move(string_));
   string_.clear();
 }
 
 bool JsonReader::SetNumber() {
   Json* value = CreateAndLinkValue();
-  *value = Json(string_, /*is_number=*/true);
+  *value = Json::FromNumber(std::move(string_));
   string_.clear();
   return true;
 }
 
 void JsonReader::SetTrue() {
   Json* value = CreateAndLinkValue();
-  *value = true;
+  *value = Json::FromBool(true);
   string_.clear();
 }
 
 void JsonReader::SetFalse() {
   Json* value = CreateAndLinkValue();
-  *value = false;
+  *value = Json::FromBool(false);
   string_.clear();
 }
 
@@ -470,6 +476,7 @@ JsonReader::Status JsonReader::Run() {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               state_ = State::GRPC_JSON_STATE_VALUE_END;
+              container_just_begun_ = false;
               EndContainer();
               if (stack_.empty()) {
                 state_ = State::GRPC_JSON_STATE_END;

data/src/core/lib/json/json_util.cc

@@ -37,18 +37,13 @@ bool ParseDurationFromJson(const Json& field, Duration* duration) {
 
 bool ExtractJsonBool(const Json& json, absl::string_view field_name,
                      bool* output, std::vector<grpc_error_handle>* error_list) {
-  switch (json.type()) {
-    case Json::Type::kTrue:
-      *output = true;
-      return true;
-    case Json::Type::kFalse:
-      *output = false;
-      return true;
-    default:
-      error_list->push_back(GRPC_ERROR_CREATE(
-          absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
-      return false;
+  if (json.type() != Json::Type::kBoolean) {
+    error_list->push_back(GRPC_ERROR_CREATE(
+        absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
+    return false;
   }
+  *output = json.boolean();
+  return true;
 }
 
 bool ExtractJsonArray(const Json& json, absl::string_view field_name,

data/src/core/lib/json/json_writer.cc

@@ -145,9 +145,7 @@ void JsonWriter::EscapeString(const std::string& string) {
   OutputChar('"');
   for (size_t idx = 0; idx < string.size(); ++idx) {
     uint8_t c = static_cast<uint8_t>(string[idx]);
-    if (c == 0) {
-      break;
-    } else if (c >= 32 && c <= 126) {
+    if (c >= 32 && c <= 126) {
       if (c == '\\' || c == '"') OutputChar('\\');
       OutputChar(static_cast<char>(c));
     } else if (c < 32 || c == 127) {
@@ -311,11 +309,12 @@ void JsonWriter::DumpValue(const Json& value) {
     case Json::Type::kNumber:
       ValueRaw(value.string());
       break;
-    case Json::Type::kTrue:
-      ValueRaw(std::string("true", 4));
-      break;
-    case Json::Type::kFalse:
-      ValueRaw(std::string("false", 5));
+    case Json::Type::kBoolean:
+      if (value.boolean()) {
+        ValueRaw(std::string("true", 4));
+      } else {
+        ValueRaw(std::string("false", 5));
+      }
       break;
     case Json::Type::kNull:
       ValueRaw(std::string("null", 4));

data/src/core/lib/load_balancing/lb_policy.h

@@ -366,6 +366,19 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// whether the LB policy accepted the update; if non-OK, informs
   /// polling-based resolvers that they should go into backoff delay and
   /// eventually reattempt the resolution.
+  ///
+  /// The first time that UpdateLocked() is called, the LB policy will
+  /// generally not be able to determine the appropriate connectivity
+  /// state by the time UpdateLocked() returns (e.g., it will need to
+  /// wait for connectivity state notifications from each subchannel,
+  /// which will be delivered asynchronously).  In this case, the LB
+  /// policy should not call the helper's UpdateState() method until it
+  /// does have a clear picture of the connectivity state (e.g., it
+  /// should wait for all subchannels to report connectivity state
+  /// before calling the helper's UpdateState() method), although it is
+  /// expected to do so within some short period of time.  The parent of
+  /// the LB policy will assume that the policy's initial state is
+  /// CONNECTING and that picks should be queued.
   virtual absl::Status UpdateLocked(UpdateArgs) = 0;  // NOLINT
 
   /// Tries to enter a READY connectivity state.

data/src/core/lib/load_balancing/lb_policy_registry.cc

@@ -31,6 +31,7 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/load_balancing/lb_policy.h"
@@ -83,7 +84,7 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
   if (factory == nullptr) return false;
   // If requested, check if the load balancing policy allows an empty config.
   if (requires_config != nullptr) {
-    auto config = factory->ParseLoadBalancingConfig(Json());
+    auto config = factory->ParseLoadBalancingConfig(Json::FromObject({}));
     *requires_config = !config.ok();
   }
   return true;

data/src/core/lib/matchers/matchers.cc

@@ -159,12 +159,11 @@ std::string StringMatcher::ToString() const {
 absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
     absl::string_view name, Type type, absl::string_view matcher,
     int64_t range_start, int64_t range_end, bool present_match,
-    bool invert_match) {
+    bool invert_match, bool case_sensitive) {
   if (static_cast<int>(type) < 5) {
     // Only for EXACT, PREFIX, SUFFIX, SAFE_REGEX and CONTAINS.
-    absl::StatusOr<StringMatcher> string_matcher =
-        StringMatcher::Create(static_cast<StringMatcher::Type>(type), matcher,
-                              /*case_sensitive=*/true);
+    absl::StatusOr<StringMatcher> string_matcher = StringMatcher::Create(
+        static_cast<StringMatcher::Type>(type), matcher, case_sensitive);
     if (!string_matcher.ok()) {
       return string_matcher.status();
     }

data/src/core/lib/matchers/matchers.h

@@ -113,7 +113,8 @@ class HeaderMatcher {
                                               int64_t range_start = 0,
                                               int64_t range_end = 0,
                                               bool present_match = false,
-                                              bool invert_match = false);
+                                              bool invert_match = false,
+                                              bool case_sensitive = true);
 
   HeaderMatcher() = default;
   HeaderMatcher(const HeaderMatcher& other);

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

@@ -26,6 +26,7 @@
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/gprpp/atomic_utils.h"
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_core {
 
@@ -83,6 +84,10 @@ class FreestandingActivity::Handle final : public Wakeable {
     Unref();
   }
 
+  void WakeupAsync(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    Crash("not implemented");
+  }
+
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {

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

@@ -32,6 +32,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -56,6 +57,9 @@ class Wakeable {
   // WakeupMask comes from the activity that created this Wakeable and specifies
   // the set of promises that should be awoken.
   virtual void Wakeup(WakeupMask wakeup_mask) = 0;
+  // Per Wakeup, but guarantee that the activity will be woken up out-of-line.
+  // Useful if there may be mutexes or the like held by the current thread.
+  virtual void WakeupAsync(WakeupMask wakeup_mask) = 0;
   // Drop this wakeable without waking up the underlying activity.
   virtual void Drop(WakeupMask wakeup_mask) = 0;
 
@@ -69,6 +73,7 @@ class Wakeable {
 namespace promise_detail {
 struct Unwakeable final : public Wakeable {
   void Wakeup(WakeupMask) override {}
+  void WakeupAsync(WakeupMask) override {}
   void Drop(WakeupMask) override {}
   std::string ActivityDebugTag(WakeupMask) const override;
 };
@@ -96,6 +101,8 @@ class Waker {
   // Wake the underlying activity.
   void Wakeup() { Take().Wakeup(); }
 
+  void WakeupAsync() { Take().WakeupAsync(); }
+
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
     return H::combine(H::combine(std::move(h), w.wakeable_and_arg_.wakeable),
@@ -125,6 +132,7 @@ class Waker {
     WakeupMask wakeup_mask;
 
     void Wakeup() { wakeable->Wakeup(wakeup_mask); }
+    void WakeupAsync() { wakeable->WakeupAsync(wakeup_mask); }
     void Drop() { wakeable->Drop(wakeup_mask); }
     std::string ActivityDebugTag() const {
       return wakeable == nullptr ? "<unknown>"
@@ -512,6 +520,8 @@ class PromiseActivity final
     }
   }
 
+  void WakeupAsync(WakeupMask) final { Crash("not implemented"); }
+
   // Drop a wakeup
   void Drop(WakeupMask) final { this->WakeupComplete(); }
 

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

@@ -169,7 +169,7 @@ absl::enable_if_t<IsVoidCallable<ResultOf<F()>>::value,
                   PromiseLike<decltype(std::declval<F>()())>>
 PromiseFactoryImpl(F&& f) {
   return f();
-};
+}
 
 template <typename A, typename F>
 class OncePromiseFactory {

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

@@ -26,12 +26,11 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/trace.h"
 
-// #define GRPC_PARTY_MAXIMIZE_THREADS
-
-#ifdef GRPC_PARTY_MAXIMIZE_THREADS
+#ifdef GRPC_MAXIMIZE_THREADYNESS
 #include "src/core/lib/gprpp/thd.h"       // IWYU pragma: keep
 #include "src/core/lib/iomgr/exec_ctx.h"  // IWYU pragma: keep
 #endif
@@ -100,9 +99,9 @@ class Party::Handle final : public Wakeable {
     Unref();
   }
 
-  // Activity needs to wake up (if it still exists!) - wake it up, and drop the
-  // ref that was kept for this handle.
-  void Wakeup(WakeupMask wakeup_mask) override ABSL_LOCKS_EXCLUDED(mu_) {
+  void WakeupGeneric(WakeupMask wakeup_mask,
+                     void (Party::*wakeup_method)(WakeupMask))
+      ABSL_LOCKS_EXCLUDED(mu_) {
     mu_.Lock();
     // Note that activity refcount can drop to zero, but we could win the lock
     // against DropActivity, so we need to only increase activities refcount if
@@ -112,7 +111,7 @@ class Party::Handle final : public Wakeable {
       mu_.Unlock();
       // Activity still exists and we have a reference: wake it up, which will
       // drop the ref.
-      party->Wakeup(wakeup_mask);
+      (party->*wakeup_method)(wakeup_mask);
     } else {
       // Could not get the activity - it's either gone or going. No need to wake
       // it up!
@@ -122,6 +121,16 @@ class Party::Handle final : public Wakeable {
     Unref();
   }
 
+  // Activity needs to wake up (if it still exists!) - wake it up, and drop the
+  // ref that was kept for this handle.
+  void Wakeup(WakeupMask wakeup_mask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    WakeupGeneric(wakeup_mask, &Party::Wakeup);
+  }
+
+  void WakeupAsync(WakeupMask wakeup_mask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    WakeupGeneric(wakeup_mask, &Party::WakeupAsync);
+  }
+
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {
@@ -202,7 +211,7 @@ void Party::RunLocked() {
       PartyOver();
     }
   };
-#ifdef GRPC_PARTY_MAXIMIZE_THREADS
+#ifdef GRPC_MAXIMIZE_THREADYNESS
   Thread thd(
       "RunParty",
       [body]() {
@@ -267,15 +276,24 @@ void Party::AddParticipants(Participant** participants, size_t count) {
   Unref();
 }
 
-void Party::ScheduleWakeup(WakeupMask mask) {
-  if (sync_.ScheduleWakeup(mask)) RunLocked();
-}
-
 void Party::Wakeup(WakeupMask wakeup_mask) {
-  ScheduleWakeup(wakeup_mask);
+  if (sync_.ScheduleWakeup(wakeup_mask)) RunLocked();
   Unref();
 }
 
+void Party::WakeupAsync(WakeupMask wakeup_mask) {
+  if (sync_.ScheduleWakeup(wakeup_mask)) {
+    event_engine()->Run([this]() {
+      ApplicationCallbackExecCtx app_exec_ctx;
+      ExecCtx exec_ctx;
+      RunLocked();
+      Unref();
+    });
+  } else {
+    Unref();
+  }
+}
+
 void Party::Drop(WakeupMask) { Unref(); }
 
 void Party::PartyIsOver() {

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

@@ -27,8 +27,10 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -37,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/trace.h"
 #include "src/core/lib/resource_quota/arena.h"
 
 // Two implementations of party synchronization are provided: one using a single
@@ -453,13 +456,15 @@ class Party : public Activity, private Wakeable {
 
   // Wakeable implementation
   void Wakeup(WakeupMask wakeup_mask) final;
+  void WakeupAsync(WakeupMask wakeup_mask) final;
   void Drop(WakeupMask wakeup_mask) final;
 
-  // Organize to wake up some participants.
-  void ScheduleWakeup(WakeupMask mask);
   // Add a participant (backs Spawn, after type erasure to ParticipantFactory).
   void AddParticipants(Participant** participant, size_t count);
 
+  virtual grpc_event_engine::experimental::EventEngine* event_engine()
+      const = 0;
+
   // Sentinal value for currently_polling_ when no participant is being polled.
   static constexpr uint8_t kNotPolling = 255;
 
@@ -482,6 +487,10 @@ class Party : public Activity, private Wakeable {
 template <typename Factory, typename OnComplete>
 void Party::BulkSpawner::Spawn(absl::string_view name, Factory promise_factory,
                                OnComplete on_complete) {
+  if (grpc_trace_promise_primitives.enabled()) {
+    gpr_log(GPR_DEBUG, "%s[bulk_spawn] On %p queue %s",
+            party_->DebugTag().c_str(), this, std::string(name).c_str());
+  }
   participants_[num_participants_++] =
       party_->arena_->NewPooled<ParticipantImpl<Factory, OnComplete>>(
           name, std::move(promise_factory), std::move(on_complete));

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

@@ -377,8 +377,8 @@ class Center : public InterceptorList<T> {
 
   std::string DebugTag() {
     if (auto* activity = Activity::current()) {
-      return absl::StrCat(activity->DebugTag(), " PIPE[0x",
-                          reinterpret_cast<uintptr_t>(this), "]: ");
+      return absl::StrCat(activity->DebugTag(), " PIPE[0x", absl::Hex(this),
+                          "]: ");
     } else {
       return absl::StrCat("PIPE[0x", reinterpret_cast<uintptr_t>(this), "]: ");
     }
@@ -610,6 +610,13 @@ class PipeReceiver {
     return [center = center_]() { return center->PollEmpty(); };
   }
 
+  void CloseWithError() {
+    if (center_ != nullptr) {
+      center_->MarkCancelled();
+      center_.reset();
+    }
+  }
+
   // Interject PromiseFactory f into the pipeline.
   // f will be called with the current value traversing the pipe, and should
   // return a value to replace it with.

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

@@ -0,0 +1,95 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_PRIORITIZED_RACE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_PRIORITIZED_RACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <type_traits>
+#include <utility>
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+template <typename A, typename B>
+class TwoPartyPrioritizedRace {
+ public:
+  using Result = decltype(std::declval<A>()());
+
+  explicit TwoPartyPrioritizedRace(A a, B b)
+      : a_(std::move(a)), b_(std::move(b)) {}
+
+  Result operator()() {
+    // Check the priority promise.
+    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;
+      }
+    }
+    return p;
+  }
+
+ private:
+  A a_;
+  B b_;
+};
+
+template <typename... Promises>
+class PrioritizedRace;
+
+template <typename Promise, typename... Promises>
+class PrioritizedRace<Promise, Promises...>
+    : public TwoPartyPrioritizedRace<Promise, PrioritizedRace<Promises...>> {
+ public:
+  using Result = decltype(std::declval<Promise>()());
+  explicit PrioritizedRace(Promise promise, Promises... promises)
+      : TwoPartyPrioritizedRace<Promise, PrioritizedRace<Promises...>>(
+            std::move(promise),
+            PrioritizedRace<Promises...>(std::move(promises)...)) {}
+};
+
+template <typename Promise>
+class PrioritizedRace<Promise> {
+ public:
+  using Result = decltype(std::declval<Promise>()());
+  explicit PrioritizedRace(Promise promise) : promise_(std::move(promise)) {}
+  Result operator()() { return promise_(); }
+
+ private:
+  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)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_PRIORITIZED_RACE_H

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

@@ -41,8 +41,9 @@ Poll<absl::Status> Sleep::operator()() {
   // Invalidate now so that we see a fresh version of the time.
   // TODO(ctiller): the following can be safely removed when we remove ExecCtx.
   ExecCtx::Get()->InvalidateNow();
+  const auto now = Timestamp::Now();
   // If the deadline is earlier than now we can just return.
-  if (deadline_ <= Timestamp::Now()) return absl::OkStatus();
+  if (deadline_ <= now) return absl::OkStatus();
   if (closure_ == nullptr) {
     // TODO(ctiller): it's likely we'll want a pool of closures - probably per
     // cpu? - to avoid allocating/deallocating on fast paths.