grpc 1.73.0 → 1.75.0

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

@@ -26,8 +26,11 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/activity.h"
@@ -38,6 +41,7 @@
 #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/json/json_writer.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
@@ -167,6 +171,9 @@ class Party : public Activity, private Wakeable {
     // Destroy the participant before finishing.
     virtual void Destroy() = 0;
 
+    // Return a description of this participant.
+    virtual channelz::PropertyList ChannelzProperties() = 0;
+
     // Return a Handle instance for this participant.
     Wakeable* MakeNonOwningWakeable(Party* party);
 
@@ -281,6 +288,20 @@ class Party : public Activity, private Wakeable {
           party_->state_.load(std::memory_order_relaxed), wakeup_mask_);
     }
 
+    channelz::PropertyList ChannelzProperties() override {
+      channelz::PropertyList properties;
+      if (active_ != nullptr) {
+        properties.Set("active", active_->ChannelzProperties());
+      }
+      properties.Set("queued", [this]() {
+        channelz::PropertyTable queued;
+        next_.ForEach(
+            [&](Participant* p) { queued.AppendRow(p->ChannelzProperties()); });
+        return queued;
+      }());
+      return properties;
+    }
+
    private:
     friend class Party;
     friend class Arena;
@@ -367,6 +388,14 @@ class Party : public Activity, private Wakeable {
     return serializer;
   }
 
+  // Convert the party to a JSON object for visualization.
+  // This is an async operation because the party cannot be locked
+  // synchronously.
+  void ToJson(absl::AnyInvocable<void(Json::Object)>);
+
+  // Export the party to channelz.
+  void ExportToChannelz(std::string name, channelz::DataSink sink);
+
  protected:
   friend class Arena;
 
@@ -407,6 +436,7 @@ class Party : public Activity, private Wakeable {
     }
 
     bool PollParticipantPromise() override {
+      GRPC_LATENT_SEE_SCOPE(TypeName<SuppliedFactory>());
       if (!started_) {
         auto p = factory_.Make();
         Destruct(&factory_);
@@ -422,6 +452,21 @@ class Party : public Activity, private Wakeable {
       return false;
     }
 
+    channelz::PropertyList ChannelzProperties() override {
+      return channelz::PropertyList()
+          .Set("on_complete", TypeName<OnComplete>())
+          .Set("factory", [this]() {
+            channelz::PropertyList factory;
+            if (started_) {
+              factory.Set("promise", PromiseProperty(&promise_));
+            } else {
+              factory.Set("factory",
+                          TypeName<typename Factory::UnderlyingFactory>());
+            }
+            return factory;
+          }());
+    }
+
     void Destroy() override { delete this; }
 
    private:
@@ -463,6 +508,7 @@ class Party : public Activity, private Wakeable {
 
     // Inside party poll: drive from factory -> promise -> result
     bool PollParticipantPromise() override {
+      GRPC_LATENT_SEE_SCOPE(TypeName<SuppliedFactory>());
       switch (state_.load(std::memory_order_relaxed)) {
         case State::kFactory: {
           auto p = factory_.Make();
@@ -503,6 +549,23 @@ class Party : public Activity, private Wakeable {
 
     void Destroy() override { this->Unref(); }
 
+    channelz::PropertyList ChannelzProperties() override {
+      channelz::PropertyList properties;
+      switch (state_.load(std::memory_order_relaxed)) {
+        case State::kFactory:
+          properties.Set("factory",
+                         TypeName<typename Factory::UnderlyingFactory>());
+          break;
+        case State::kPromise:
+          properties.Set("promise", PromiseProperty(&promise_));
+          break;
+        case State::kResult:
+          properties.Set("result", TypeName<typename Promise::Result>());
+          break;
+      }
+      return properties;
+    }
+
    private:
     enum class State : uint8_t { kFactory, kPromise, kResult };
     union {
@@ -560,7 +623,7 @@ class Party : public Activity, private Wakeable {
 
   // Wakeable implementation
   void Wakeup(WakeupMask wakeup_mask) final {
-    GRPC_LATENT_SEE_INNER_SCOPE("Party::Wakeup");
+    GRPC_LATENT_SEE_SCOPE("Party::Wakeup");
     if (Activity::current() == this) {
       wakeup_mask_ |= wakeup_mask;
       Unref();
@@ -572,7 +635,7 @@ class Party : public Activity, private Wakeable {
   template <bool kReffed>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void WakeupFromState(
       uint64_t cur_state, WakeupMask wakeup_mask) {
-    GRPC_LATENT_SEE_INNER_SCOPE("Party::WakeupFromState");
+    GRPC_LATENT_SEE_SCOPE("Party::WakeupFromState");
     DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "Wakeup mask must be non-zero: " << wakeup_mask;
     while (true) {
@@ -580,7 +643,7 @@ 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.
-        if (kReffed) {
+        if constexpr (kReffed) {
           DCHECK_GT(cur_state & kRefMask, kOneRef);
         } else {
           DCHECK_GE(cur_state & kRefMask, kOneRef);
@@ -626,6 +689,8 @@ class Party : public Activity, private Wakeable {
                            new_state);
   }
 
+  channelz::PropertyList ChannelzPropertiesLocked();
+
   // Sentinel value for currently_polling_ when no participant is being polled.
   static constexpr uint8_t kNotPolling = 255;
 

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

@@ -270,6 +270,16 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline Poll<T> poll_cast(U poll) {
   return PollCastImpl<T, U>::Cast(std::move(poll));
 }
 
+template <typename T>
+bool IsPending(const T&) {
+  return false;
+}
+
+template <typename T>
+bool IsPending(const Poll<T>& poll) {
+  return poll.pending();
+}
+
 // Convert a poll to a string
 template <typename T, typename F>
 std::string PollToString(

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

@@ -19,6 +19,9 @@
 
 #include <utility>
 
+#include "src/core/util/json/json.h"
+#include "src/proto/grpc/channelz/v2/promise.upb.h"
+
 namespace grpc_core {
 
 /// Run all the promises, return the first result that's available.
@@ -47,6 +50,24 @@ class Race<Promise, Promises...> {
     return std::move(r.value());
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    auto* race_promise =
+        grpc_channelz_v2_Promise_mutable_race_promise(promise_proto, arena);
+    auto** children = grpc_channelz_v2_Promise_Race_resize_children(
+        race_promise, 1 + sizeof...(Promises), arena);
+    for (size_t i = 0; i < 1 + sizeof...(Promises); ++i) {
+      children[i] = grpc_channelz_v2_Promise_new(arena);
+    }
+    SetChildrenProto(children, 0, arena);
+  }
+
+  void SetChildrenProto(grpc_channelz_v2_Promise** promise_protos, int index,
+                        upb_Arena* arena) const {
+    PromiseAsProto(promise_, promise_protos[index], arena);
+    next_.SetChildrenProto(promise_protos, index + 1, arena);
+  }
+
  private:
   // The Promise checked by this instance.
   Promise promise_;
@@ -64,6 +85,16 @@ class Race<Promise> {
     return promise_();
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    PromiseAsProto(promise_, promise_proto, arena);
+  }
+
+  void SetChildrenProto(grpc_channelz_v2_Promise** promise_protos, int index,
+                        upb_Arena* arena) const {
+    PromiseAsProto(promise_, promise_protos[index], arena);
+  }
+
  private:
   Promise promise_;
 };

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

@@ -108,7 +108,10 @@ class Seq {
     return state_.PollOnce();
   }
 
-  Json ToJson() const { return state_.ToJson("Seq"); }
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    state_.ToProto(grpc_channelz_v2_Promise_NORMAL, promise_proto, arena);
+  }
 
  private:
   SeqState<SeqTraits, P, Fs...> state_;

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

@@ -275,6 +275,13 @@ class ValueOrFailure {
     return value_ != other;
   }
 
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator==(Failure) const {
+    return !value_.has_value();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool operator!=(Failure) const {
+    return value_.has_value();
+  }
+
  private:
   std::optional<T> value_;
 };

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

@@ -263,7 +263,10 @@ class TrySeq {
     return state_.PollOnce();
   }
 
-  Json ToJson() const { return state_.ToJson("TrySeq"); }
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    state_.ToProto(grpc_channelz_v2_Promise_TRY, promise_proto, arena);
+  }
 
  private:
   SeqState<TrySeqTraits, P, Fs...> state_;

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

@@ -0,0 +1,28 @@
+// Copyright 2025 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.
+
+#include "src/core/lib/promise/wait_set.h"
+
+#include "absl/strings/str_join.h"
+
+namespace grpc_core {
+
+std::string WaitSet::ToString() {
+  return absl::StrJoin(pending_, ", ",
+                       [](std::string* out, const Waker& waker) {
+                         absl::StrAppend(out, waker.DebugString());
+                       });
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,86 @@
+// Copyright 2021 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_WAIT_SET_H
+#define GRPC_SRC_CORE_LIB_PROMISE_WAIT_SET_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/hash/hash.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+// Helper type that can be used to enqueue many Activities waiting for some
+// external state.
+// Typically the external state should be guarded by mu_, and a call to
+// WakeAllAndUnlock should be made when the state changes.
+// Promises should bottom out polling inside pending(), which will register for
+// wakeup and return Pending().
+// Queues handles to Activities, and not Activities themselves, meaning that if
+// an Activity is destroyed prior to wakeup we end up holding only a small
+// amount of memory (around 16 bytes + malloc overhead) until the next wakeup
+// occurs.
+class WaitSet final {
+  using WakerSet = absl::flat_hash_set<Waker>;
+
+ public:
+  // Register for wakeup, return Pending(). If state is not ready to proceed,
+  // Promises should bottom out here.
+  Pending AddPending(Waker waker) {
+    pending_.emplace(std::move(waker));
+    return Pending();
+  }
+
+  class WakeupSet {
+   public:
+    void Wakeup() {
+      while (!wakeup_.empty()) {
+        wakeup_.extract(wakeup_.begin()).value().Wakeup();
+      }
+    }
+
+   private:
+    friend class WaitSet;
+    explicit WakeupSet(WakerSet&& wakeup)
+        : wakeup_(std::forward<WakerSet>(wakeup)) {}
+    WakerSet wakeup_;
+  };
+
+  GRPC_MUST_USE_RESULT WakeupSet TakeWakeupSet() {
+    auto ret = WakeupSet(std::move(pending_));
+    pending_.clear();  // reinitialize after move.
+    return ret;
+  }
+
+  void WakeupAsync() {
+    while (!pending_.empty()) {
+      pending_.extract(pending_.begin()).value().WakeupAsync();
+    }
+  }
+
+  std::string ToString();
+
+ private:
+  // Handles to activities that need to be awoken.
+  WakerSet pending_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_WAIT_SET_H

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

@@ -409,6 +409,25 @@ class ArenaSpsc {
     return result;
   }
 
+  T* Peek() {
+    Node* n = tail_.load(std::memory_order_relaxed);
+    Node* next = n->next.load(std::memory_order_acquire);
+    if (next == nullptr) return nullptr;
+    return &next->value;
+  }
+
+  // Iterate over queued nodes. At most one thread can be calling this at a
+  // time, and no other thread can be calling Pop().
+  template <typename F>
+  void ForEach(F f) {
+    Node* tail = tail_.load(std::memory_order_relaxed);
+    Node* n = tail->next.load(std::memory_order_acquire);
+    while (n != nullptr) {
+      f(n->value);
+      n = n->next.load(std::memory_order_acquire);
+    }
+  }
+
  private:
   struct Node {
     Node() {}

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

@@ -32,6 +32,8 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/exec_ctx_wakeup_scheduler.h"
 #include "src/core/lib/promise/loop.h"
@@ -407,6 +409,20 @@ grpc_slice GrpcMemoryAllocatorImpl::MakeSlice(MemoryRequest request) {
   return slice;
 }
 
+void GrpcMemoryAllocatorImpl::FillChannelzProperties(
+    channelz::PropertyList& list) {
+  list.Set("free_bytes", free_bytes_.load(std::memory_order_relaxed))
+      .Set("taken_bytes", taken_bytes_.load(std::memory_order_relaxed))
+      .Set("chosen_shard_idx",
+           chosen_shard_idx_.load(std::memory_order_relaxed))
+      .Set("donate_back_period", donate_back_.period());
+  donate_back_.Interrupt([&list](Duration so_far) {
+    list.Set("donate_back_period_expired", so_far);
+  });
+  MutexLock lock(&reclaimer_mu_);
+  list.Set("shutdown", shutdown_);
+}
+
 //
 // BasicMemoryQuota
 //
@@ -431,7 +447,11 @@ class BasicMemoryQuota::WaitForSweepPromise {
   uint64_t token_;
 };
 
-BasicMemoryQuota::BasicMemoryQuota(std::string name) : name_(std::move(name)) {}
+BasicMemoryQuota::BasicMemoryQuota(
+    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
+    : channelz::DataSource(channelz_node) {
+  channelz::DataSource::SourceConstructed();
+}
 
 void BasicMemoryQuota::Start() {
   auto self = shared_from_this();
@@ -471,7 +491,7 @@ void BasicMemoryQuota::Start() {
           if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
             double free = std::max(intptr_t{0}, self->free_bytes_.load());
             size_t quota_size = self->quota_size_.load();
-            LOG(INFO) << "RQ: " << self->name_ << " perform "
+            LOG(INFO) << "RQ: " << self->name() << " perform "
                       << std::get<0>(arg)
                       << " reclamation. Available free bytes: " << free
                       << ", total quota_size: " << quota_size;
@@ -555,7 +575,7 @@ void BasicMemoryQuota::FinishReclamation(uint64_t token, Waker waker) {
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
       double free = std::max(intptr_t{0}, free_bytes_.load());
       size_t quota_size = quota_size_.load();
-      LOG(INFO) << "RQ: " << name_
+      LOG(INFO) << "RQ: " << name()
                 << " reclamation complete. Available free bytes: " << free
                 << ", total quota_size: " << quota_size;
     }
@@ -678,6 +698,44 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   return pressure_info;
 }
 
+void BasicMemoryQuota::AddData(channelz::DataSink sink) {
+  sink.AddData(
+      "memory_quota",
+      channelz::PropertyList()
+          .Set("free_bytes", free_bytes_.load(std::memory_order_relaxed))
+          .Set("quota_size", quota_size_.load(std::memory_order_relaxed))
+          .Merge(pressure_tracker_.ChannelzProperties())
+          .Set("allocators",
+               [this]() {
+                 channelz::PropertyTable table;
+                 for (auto& shard : small_allocators_.shards) {
+                   MutexLock l(&shard.shard_mu);
+                   size_t i = 0;
+                   for (auto& allocator : shard.allocators) {
+                     i++;
+                     channelz::PropertyList list;
+                     list.Set("shard", absl::StrCat("small", i));
+                     allocator->FillChannelzProperties(list);
+                     table.AppendRow(std::move(list));
+                   }
+                 }
+                 for (auto& shard : big_allocators_.shards) {
+                   MutexLock l(&shard.shard_mu);
+                   size_t i = 0;
+                   for (auto& allocator : shard.allocators) {
+                     i++;
+                     channelz::PropertyList list;
+                     list.Set("shard", absl::StrCat("big", i));
+                     allocator->FillChannelzProperties(list);
+                     table.AppendRow(std::move(list));
+                   }
+                 }
+                 return table;
+               }())
+          .Set("reclamation_counter",
+               reclamation_counter_.load(std::memory_order_relaxed)));
+}
+
 //
 // PressureTracker
 //
@@ -789,6 +847,35 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
   return report_.load(std::memory_order_relaxed);
 }
 
+channelz::PropertyList PressureController::ChannelzProperties() const {
+  return channelz::PropertyList()
+      .Set("ticks_same_pressure", ticks_same_)
+      .Set("max_ticks_same_pressure", max_ticks_same_)
+      .Set("max_pressure_reduction_per_tick", max_reduction_per_tick_ * 0.001)
+      .Set("last_pressure_was_low", last_was_low_)
+      .Set("min_pressure", min_)
+      .Set("max_pressure", max_)
+      .Set("last_control", last_control_);
+}
+
+channelz::PropertyList PressureTracker::ChannelzProperties() {
+  return channelz::PropertyList()
+      .Set("max_pressure_this_round",
+           max_this_round_.load(std::memory_order_relaxed))
+      .Set("pressure_report", report_.load(std::memory_order_relaxed))
+      .Merge([this]() {
+        channelz::PropertyList list;
+        if (!update_.Interrupt([&](Duration duration) {
+              list = controller_.ChannelzProperties();
+              list.Set("time_since_last_pressure_update", duration);
+              list.Set("pressure_update_period", update_.period());
+            })) {
+          list.Set("pressure_controller_busy", true)
+              .Set("pressure_update_period", update_.period());
+        }
+        return list;
+      }());
+}
 }  // namespace memory_quota_detail
 
 //

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

@@ -35,6 +35,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/promise/activity.h"
@@ -233,6 +234,7 @@ class PressureController {
   double Update(double error);
   // Textual representation of the controller.
   std::string DebugString() const;
+  channelz::PropertyList ChannelzProperties() const;
 
  private:
   // How many update periods have we reached the same decision in a row?
@@ -264,6 +266,8 @@ class PressureTracker {
  public:
   double AddSampleAndGetControlValue(double sample);
 
+  channelz::PropertyList ChannelzProperties();
+
  private:
   std::atomic<double> max_this_round_{0.0};
   std::atomic<double> report_{0.0};
@@ -279,7 +283,8 @@ static constexpr size_t kBigAllocatorThreshold = 0.5 * 1024 * 1024;
 static constexpr size_t kSmallAllocatorThreshold = 0.1 * 1024 * 1024;
 
 class BasicMemoryQuota final
-    : public std::enable_shared_from_this<BasicMemoryQuota> {
+    : public std::enable_shared_from_this<BasicMemoryQuota>,
+      public channelz::DataSource {
  public:
   // Data about current memory pressure.
   struct PressureInfo {
@@ -292,7 +297,9 @@ class BasicMemoryQuota final
     size_t max_recommended_allocation_size = 0;
   };
 
-  explicit BasicMemoryQuota(std::string name);
+  explicit BasicMemoryQuota(
+      RefCountedPtr<channelz::ResourceQuotaNode> channelz_node);
+  ~BasicMemoryQuota() { channelz::DataSource::SourceDestructing(); }
 
   // Start the reclamation activity.
   void Start();
@@ -324,7 +331,9 @@ class BasicMemoryQuota final
   ReclaimerQueue* reclaimer_queue(size_t i) { return &reclaimers_[i]; }
 
   // The name of this quota
-  absl::string_view name() const { return name_; }
+  absl::string_view name() const { return channelz_node()->name(); }
+
+  void AddData(channelz::DataSink sink) override;
 
  private:
   friend class ReclamationSweep;
@@ -378,8 +387,6 @@ class BasicMemoryQuota final
   std::atomic<uint64_t> reclamation_counter_{0};
   // Memory pressure smoothing
   memory_quota_detail::PressureTracker pressure_tracker_;
-  // The name of this quota - used for debugging/tracing/etc..
-  std::string name_;
 };
 
 // MemoryAllocatorImpl grants the owner the ability to allocate memory from an
@@ -453,6 +460,8 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
     return chosen_shard_idx_.fetch_add(1, std::memory_order_relaxed);
   }
 
+  void FillChannelzProperties(channelz::PropertyList& list);
+
  private:
   static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
 
@@ -550,8 +559,9 @@ class MemoryOwner final : public MemoryAllocator {
 class MemoryQuota final
     : public grpc_event_engine::experimental::MemoryAllocatorFactory {
  public:
-  explicit MemoryQuota(std::string name)
-      : memory_quota_(std::make_shared<BasicMemoryQuota>(std::move(name))) {
+  explicit MemoryQuota(RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
+      : memory_quota_(
+            std::make_shared<BasicMemoryQuota>(std::move(channelz_node))) {
     memory_quota_->Start();
   }
   ~MemoryQuota() override {
@@ -580,8 +590,9 @@ class MemoryQuota final
 };
 
 using MemoryQuotaRefPtr = std::shared_ptr<MemoryQuota>;
-inline MemoryQuotaRefPtr MakeMemoryQuota(std::string name) {
-  return std::make_shared<MemoryQuota>(std::move(name));
+inline MemoryQuotaRefPtr MakeMemoryQuota(
+    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node) {
+  return std::make_shared<MemoryQuota>(std::move(channelz_node));
 }
 
 std::vector<std::shared_ptr<BasicMemoryQuota>> AllMemoryQuotas();

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

@@ -22,6 +22,20 @@
 
 namespace grpc_core {
 
+bool PeriodicUpdate::Interrupt(absl::FunctionRef<void(Duration)> f) {
+  int64_t old_value = updates_remaining_.load(std::memory_order_acquire);
+  while (true) {
+    if (old_value <= 1) return false;
+    if (!updates_remaining_.compare_exchange_weak(old_value, 0,
+                                                  std::memory_order_acquire)) {
+      continue;
+    }
+    f(Timestamp::Now() - period_start_);
+    updates_remaining_.store(old_value, std::memory_order_release);
+    return true;
+  }
+}
+
 bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
   if (period_start_ == Timestamp::ProcessEpoch()) {
     period_start_ = Timestamp::Now();

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

@@ -48,6 +48,14 @@ class PeriodicUpdate {
     return false;
   }
 
+  // Interrupt execution: call f as if the period expired, and then continue
+  // from where we left off.
+  // Returns false if this was not possible (eg we were at the end of a tick)
+  // Argument to the callback is the amount of time expired so far.
+  bool Interrupt(absl::FunctionRef<void(Duration)> f);
+
+  Duration period() const { return period_; }
+
  private:
   bool MaybeEndPeriod(absl::FunctionRef<void(Duration)> f);