grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -27,7 +27,6 @@
 
 #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"
@@ -41,6 +40,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/grpc_check.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -211,7 +211,7 @@ class Party : public Activity, private Wakeable {
           party->state_.compare_exchange_weak(prev_state_,
                                               (prev_state_ | kLocked) + kOneRef,
                                               std::memory_order_relaxed)) {
-        DCHECK_EQ(prev_state_ & ~(kRefMask | kAllocatedMask), 0u)
+        GRPC_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_,
@@ -349,7 +349,7 @@ class Party : public Activity, private Wakeable {
   // Activity implementation: not allowed to be overridden by derived types.
   void ForceImmediateRepoll(WakeupMask mask) final;
   WakeupMask CurrentParticipant() const final {
-    DCHECK(currently_polling_ != kNotPolling);
+    GRPC_DCHECK(currently_polling_ != kNotPolling);
     return 1u << currently_polling_;
   }
   Waker MakeOwningWaker() final;
@@ -383,7 +383,7 @@ class Party : public Activity, private Wakeable {
   SpawnSerializer* MakeSpawnSerializer() {
     auto* const serializer = arena_->New<SpawnSerializer>(this);
     const size_t slot = AddParticipant(serializer);
-    DCHECK_NE(slot, std::numeric_limits<size_t>::max());
+    GRPC_DCHECK_NE(slot, std::numeric_limits<size_t>::max());
     serializer->wakeup_mask_ = 1ull << slot;
     return serializer;
   }
@@ -401,8 +401,9 @@ class Party : public Activity, private Wakeable {
 
   // Derived types should be constructed upon `arena`.
   explicit Party(RefCountedPtr<Arena> arena) : arena_(std::move(arena)) {
-    CHECK(arena_->GetContext<grpc_event_engine::experimental::EventEngine>() !=
-          nullptr);
+    GRPC_CHECK(
+        arena_->GetContext<grpc_event_engine::experimental::EventEngine>() !=
+        nullptr);
   }
   ~Party() override;
 
@@ -455,15 +456,11 @@ class Party : public Activity, private Wakeable {
     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;
+          .Set("factory", TypeName<typename Factory::UnderlyingFactory>())
+          .Merge([this]() {
+            channelz::PropertyList p;
+            if (started_) p.Set("promise", PromiseProperty(&promise_));
+            return p;
           }());
     }
 
@@ -636,7 +633,7 @@ class Party : public Activity, private Wakeable {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void WakeupFromState(
       uint64_t cur_state, WakeupMask wakeup_mask) {
     GRPC_LATENT_SEE_SCOPE("Party::WakeupFromState");
-    DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
+    GRPC_DCHECK_NE(wakeup_mask & kWakeupMask, 0u)
         << "Wakeup mask must be non-zero: " << wakeup_mask;
     while (true) {
       if (cur_state & kLocked) {
@@ -644,9 +641,9 @@ class Party : public Activity, private Wakeable {
         // we'll immediately unref. Since something is running this should never
         // bring the refcount to zero.
         if constexpr (kReffed) {
-          DCHECK_GT(cur_state & kRefMask, kOneRef);
+          GRPC_DCHECK_GT(cur_state & kRefMask, kOneRef);
         } else {
-          DCHECK_GE(cur_state & kRefMask, kOneRef);
+          GRPC_DCHECK_GE(cur_state & kRefMask, kOneRef);
         }
         const uint64_t new_state =
             (cur_state | wakeup_mask) - (kReffed ? kOneRef : 0);
@@ -657,7 +654,7 @@ 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);
+        GRPC_DCHECK_EQ(cur_state & kWakeupMask, 0u);
         const uint64_t new_state =
             (cur_state | kLocked) + (kReffed ? 0 : kOneRef);
         if (state_.compare_exchange_weak(cur_state, new_state,

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

@@ -25,7 +25,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/promise/activity.h"
@@ -37,6 +36,7 @@
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {
@@ -58,10 +58,10 @@ struct Pipe;
 template <typename T>
 class NextResult final {
  public:
-  NextResult() : center_(nullptr) {}
+  NextResult() : center_(nullptr), cancelled_(true) {}
   explicit NextResult(RefCountedPtr<pipe_detail::Center<T>> center)
-      : center_(std::move(center)) {
-    CHECK(center_ != nullptr);
+      : center_(std::move(center)), cancelled_(false) {
+    GRPC_CHECK(center_ != nullptr);
   }
   explicit NextResult(bool cancelled)
       : center_(nullptr), cancelled_(cancelled) {}
@@ -77,11 +77,11 @@ class NextResult final {
   bool has_value() const;
   // Only valid if has_value()
   const T& value() const {
-    CHECK(has_value());
+    GRPC_CHECK(has_value());
     return **this;
   }
   T& value() {
-    CHECK(has_value());
+    GRPC_CHECK(has_value());
     return **this;
   }
   const T& operator*() const;
@@ -118,7 +118,7 @@ class Center : public InterceptorList<T> {
     GRPC_TRACE_VLOG(promise_primitives, 2)
         << DebugOpString("IncrementRefCount");
     refs_++;
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
   }
 
   RefCountedPtr<Center> Ref() {
@@ -130,7 +130,7 @@ class Center : public InterceptorList<T> {
   // If no refs remain, destroy this object
   void Unref() {
     GRPC_TRACE_VLOG(promise_primitives, 2) << DebugOpString("Unref");
-    DCHECK_GT(refs_, 0);
+    GRPC_DCHECK_GT(refs_, 0);
     refs_--;
     if (0 == refs_) {
       this->~Center();
@@ -143,7 +143,7 @@ class Center : public InterceptorList<T> {
   // Return false if the recv end is closed.
   Poll<bool> Push(T* value) {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Push");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
       case ValueState::kReadyClosed:
@@ -165,7 +165,7 @@ class Center : public InterceptorList<T> {
 
   Poll<bool> PollAck() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollAck");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kClosed:
         return true;
@@ -191,7 +191,7 @@ class Center : public InterceptorList<T> {
   // Return nullopt if the send end is closed and no value had been pushed.
   Poll<std::optional<T>> Next() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("Next");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -216,7 +216,7 @@ class Center : public InterceptorList<T> {
   Poll<bool> PollClosedForSender() {
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugOpString("PollClosedForSender");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -238,7 +238,7 @@ class Center : public InterceptorList<T> {
   Poll<bool> PollClosedForReceiver() {
     GRPC_TRACE_LOG(promise_primitives, INFO)
         << DebugOpString("PollClosedForReceiver");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kEmpty:
       case ValueState::kAcked:
@@ -257,7 +257,7 @@ class Center : public InterceptorList<T> {
 
   Poll<Empty> PollEmpty() {
     GRPC_TRACE_LOG(promise_primitives, INFO) << DebugOpString("PollEmpty");
-    DCHECK_NE(refs_, 0);
+    GRPC_DCHECK_NE(refs_, 0);
     switch (value_state_) {
       case ValueState::kReady:
       case ValueState::kReadyClosed:
@@ -646,7 +646,7 @@ class Push {
         return Pending{};
       }
     }
-    DCHECK(std::holds_alternative<AwaitingAck>(state_));
+    GRPC_DCHECK(std::holds_alternative<AwaitingAck>(state_));
     return center_->PollAck();
   }
 

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

@@ -21,10 +21,11 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "src/core/util/construct_destruct.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -112,12 +113,12 @@ class Poll {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ready() const { return ready_; }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T& value() {
-    DCHECK(ready());
+    GRPC_DCHECK(ready());
     return value_;
   }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T& value() const {
-    DCHECK(ready());
+    GRPC_DCHECK(ready());
     return value_;
   }
 
@@ -174,7 +175,7 @@ class Poll<Empty> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool ready() const { return ready_; }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Empty value() const {
-    DCHECK(ready());
+    GRPC_DCHECK(ready());
     return Empty{};
   }
 

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

@@ -24,8 +24,6 @@
 #include "absl/status/status.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
-#include "src/core/util/function_signature.h"
-#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 

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

@@ -56,7 +56,9 @@ Poll<absl::Status> Sleep::operator()() {
 }
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
-    : waker_(GetContext<Activity>()->MakeOwningWaker()),
+    : waker_((IsSleepUseNonOwningWakerEnabled())
+                 ? GetContext<Activity>()->MakeNonOwningWaker()
+                 : GetContext<Activity>()->MakeOwningWaker()),
       event_engine_(GetContext<EventEngine>()->shared_from_this()),
       timer_handle_(
           event_engine_->RunAfter(deadline - Timestamp::Now(), this)) {}

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

@@ -20,12 +20,12 @@
 #include <optional>
 #include <ostream>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "src/core/lib/promise/detail/status.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -198,7 +198,7 @@ template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
       StatusFlag flag) {
-    DCHECK(!flag.ok());
+    GRPC_DCHECK(!flag.ok());
     return absl::CancelledError();
   }
 };
@@ -207,7 +207,7 @@ template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, StatusFlag&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
       StatusFlag flag) {
-    DCHECK(!flag.ok());
+    GRPC_DCHECK(!flag.ok());
     return absl::CancelledError();
   }
 };
@@ -216,7 +216,7 @@ template <typename T>
 struct FailureStatusCastImpl<absl::StatusOr<T>, const StatusFlag&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static absl::StatusOr<T> Cast(
       StatusFlag flag) {
-    DCHECK(!flag.ok());
+    GRPC_DCHECK(!flag.ok());
     return absl::CancelledError();
   }
 };
@@ -230,7 +230,7 @@ class ValueOrFailure {
   // NOLINTNEXTLINE(google-explicit-constructor)
   ValueOrFailure(Failure) {}
   // NOLINTNEXTLINE(google-explicit-constructor)
-  ValueOrFailure(StatusFlag status) { CHECK(!status.ok()); }
+  ValueOrFailure(StatusFlag status) { GRPC_CHECK(!status.ok()); }
 
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure FromOptional(
       std::optional<T> value) {
@@ -356,7 +356,7 @@ template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, StatusFlag&> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(
       StatusFlag f) {
-    CHECK(!f.ok());
+    GRPC_CHECK(!f.ok());
     return ValueOrFailure<T>(Failure{});
   }
 };
@@ -365,7 +365,7 @@ template <typename T>
 struct StatusCastImpl<ValueOrFailure<T>, StatusFlag> {
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static ValueOrFailure<T> Cast(
       StatusFlag f) {
-    CHECK(!f.ok());
+    GRPC_CHECK(!f.ok());
     return ValueOrFailure<T>(Failure{});
   }
 };

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

@@ -20,7 +20,6 @@
 #include <tuple>
 #include <variant>
 
-#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -28,6 +27,7 @@
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -212,7 +212,7 @@ struct TryJoinTraits {
   template <typename R, typename T>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R EarlyReturn(
       const ValueOrFailure<T>& x) {
-    CHECK(!x.ok());
+    GRPC_CHECK(!x.ok());
     return FailureStatusCast<R>(Failure{});
   }
   template <typename... A>

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

@@ -21,7 +21,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -31,6 +30,7 @@
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -208,7 +208,7 @@ struct TrySeqTraitsWithSfinae<
   }
   template <typename R>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(T&& status) {
-    DCHECK(!IsStatusOk(status));
+    GRPC_DCHECK(!IsStatusOk(status));
     return FailureStatusCast<R>(status.status());
   }
   template <typename Result, typename RunNext>

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

@@ -102,6 +102,20 @@ template <typename T>
 const uint16_t ArenaContextTraits<T>::id_ =
     BaseArenaContextTraits::MakeId(DestroyArenaContext<T>);
 
+template <typename T, typename SfinaeVoid = void>
+struct GetContextId {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static uint16_t id() {
+    return ArenaContextTraits<T>::id();
+  }
+};
+
+template <typename T>
+struct GetContextId<T, std::void_t<typename ContextSubclass<T>::Base>> {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static uint16_t id() {
+    return GetContextId<typename ContextSubclass<T>::Base>::id();
+  }
+};
+
 template <typename T, typename A, typename B>
 struct IfArray {
   using Result = A;
@@ -292,8 +306,7 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
   // often needs to access these directly.
   template <typename T>
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T* GetContext() {
-    return static_cast<T*>(
-        contexts()[arena_detail::ArenaContextTraits<T>::id()]);
+    return static_cast<T*>(contexts()[arena_detail::GetContextId<T>::id()]);
   }
 
   template <typename T>

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

@@ -19,7 +19,7 @@
 #include <atomic>
 #include <cstdint>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -27,16 +27,17 @@ ConnectionQuota::ConnectionQuota() = default;
 
 void ConnectionQuota::SetMaxIncomingConnections(int max_incoming_connections) {
   // The maximum can only be configured once.
-  CHECK_LT(max_incoming_connections, INT_MAX);
-  CHECK(max_incoming_connections_.exchange(
-            max_incoming_connections, std::memory_order_release) == INT_MAX);
+  GRPC_CHECK_LT(max_incoming_connections, INT_MAX);
+  GRPC_CHECK(max_incoming_connections_.exchange(max_incoming_connections,
+                                                std::memory_order_release) ==
+             INT_MAX);
 }
 
 // Returns true if the incoming connection is allowed to be accepted on the
 // server.
 bool ConnectionQuota::AllowIncomingConnection(MemoryQuotaRefPtr mem_quota,
                                               absl::string_view /*peer*/) {
-  if (mem_quota->IsMemoryPressureHigh()) {
+  if (mem_quota->RejectNewConnectionsUnderHighMemoryPressure()) {
     return false;
   }
 
@@ -62,8 +63,9 @@ void ConnectionQuota::ReleaseConnections(int num_connections) {
   if (max_incoming_connections_.load(std::memory_order_relaxed) == INT_MAX) {
     return;
   }
-  CHECK(active_incoming_connections_.fetch_sub(
-            num_connections, std::memory_order_acq_rel) >= num_connections);
+  GRPC_CHECK(active_incoming_connections_.fetch_sub(
+                 num_connections, std::memory_order_acq_rel) >=
+             num_connections);
 }
 
 }  // namespace grpc_core

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

@@ -28,7 +28,6 @@
 #include <tuple>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -40,7 +39,9 @@
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/seq.h"
+#include "src/core/lib/resource_tracker/resource_tracker.h"
 #include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/mpscq.h"
 #include "src/core/util/useful.h"
 
@@ -132,16 +133,20 @@ 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);
+  auto* tracker = ResourceTracker::Get();
+  if (tracker == nullptr) {
+    return 0.0;
+  }
+  auto value = tracker->GetMetricValue("memory");
+  if (!value.ok()) {
+    LOG(WARNING) << "Failed to get 'memory' metric from ResourceTracker: "
+                 << value.status();
+    return 0.0;
+  }
+  return *value;
 }
 
 //
@@ -272,9 +277,9 @@ GrpcMemoryAllocatorImpl::GrpcMemoryAllocatorImpl(
 }
 
 GrpcMemoryAllocatorImpl::~GrpcMemoryAllocatorImpl() {
-  CHECK_EQ(free_bytes_.load(std::memory_order_acquire) +
-               sizeof(GrpcMemoryAllocatorImpl),
-           taken_bytes_.load(std::memory_order_relaxed));
+  GRPC_CHECK_EQ(free_bytes_.load(std::memory_order_acquire) +
+                    sizeof(GrpcMemoryAllocatorImpl),
+                taken_bytes_.load(std::memory_order_relaxed));
   memory_quota_->Return(taken_bytes_.load(std::memory_order_relaxed));
 }
 
@@ -285,7 +290,7 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
       reclamation_handles[kNumReclamationPasses];
   {
     MutexLock lock(&reclaimer_mu_);
-    CHECK(!shutdown_);
+    GRPC_CHECK(!shutdown_);
     shutdown_ = true;
     memory_quota = memory_quota_;
     for (size_t i = 0; i < kNumReclamationPasses; i++) {
@@ -297,8 +302,8 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
 size_t GrpcMemoryAllocatorImpl::Reserve(MemoryRequest request) {
   // Validate request - performed here so we don't bloat the generated code with
   // inlined asserts.
-  CHECK(request.min() <= request.max());
-  CHECK(request.max() <= MemoryRequest::max_allowed_size());
+  GRPC_CHECK(request.min() <= request.max());
+  GRPC_CHECK(request.max() <= MemoryRequest::max_allowed_size());
   size_t old_free = free_bytes_.load(std::memory_order_relaxed);
 
   while (true) {
@@ -376,7 +381,7 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
                                           std::memory_order_acquire)) {
       GRPC_TRACE_LOG(resource_quota, INFO)
           << "[" << this << "] Early return " << ret << " bytes";
-      CHECK(taken_bytes_.fetch_sub(ret, std::memory_order_relaxed) >= ret);
+      GRPC_CHECK(taken_bytes_.fetch_sub(ret, std::memory_order_relaxed) >= ret);
       memory_quota_->Return(ret);
       return;
     }
@@ -448,11 +453,20 @@ class BasicMemoryQuota::WaitForSweepPromise {
 };
 
 BasicMemoryQuota::BasicMemoryQuota(
-    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node)
-    : channelz::DataSource(channelz_node) {
+    RefCountedPtr<channelz::ResourceQuotaNode> channelz_node,
+    InstrumentStorageRefPtr<ResourceQuotaDomain> telemetry_storage)
+    : channelz::DataSource(channelz_node),
+      GaugeProvider(telemetry_storage),
+      telemetry_storage_(std::move(telemetry_storage)) {
+  ProviderConstructed();
   channelz::DataSource::SourceConstructed();
 }
 
+BasicMemoryQuota::~BasicMemoryQuota() {
+  ProviderDestructing();
+  channelz::DataSource::SourceDestructing();
+}
+
 void BasicMemoryQuota::Start() {
   auto self = shared_from_this();
 
@@ -518,7 +532,7 @@ void BasicMemoryQuota::Start() {
   reclaimer_activity_ =
       MakeActivity(std::move(reclamation_loop), ExecCtxWakeupScheduler(),
                    [](absl::Status status) {
-                     CHECK(status.code() == absl::StatusCode::kCancelled);
+                     GRPC_CHECK(status.code() == absl::StatusCode::kCancelled);
                    });
 }
 
@@ -538,7 +552,7 @@ void BasicMemoryQuota::SetSize(size_t new_size) {
 void BasicMemoryQuota::Take(GrpcMemoryAllocatorImpl* allocator, size_t amount) {
   // If there's a request for nothing, then do nothing!
   if (amount == 0) return;
-  DCHECK(amount <= std::numeric_limits<intptr_t>::max());
+  GRPC_DCHECK(amount <= std::numeric_limits<intptr_t>::max());
   // Grab memory from the quota.
   auto prior = free_bytes_.fetch_sub(amount, std::memory_order_acq_rel);
   // If we push into overcommit, awake the reclaimer.
@@ -698,12 +712,21 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   return pressure_info;
 }
 
+void BasicMemoryQuota::PopulateGaugeData(GaugeSink<ResourceQuotaDomain>& sink) {
+  auto pressure_info = GetPressureInfo();
+  sink.Set(ResourceQuotaDomain::kInstantaneousMemoryPressure,
+           pressure_info.instantaneous_pressure);
+  sink.Set(ResourceQuotaDomain::kMemoryPressureControlValue,
+           pressure_info.pressure_control_value);
+}
+
 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))
+          .Set("container_memory_pressure", ContainerMemoryPressure())
           .Merge(pressure_tracker_.ChannelzProperties())
           .Set("allocators",
                [this]() {
@@ -815,8 +838,6 @@ std::string PressureController::DebugString() const {
 }
 
 double PressureTracker::AddSampleAndGetControlValue(double sample) {
-  static const double kSetPoint = 0.95;
-
   double max_so_far = max_this_round_.load(std::memory_order_relaxed);
   if (sample > max_so_far) {
     max_this_round_.compare_exchange_weak(max_so_far, sample,
@@ -825,7 +846,7 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
   }
   // If memory pressure is almost done, immediately hit the brakes and report
   // full memory usage.
-  if (sample >= 0.99) {
+  if (sample >= memory_pressure_threshold_) {
     report_.store(1.0, std::memory_order_relaxed);
   }
   update_.Tick([&](Duration) {
@@ -833,11 +854,11 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
     const double current_estimate =
         max_this_round_.exchange(sample, std::memory_order_relaxed);
     double report;
-    if (current_estimate > 0.99) {
+    if (current_estimate > memory_pressure_threshold_) {
       // Under very high memory pressure we... just max things out.
       report = controller_.Update(1e99);
     } else {
-      report = controller_.Update(current_estimate - kSetPoint);
+      report = controller_.Update(current_estimate - target_memory_pressure_);
     }
     GRPC_TRACE_LOG(resource_quota, INFO)
         << "RQ: pressure:" << current_estimate << " report:" << report