grpc 1.68.1 → 1.69.0.pre1

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

@@ -22,6 +22,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/variant.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/construct_destruct.h"
@@ -100,6 +101,8 @@ class Loop {
   Loop& operator=(const Loop& loop) = delete;
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> operator()() {
+    GRPC_TRACE_LOG(promise_primitives, INFO)
+        << "loop[" << this << "] begin poll started=" << started_;
     if (!started_) {
       started_ = true;
       Construct(&promise_, factory_.Make());
@@ -113,14 +116,20 @@ class Loop {
         //  from our factory.
         auto lc = LoopTraits<PromiseResult>::ToLoopCtl(std::move(*p));
         if (absl::holds_alternative<Continue>(lc)) {
+          GRPC_TRACE_LOG(promise_primitives, INFO)
+              << "loop[" << this << "] iteration complete, continue";
           Destruct(&promise_);
           Construct(&promise_, factory_.Make());
           continue;
         }
+        GRPC_TRACE_LOG(promise_primitives, INFO)
+            << "loop[" << this << "] iteration complete, return";
         //  - otherwise there's our result... return it out.
         return absl::get<Result>(std::move(lc));
       } else {
         // Otherwise the inner promise was pending, so we are pending.
+        GRPC_TRACE_LOG(promise_primitives, INFO)
+            << "loop[" << this << "] pending";
         return Pending();
       }
     }

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

@@ -31,8 +31,20 @@ 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 Promise, typename Fn>
-class Map {
+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>> {
  public:
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise promise, Fn fn)
       : promise_(std::move(promise)), fn_(std::move(fn)) {}
@@ -61,6 +73,45 @@ class Map {
   Fn 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>> {
+ public:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Map(Promise promise, Fn fn)
+      : promise_(std::move(promise)), fn_(std::move(fn)) {}
+
+  Map(const Map&) = delete;
+  Map& operator=(const Map&) = delete;
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
+  Map(Map&& other) = default;
+  // NOLINTNEXTLINE(performance-noexcept-move-constructor): clang6 bug
+  Map& operator=(Map&& other) = default;
+
+  using PromiseResult = typename PromiseLike<Promise>::Result;
+  using Result = Empty;
+
+  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 Pending();
+  }
+
+ private:
+  PromiseLike<Promise> promise_;
+  Fn fn_;
+};
+
 }  // namespace promise_detail
 
 // Mapping combinator.
@@ -79,7 +130,7 @@ template <typename Promise>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline auto CheckDelayed(Promise promise) {
   using P = promise_detail::PromiseLike<Promise>;
   return [delayed = false, promise = P(std::move(promise))]() mutable
-         -> Poll<std::tuple<typename P::Result, bool>> {
+             -> Poll<std::tuple<typename P::Result, bool>> {
     auto r = promise();
     if (r.pending()) {
       delayed = true;

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

@@ -251,13 +251,16 @@ void Party::RunLockedAndUnref(Party* party, uint64_t prev_state) {
       // gets held for a really long time.
       auto wakeup =
           std::exchange(g_run_state->next, PartyWakeup{party, prev_state});
-      party->arena_->GetContext<grpc_event_engine::experimental::EventEngine>()
-          ->Run([wakeup]() {
-            GRPC_LATENT_SEE_PARENT_SCOPE("Party::RunLocked offload");
-            ApplicationCallbackExecCtx app_exec_ctx;
-            ExecCtx exec_ctx;
-            RunState{wakeup}.Run();
-          });
+      auto arena = party->arena_.get();
+      auto* event_engine =
+          arena->GetContext<grpc_event_engine::experimental::EventEngine>();
+      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();
+      });
       return;
     }
     g_run_state->next = PartyWakeup{party, prev_state};
@@ -356,50 +359,8 @@ void Party::RunPartyAndUnref(uint64_t prev_state) {
   }
 }
 
-void Party::AddParticipants(Participant** participants, size_t count) {
-  uint64_t state = state_.load(std::memory_order_acquire);
-  uint64_t allocated;
-
-  size_t slots[party_detail::kMaxParticipants];
-
-  // Find slots for each new participant, ordering them from lowest available
-  // slot upwards to ensure the same poll ordering as presentation ordering to
-  // this function.
-  WakeupMask wakeup_mask;
-  uint64_t new_state;
-  do {
-    wakeup_mask = 0;
-    allocated = (state & kAllocatedMask) >> kAllocatedShift;
-    for (size_t i = 0; i < count; i++) {
-      auto new_mask = LowestOneBit(~allocated);
-      if (GPR_UNLIKELY((new_mask & kWakeupMask) == 0)) {
-        DelayAddParticipants(participants, count);
-        return;
-      }
-      wakeup_mask |= new_mask;
-      allocated |= new_mask;
-      slots[i] = absl::countr_zero(new_mask);
-    }
-    // Try to allocate this slot and take a ref (atomically).
-    // Ref needs to be taken because once we store the participant it could be
-    // spuriously woken up and unref the party.
-    new_state = (state | (allocated << kAllocatedShift)) + kOneRef;
-  } while (!state_.compare_exchange_weak(
-      state, new_state, std::memory_order_acq_rel, std::memory_order_acquire));
-  LogStateChange("AddParticipantsAndRef", state, new_state);
-
-  for (size_t i = 0; i < count; i++) {
-    GRPC_TRACE_LOG(party_state, INFO)
-        << "Party " << this << "                 AddParticipant: " << slots[i]
-        << " " << participants[i];
-    participants_[slots[i]].store(participants[i], std::memory_order_release);
-  }
-
-  // Now we need to wake up the party.
-  WakeupFromState(new_state, wakeup_mask);
-}
-
 void Party::AddParticipant(Participant* participant) {
+  GRPC_LATENT_SEE_INNER_SCOPE("Party::AddParticipant");
   uint64_t state = state_.load(std::memory_order_acquire);
   uint64_t allocated;
   size_t slot;
@@ -413,7 +374,7 @@ void Party::AddParticipant(Participant* participant) {
     allocated = (state & kAllocatedMask) >> kAllocatedShift;
     wakeup_mask = LowestOneBit(~allocated);
     if (GPR_UNLIKELY((wakeup_mask & kWakeupMask) == 0)) {
-      DelayAddParticipants(&participant, 1);
+      DelayAddParticipant(participant);
       return;
     }
     DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
@@ -436,20 +397,16 @@ void Party::AddParticipant(Participant* participant) {
   WakeupFromState(new_state, wakeup_mask);
 }
 
-void Party::DelayAddParticipants(Participant** participants, size_t count) {
+void Party::DelayAddParticipant(Participant* participant) {
   // We need to delay the addition of participants.
   IncrementRefCount();
-  VLOG_EVERY_N_SEC(2, 10) << "Delaying addition of " << count
-                          << " participants to party " << this
-                          << " because it is full.";
-  std::vector<Participant*> delayed_participants{participants,
-                                                 participants + count};
+  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, delayed_participants = std::move(delayed_participants)]() mutable {
+      [this, participant]() mutable {
         ApplicationCallbackExecCtx app_exec_ctx;
         ExecCtx exec_ctx;
-        AddParticipants(delayed_participants.data(),
-                        delayed_participants.size());
+        AddParticipant(participant);
         Unref();
       });
 }
@@ -468,6 +425,7 @@ void Party::WakeupAsync(WakeupMask wakeup_mask) {
         wakeup_mask_ |= 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);

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

@@ -82,6 +82,52 @@ class Party : public Activity, private Wakeable {
   Party(const Party&) = delete;
   Party& operator=(const Party&) = delete;
 
+  // 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
+  // it runs the party in its destructor, effectively holding all wakeups of the
+  // party until it goes out of scope.
+  // If it fails, presumably some other thread holds the lock - and in this case
+  // we don't attempt to do any buffering.
+  class WakeupHold {
+   public:
+    WakeupHold() = default;
+    explicit WakeupHold(Party* party)
+        : prev_state_(party->state_.load(std::memory_order_relaxed)) {
+      // Try to lock
+      if ((prev_state_ & kLocked) == 0 &&
+          party->state_.compare_exchange_weak(prev_state_,
+                                              (prev_state_ | kLocked) + kOneRef,
+                                              std::memory_order_relaxed)) {
+        DCHECK_EQ(prev_state_ & ~(kRefMask | kAllocatedMask), 0u)
+            << "Party should have contained no wakeups on lock";
+        // If we win, record that fact for the destructor
+        party->LogStateChange("WakeupHold", prev_state_,
+                              (prev_state_ | kLocked) + kOneRef);
+        party_ = party;
+      }
+    }
+    WakeupHold(const WakeupHold&) = delete;
+    WakeupHold& operator=(const WakeupHold&) = delete;
+    WakeupHold(WakeupHold&& other) noexcept
+        : party_(std::exchange(other.party_, nullptr)),
+          prev_state_(other.prev_state_) {}
+    WakeupHold& operator=(WakeupHold&& other) noexcept {
+      std::swap(party_, other.party_);
+      std::swap(prev_state_, other.prev_state_);
+      return *this;
+    }
+
+    ~WakeupHold() {
+      if (party_ == nullptr) return;
+      party_->RunLockedAndUnref(party_, prev_state_);
+    }
+
+   private:
+    Party* party_ = nullptr;
+    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)));
@@ -135,23 +181,6 @@ class Party : public Activity, private Wakeable {
 
   Arena* arena() { return arena_.get(); }
 
-  class BulkSpawner {
-   public:
-    explicit BulkSpawner(Party* party) : party_(party) {}
-    ~BulkSpawner() {
-      party_->AddParticipants(participants_, num_participants_);
-    }
-
-    template <typename Factory, typename OnComplete>
-    void Spawn(absl::string_view name, Factory promise_factory,
-               OnComplete on_complete);
-
-   private:
-    Party* const party_;
-    size_t num_participants_ = 0;
-    Participant* participants_[party_detail::kMaxParticipants];
-  };
-
  protected:
   friend class Arena;
 
@@ -342,6 +371,7 @@ class Party : public Activity, private Wakeable {
 
   // Wakeable implementation
   void Wakeup(WakeupMask wakeup_mask) final {
+    GRPC_LATENT_SEE_INNER_SCOPE("Party::Wakeup");
     if (Activity::current() == this) {
       wakeup_mask_ |= wakeup_mask;
       Unref();
@@ -352,6 +382,7 @@ class Party : public Activity, private Wakeable {
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void WakeupFromState(
       uint64_t cur_state, WakeupMask wakeup_mask) {
+    GRPC_LATENT_SEE_INNER_SCOPE("Party::WakeupFromState");
     DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "Wakeup mask must be non-zero: " << wakeup_mask;
     while (true) {
@@ -384,9 +415,8 @@ class Party : public Activity, private Wakeable {
   void Drop(WakeupMask wakeup_mask) final;
 
   // Add a participant (backs Spawn, after type erasure to ParticipantFactory).
-  void AddParticipants(Participant** participant, size_t count);
   void AddParticipant(Participant* participant);
-  void DelayAddParticipants(Participant** participant, size_t count);
+  void DelayAddParticipant(Participant* participant);
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void LogStateChange(
       const char* op, uint64_t prev_state, uint64_t new_state,
@@ -397,7 +427,7 @@ class Party : public Activity, private Wakeable {
                            new_state);
   }
 
-  // Sentinal value for currently_polling_ when no participant is being polled.
+  // Sentinel value for currently_polling_ when no participant is being polled.
   static constexpr uint8_t kNotPolling = 255;
 
   std::atomic<uint64_t> state_{kOneRef};
@@ -415,16 +445,6 @@ 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) {
-  GRPC_TRACE_LOG(promise_primitives, INFO)
-      << party_->DebugTag() << "[bulk_spawn] On " << this << " queue " << name
-      << " (" << sizeof(ParticipantImpl<Factory, OnComplete>) << " bytes)";
-  participants_[num_participants_++] = new ParticipantImpl<Factory, OnComplete>(
-      name, std::move(promise_factory), std::move(on_complete));
-}
-
 template <typename Factory, typename OnComplete>
 void Party::Spawn(absl::string_view name, Factory promise_factory,
                   OnComplete on_complete) {

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

@@ -286,6 +286,19 @@ void AbslStringify(Sink& sink, const Poll<T>& poll) {
   absl::Format(&sink, "%v", poll.value());
 }
 
+template <typename Sink, typename T>
+void AbslStringify(Sink& sink, const Poll<absl::StatusOr<T>>& poll) {
+  if (poll.pending()) {
+    absl::Format(&sink, "<<pending>>");
+    return;
+  }
+  if (poll.value().ok()) {
+    absl::Format(&sink, "%v", *poll.value());
+  } else {
+    absl::Format(&sink, "%v", poll.value().status());
+  }
+}
+
 template <typename Sink, typename T>
 void AbslStringify(Sink& sink, const Poll<absl::optional<T>>& poll) {
   if (poll.pending()) {

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

@@ -47,12 +47,6 @@ struct SeqTraits {
   static R ReturnValue(T&&) {
     abort();
   }
-  template <typename F, typename Elem>
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallSeqFactory(F& f,
-                                                                  Elem&& elem,
-                                                                  T&& value) {
-    return f(std::forward<Elem>(elem), std::forward<T>(value));
-  }
   template <typename Result, typename PriorResult, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
   CheckResultAndRunNext(PriorResult prior, RunNext run_next) {
@@ -77,25 +71,8 @@ class Seq {
   SeqState<SeqTraits, P, Fs...> state_;
 };
 
-template <typename I, typename F, typename Arg>
-struct SeqIterTraits {
-  using Iter = I;
-  using Factory = F;
-  using Argument = Arg;
-  using IterValue = decltype(*std::declval<Iter>());
-  using StateCreated = decltype(std::declval<F>()(std::declval<IterValue>(),
-                                                  std::declval<Arg>()));
-  using State = PromiseLike<StateCreated>;
-  using Wrapped = typename State::Result;
-
-  using Traits = SeqTraits<Wrapped>;
-};
-
 template <typename Iter, typename Factory, typename Argument>
-struct SeqIterResultTraits {
-  using IterTraits = SeqIterTraits<Iter, Factory, Argument>;
-  using Result = BasicSeqIter<IterTraits>;
-};
+using SeqIter = BasicSeqIter<SeqTraits, Iter, Factory, Argument>;
 
 }  // namespace promise_detail
 
@@ -227,11 +204,11 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
 //   }
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
-typename promise_detail::SeqIterResultTraits<Iter, Factory, Argument>::Result
-SeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
-  using Result = typename promise_detail::SeqIterResultTraits<Iter, Factory,
-                                                              Argument>::Result;
-  return Result(begin, end, std::move(factory), std::move(argument));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto SeqIter(Iter begin, Iter end,
+                                                  Argument argument,
+                                                  Factory factory) {
+  return promise_detail::SeqIter<Iter, Factory, Argument>(
+      begin, end, std::move(factory), std::move(argument));
 }
 
 }  // namespace grpc_core

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

@@ -55,6 +55,13 @@ struct StatusCastImpl<absl::Status, Success> {
   }
 };
 
+template <>
+struct StatusCastImpl<absl::Status, Success&> {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(Success) {
+    return absl::OkStatus();
+  }
+};
+
 template <>
 struct StatusCastImpl<absl::Status, const Success&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::Status Cast(Success) {

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

@@ -53,13 +53,6 @@ struct TrySeqTraitsWithSfinae {
   static R ReturnValue(T&&) {
     abort();
   }
-  template <typename F, typename Elem>
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallSeqFactory(F& f,
-                                                                  Elem&& elem,
-                                                                  T&& value)
-      -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
-    return f(std::forward<Elem>(elem), std::forward<T>(value));
-  }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
   CheckResultAndRunNext(T prior, RunNext run_next) {
@@ -88,12 +81,6 @@ struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
       absl::StatusOr<T>&& status) {
     return FailureStatusCast<R>(status.status());
   }
-  template <typename F, typename Elem>
-  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallSeqFactory(
-      F& f, Elem&& elem, absl::StatusOr<T> value)
-      -> decltype(f(std::forward<Elem>(elem), std::move(*value))) {
-    return f(std::forward<Elem>(elem), std::move(*value));
-  }
   template <typename Result, typename RunNext>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
   CheckResultAndRunNext(absl::StatusOr<T> prior, RunNext run_next) {
@@ -241,24 +228,30 @@ class TrySeq {
   SeqState<TrySeqTraits, P, Fs...> state_;
 };
 
-template <typename I, typename F, typename Arg>
-struct TrySeqIterTraits {
-  using Iter = I;
-  using Factory = F;
-  using Argument = Arg;
-  using IterValue = decltype(*std::declval<Iter>());
-  using StateCreated = decltype(std::declval<F>()(std::declval<IterValue>(),
-                                                  std::declval<Arg>()));
-  using State = PromiseLike<StateCreated>;
-  using Wrapped = typename State::Result;
-
-  using Traits = TrySeqTraits<Wrapped>;
-};
-
 template <typename Iter, typename Factory, typename Argument>
-struct TrySeqIterResultTraits {
-  using IterTraits = TrySeqIterTraits<Iter, Factory, Argument>;
-  using Result = BasicSeqIter<IterTraits>;
+using TrySeqIter = BasicSeqIter<TrySeqTraits, Iter, Factory, Argument>;
+
+template <typename Container, typename Factory, typename Argument>
+struct TrySeqContainerResultTraits {
+  using BaseResult =
+      TrySeqIter<typename Container::iterator, Factory, Argument>;
+  class Result {
+   public:
+    Result(Container container, Factory factory, Argument argument)
+        : container_(std::move(container)),
+          base_result_(container_.begin(), container_.end(), std::move(factory),
+                       std::move(argument)) {}
+    Result(const Result&) = delete;
+    Result& operator=(const Result&) = delete;
+    Result(Result&&) = default;
+    Result& operator=(Result&&) = default;
+
+    auto operator()() { return base_result_(); }
+
+   private:
+    Container container_;
+    BaseResult base_result_;
+  };
 };
 
 }  // namespace promise_detail
@@ -352,14 +345,19 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
 //   }
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
-    typename promise_detail::TrySeqIterResultTraits<Iter, Factory,
-                                                    Argument>::Result
-    TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto TrySeqIter(Iter begin, Iter end,
+                                                     Argument argument,
+                                                     Factory factory) {
+  return promise_detail::TrySeqIter<Iter, Factory, Argument>(
+      begin, end, std::move(factory), std::move(argument));
+}
+
+template <typename Container, typename Factory, typename Argument>
+auto TrySeqContainer(Container container, Argument argument, Factory factory) {
   using Result =
-      typename promise_detail::TrySeqIterResultTraits<Iter, Factory,
-                                                      Argument>::Result;
-  return Result(begin, end, std::move(factory), std::move(argument));
+      typename promise_detail::TrySeqContainerResultTraits<Container, Factory,
+                                                           Argument>::Result;
+  return Result(std::move(container), std::move(factory), std::move(argument));
 }
 
 }  // namespace grpc_core

data/src/core/lib/resource_quota/api.h

@@ -20,7 +20,7 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "src/core/lib/config/core_configuration.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 
 typedef struct grpc_resource_quota grpc_resource_quota;

data/src/core/lib/resource_quota/memory_quota.cc

@@ -130,8 +130,18 @@ class SliceRefCount : public grpc_slice_refcount {
   size_t size_;
 };
 
+std::atomic<double> container_memory_pressure{0.0};
+
 }  // namespace
 
+void SetContainerMemoryPressure(double pressure) {
+  container_memory_pressure.store(pressure, std::memory_order_relaxed);
+}
+
+double ContainerMemoryPressure() {
+  return container_memory_pressure.load(std::memory_order_relaxed);
+}
+
 //
 // Reclaimer
 //
@@ -346,7 +356,7 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
     size_t ret = 0;
     if (!IsUnconstrainedMaxQuotaBufferSizeEnabled() &&
         free > kMaxQuotaBufferSize / 2) {
-      ret = std::max(ret, free - kMaxQuotaBufferSize / 2);
+      ret = std::max(ret, free - (kMaxQuotaBufferSize / 2));
     }
     ret = std::max(ret, free > 8192 ? free / 2 : free);
     const size_t new_free = free - ret;
@@ -646,7 +656,8 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   double size = quota_size;
   if (size < 1) return PressureInfo{1, 1, 1};
   PressureInfo pressure_info;
-  pressure_info.instantaneous_pressure = std::max(0.0, (size - free) / size);
+  pressure_info.instantaneous_pressure =
+      std::max({0.0, (size - free) / size, ContainerMemoryPressure()});
   pressure_info.pressure_control_value =
       pressure_tracker_.AddSampleAndGetControlValue(
           pressure_info.instantaneous_pressure);
@@ -708,7 +719,7 @@ double PressureController::Update(double error) {
     // The first switchover will have last_control_ being 0, and max_ being 2,
     // so we'll immediately choose 1.0 which will tend to really slow down
     // progress.
-    // If we end up targetting too low, we'll eventually move it back towards
+    // If we end up targeting too low, we'll eventually move it back towards
     // 1.0 after max_ticks_same_ ticks.
     ticks_same_ = 0;
     max_ = (last_control_ + max_) / 2.0;
@@ -719,8 +730,8 @@ double PressureController::Update(double error) {
   // (If we want a control value that's higher than the last one we snap
   // immediately because it's likely that memory pressure is growing unchecked).
   if (new_control < last_control_) {
-    new_control =
-        std::max(new_control, last_control_ - max_reduction_per_tick_ / 1000.0);
+    new_control = std::max(new_control,
+                           last_control_ - (max_reduction_per_tick_ / 1000.0));
   }
   last_control_ = new_control;
   return new_control;

data/src/core/lib/resource_quota/memory_quota.h

@@ -239,7 +239,7 @@ class PressureController {
  private:
   // How many update periods have we reached the same decision in a row?
   // Too many and we should start expanding the search space since we're not
-  // being agressive enough.
+  // being aggressive enough.
   uint8_t ticks_same_ = 0;
   // Maximum number of ticks with the same value until we start expanding the
   // control space.
@@ -588,6 +588,10 @@ inline MemoryQuotaRefPtr MakeMemoryQuota(std::string name) {
 
 std::vector<std::shared_ptr<BasicMemoryQuota>> AllMemoryQuotas();
 
+void SetContainerMemoryPressure(double pressure);
+
+double ContainerMemoryPressure();
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H

data/src/core/lib/resource_quota/periodic_update.cc

@@ -32,7 +32,7 @@ bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
   // the decrementer that got us there.
   // We can now safely mutate any non-atomic mutable variables (we've got a
   // guarantee that no other thread will), and by the time this function returns
-  // we must store a postive number into updates_remaining_.
+  // we must store a positive number into updates_remaining_.
   auto now = Timestamp::Now();
   Duration time_so_far = now - period_start_;
   if (time_so_far < period_) {