grpc 1.43.1 → 1.53.0

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

@@ -12,30 +12,48 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
-#define GRPC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
+#ifndef GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
+#define GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
 
 #include <grpc/support/port_platform.h>
 
-#include <algorithm>
+#include <stdint.h>
+
+#include <array>
+#include <atomic>
 #include <cstddef>
 #include <limits>
 #include <memory>
-#include <queue>
-#include <vector>
+#include <string>
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/types/optional.h"
 
 #include <grpc/event_engine/memory_allocator.h>
-#include <grpc/slice.h>
+#include <grpc/event_engine/memory_request.h>
+#include <grpc/support/log.h>
 
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/periodic_update.h"
+#include "src/core/lib/resource_quota/trace.h"
 
 namespace grpc_core {
 
 class BasicMemoryQuota;
 class MemoryQuota;
+class GrpcMemoryAllocatorImpl;
 
 using grpc_event_engine::experimental::MemoryRequest;
 
@@ -52,26 +70,22 @@ using Vector = grpc_event_engine::experimental::Vector<T>;
 // reclaimers. We do this in multiple passes: if there is a less destructive
 // operation available, we do that, otherwise we do something more destructive.
 enum class ReclamationPass {
-  // Non-empty reclamation ought to take index 0, but to simplify API we don't
-  // expose that publicly (it's an internal detail), and hence index zero is
-  // here unnamed.
-
   // Benign reclamation is intended for reclamation steps that are not
   // observable outside of gRPC (besides maybe causing an increase in CPU
   // usage).
   // Examples of such reclamation would be resizing buffers to fit the current
   // load needs, rather than whatever was the peak usage requirement.
-  kBenign = 1,
+  kBenign = 0,
   // Idle reclamation is intended for reclamation steps that are observable
   // outside of gRPC, but do not cause application work to be lost.
   // Examples of such reclamation would be dropping channels that are not being
   // used.
-  kIdle = 2,
+  kIdle = 1,
   // Destructive reclamation is our last resort, and is these reclamations are
   // allowed to drop work - such as cancelling in flight requests.
-  kDestructive = 3,
+  kDestructive = 2,
 };
-static constexpr size_t kNumReclamationPasses = 4;
+static constexpr size_t kNumReclamationPasses = 3;
 
 // For each reclamation function run we construct a ReclamationSweep.
 // When this object is finally destroyed (it may be moved several times first),
@@ -80,8 +94,10 @@ class ReclamationSweep {
  public:
   ReclamationSweep() = default;
   ReclamationSweep(std::shared_ptr<BasicMemoryQuota> memory_quota,
-                   uint64_t sweep_token)
-      : memory_quota_(std::move(memory_quota)), sweep_token_(sweep_token) {}
+                   uint64_t sweep_token, Waker waker)
+      : memory_quota_(std::move(memory_quota)),
+        sweep_token_(sweep_token),
+        waker_(std::move(waker)) {}
   ~ReclamationSweep();
 
   ReclamationSweep(const ReclamationSweep&) = delete;
@@ -106,18 +122,72 @@ class ReclamationSweep {
  private:
   std::shared_ptr<BasicMemoryQuota> memory_quota_;
   uint64_t sweep_token_;
+  Waker waker_;
 };
 
-using ReclamationFunction =
-    std::function<void(absl::optional<ReclamationSweep>)>;
-
 class ReclaimerQueue {
+ private:
+  struct QueuedNode;
+  struct State;
+
  public:
-  using Index = size_t;
+  class Handle : public InternallyRefCounted<Handle> {
+   public:
+    Handle() = default;
+    template <typename F>
+    explicit Handle(F reclaimer, std::shared_ptr<State> state)
+        : sweep_(new SweepFn<F>(std::move(reclaimer), std::move(state))) {}
+    ~Handle() override {
+      GPR_DEBUG_ASSERT(sweep_.load(std::memory_order_relaxed) == nullptr);
+    }
+
+    Handle(const Handle&) = delete;
+    Handle& operator=(const Handle&) = delete;
+
+    void Orphan() final;
+    void Run(ReclamationSweep reclamation_sweep);
+    bool Requeue(ReclaimerQueue* new_queue);
+
+   private:
+    friend class ReclaimerQueue;
+    using InternallyRefCounted<Handle>::Ref;
+
+    class Sweep {
+     public:
+      virtual void RunAndDelete(absl::optional<ReclamationSweep> sweep) = 0;
+
+     protected:
+      explicit Sweep(std::shared_ptr<State> state) : state_(std::move(state)) {}
+      ~Sweep() = default;
+      void MarkCancelled();
+
+     private:
+      std::shared_ptr<State> state_;
+    };
+
+    template <typename F>
+    class SweepFn final : public Sweep {
+     public:
+      explicit SweepFn(F&& f, std::shared_ptr<State> state)
+          : Sweep(std::move(state)), f_(std::move(f)) {}
+      void RunAndDelete(absl::optional<ReclamationSweep> sweep) override {
+        if (!sweep.has_value()) MarkCancelled();
+        f_(std::move(sweep));
+        delete this;
+      }
+
+     private:
+      F f_;
+    };
+
+    std::atomic<Sweep*> sweep_{nullptr};
+  };
+
+  ReclaimerQueue();
+  ~ReclaimerQueue();
 
-  // An invalid index usable as an empty value.
-  // This value will not be returned from Insert ever.
-  static constexpr Index kInvalidIndex = std::numeric_limits<Index>::max();
+  ReclaimerQueue(const ReclaimerQueue&) = delete;
+  ReclaimerQueue& operator=(const ReclaimerQueue&) = delete;
 
   // Insert a new element at the back of the queue.
   // If there is already an element from allocator at *index, then it is
@@ -125,60 +195,108 @@ class ReclaimerQueue {
   // then *index is set to the index of the newly queued entry.
   // Associates the reclamation function with an allocator, and keeps that
   // allocator alive, so that we can use the pointer as an ABA guard.
-  void Insert(std::shared_ptr<EventEngineMemoryAllocatorImpl> allocator,
-              ReclamationFunction reclaimer, Index* index)
-      ABSL_LOCKS_EXCLUDED(mu_);
-  // Cancel a reclamation function - returns the function if cancelled
-  // successfully, or nullptr if the reclamation was already begun and could not
-  // be cancelled. allocator must be the same as was passed to Insert.
-  ReclamationFunction Cancel(Index index,
-                             EventEngineMemoryAllocatorImpl* allocator)
-      ABSL_LOCKS_EXCLUDED(mu_);
+  template <typename F>
+  GRPC_MUST_USE_RESULT OrphanablePtr<Handle> Insert(F reclaimer) {
+    auto p = MakeOrphanable<Handle>(std::move(reclaimer), state_);
+    Enqueue(p->Ref());
+    return p;
+  }
+
   // Poll to see if an entry is available: returns Pending if not, or the
   // removed reclamation function if so.
-  Poll<ReclamationFunction> PollNext() ABSL_LOCKS_EXCLUDED(mu_);
+  Poll<RefCountedPtr<Handle>> PollNext();
 
   // This callable is the promise backing Next - it resolves when there is an
   // entry available. This really just redirects to calling PollNext().
   class NextPromise {
    public:
     explicit NextPromise(ReclaimerQueue* queue) : queue_(queue) {}
-    Poll<ReclamationFunction> operator()() { return queue_->PollNext(); }
+    Poll<RefCountedPtr<Handle>> operator()() { return queue_->PollNext(); }
 
    private:
     // Borrowed ReclaimerQueue backing this promise.
     ReclaimerQueue* queue_;
   };
-  NextPromise Next() { return NextPromise(this); }
+  GRPC_MUST_USE_RESULT NextPromise Next() { return NextPromise(this); }
 
  private:
-  // One entry in the reclaimer queue
-  struct Entry {
-    Entry(std::shared_ptr<EventEngineMemoryAllocatorImpl> allocator,
-          ReclamationFunction reclaimer)
-        : allocator(std::move(allocator)), reclaimer(reclaimer) {}
-    // The allocator we'd be reclaiming for.
-    std::shared_ptr<EventEngineMemoryAllocatorImpl> allocator;
-    // The reclamation function to call.
-    ReclamationFunction reclaimer;
-  };
-  // Guarding mutex.
-  Mutex mu_;
-  // Entries in the queue (or empty entries waiting to be queued).
-  // We actually queue indices into this vector - and do this so that
-  // we can use the memory allocator pointer as an ABA protection.
-  std::vector<Entry> entries_ ABSL_GUARDED_BY(mu_);
-  // Which entries in entries_ are not allocated right now.
-  std::vector<size_t> free_entries_ ABSL_GUARDED_BY(mu_);
-  // Allocated entries waiting to be consumed.
-  std::queue<Index> queue_ ABSL_GUARDED_BY(mu_);
-  // Potentially one activity can be waiting for new entries on the queue.
-  Waker waker_ ABSL_GUARDED_BY(mu_);
+  void Enqueue(RefCountedPtr<Handle> handle);
+
+  std::shared_ptr<State> state_;
+};
+
+namespace memory_quota_detail {
+// Controller: tries to adjust a control variable up or down to get memory
+// pressure to some target. We use the control variable to size buffers
+// throughout the stack.
+class PressureController {
+ public:
+  PressureController(uint8_t max_ticks_same, uint8_t max_reduction_per_tick)
+      : max_ticks_same_(max_ticks_same),
+        max_reduction_per_tick_(max_reduction_per_tick) {}
+  // Update the controller, returns the new control value.
+  double Update(double error);
+  // Textual representation of the controller.
+  std::string DebugString() const;
+
+ 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.
+  uint8_t ticks_same_ = 0;
+  // Maximum number of ticks with the same value until we start expanding the
+  // control space.
+  const uint8_t max_ticks_same_;
+  // Maximum amount to reduce the reporting value per iteration (in tenths of a
+  // percentile).
+  const uint8_t max_reduction_per_tick_;
+  // Was the last error indicating a too low pressure (or if false,
+  // a too high pressure).
+  bool last_was_low_ = true;
+  // Current minimum value to report.
+  double min_ = 0.0;
+  // Current maximum value to report.
+  // Set so that the first change over will choose 1.0 for max.
+  double max_ = 2.0;
+  // Last control value reported.
+  double last_control_ = 0.0;
+};
+
+// Utility to track memory pressure.
+// Tries to be conservative (returns a higher pressure than there may actually
+// be) but to be eventually accurate.
+class PressureTracker {
+ public:
+  double AddSampleAndGetControlValue(double sample);
+
+ private:
+  std::atomic<double> max_this_round_{0.0};
+  std::atomic<double> report_{0.0};
+  PeriodicUpdate update_{Duration::Seconds(1)};
+  PressureController controller_{100, 3};
 };
+}  // namespace memory_quota_detail
+
+// Minimum number of free bytes in order for allocator to move to big bucket.
+static constexpr size_t kBigAllocatorThreshold = 0.5 * 1024 * 1024;
+// Maximum number of free bytes in order for allocator to move to small
+// bucket.
+static constexpr size_t kSmallAllocatorThreshold = 0.1 * 1024 * 1024;
 
 class BasicMemoryQuota final
     : public std::enable_shared_from_this<BasicMemoryQuota> {
  public:
+  // Data about current memory pressure.
+  struct PressureInfo {
+    // The current instantaneously measured memory pressure.
+    double instantaneous_pressure = 0.0;
+    // A control value that can be used to scale buffer sizes up or down to
+    // adjust memory pressure to our target set point.
+    double pressure_control_value = 0.0;
+    // Maximum recommended individual allocation size.
+    size_t max_recommended_allocation_size = 0;
+  };
+
   explicit BasicMemoryQuota(std::string name) : name_(std::move(name)) {}
 
   // Start the reclamation activity.
@@ -193,27 +311,22 @@ class BasicMemoryQuota final
   void SetSize(size_t new_size);
   // Forcefully take some memory from the quota, potentially entering
   // overcommit.
-  void Take(size_t amount);
+  void Take(GrpcMemoryAllocatorImpl* allocator, size_t amount);
   // Finish reclamation pass.
-  void FinishReclamation(uint64_t token);
+  void FinishReclamation(uint64_t token, Waker waker);
   // Return some memory to the quota.
   void Return(size_t amount);
+  // Add allocator to list of allocators in small bucket. Returns allocator id.
+  void AddNewAllocator(GrpcMemoryAllocatorImpl* allocator);
+  // Remove allocator from list of allocators.
+  void RemoveAllocator(GrpcMemoryAllocatorImpl* allocator);
+  // Determine whether to move allocator to different bucket and if so, move.
+  void MaybeMoveAllocator(GrpcMemoryAllocatorImpl* allocator,
+                          size_t old_free_bytes, size_t new_free_bytes);
   // Instantaneous memory pressure approximation.
-  std::pair<double, size_t>
-  InstantaneousPressureAndMaxRecommendedAllocationSize() const;
-  // Cancel a reclaimer
-  ReclamationFunction CancelReclaimer(
-      size_t reclaimer, typename ReclaimerQueue::Index index,
-      EventEngineMemoryAllocatorImpl* allocator) {
-    return reclaimers_[reclaimer].Cancel(index, allocator);
-  }
-  // Insert a reclaimer
-  void InsertReclaimer(
-      size_t reclaimer,
-      std::shared_ptr<EventEngineMemoryAllocatorImpl> allocator,
-      ReclamationFunction fn, ReclaimerQueue::Index* index) {
-    reclaimers_[reclaimer].Insert(std::move(allocator), std::move(fn), index);
-  }
+  PressureInfo GetPressureInfo();
+  // Get a reclamation queue
+  ReclaimerQueue* reclaimer_queue(size_t i) { return &reclaimers_[i]; }
 
   // The name of this quota
   absl::string_view name() const { return name_; }
@@ -222,8 +335,29 @@ class BasicMemoryQuota final
   friend class ReclamationSweep;
   class WaitForSweepPromise;
 
+  class AllocatorBucket {
+   public:
+    struct Shard {
+      absl::flat_hash_set<GrpcMemoryAllocatorImpl*> allocators
+          ABSL_GUARDED_BY(shard_mu);
+      absl::Mutex shard_mu;
+    };
+
+    Shard& SelectShard(void* key) {
+      const size_t hash = HashPointer(key, shards.size());
+      return shards[hash % shards.size()];
+    }
+
+    std::array<Shard, 16> shards;
+  };
+
   static constexpr intptr_t kInitialSize = std::numeric_limits<intptr_t>::max();
 
+  // Move allocator from big bucket to small bucket.
+  void MaybeMoveAllocatorBigToSmall(GrpcMemoryAllocatorImpl* allocator);
+  // Move allocator from small bucket to big bucket.
+  void MaybeMoveAllocatorSmallToBig(GrpcMemoryAllocatorImpl* allocator);
+
   // The amount of memory that's free in this quota.
   // We use intptr_t as a reasonable proxy for ssize_t that's portable.
   // We allow arbitrary overcommit and so this must allow negative values.
@@ -233,6 +367,10 @@ class BasicMemoryQuota final
 
   // Reclaimer queues.
   ReclaimerQueue reclaimers_[kNumReclamationPasses];
+  // List of all allocators sorted into 2 buckets, small (<100 KB free bytes)
+  // and large (>500 KB free bytes).
+  AllocatorBucket small_allocators_;
+  AllocatorBucket big_allocators_;
   // The reclaimer activity consumes reclaimers whenever we are in overcommit to
   // try and get back under memory limits.
   ActivityPtr reclaimer_activity_;
@@ -243,6 +381,8 @@ class BasicMemoryQuota final
   // We also increment this counter on completion of a sweep, as an indicator
   // that the wait has ended.
   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_;
 };
@@ -255,11 +395,6 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
       std::shared_ptr<BasicMemoryQuota> memory_quota, std::string name);
   ~GrpcMemoryAllocatorImpl() override;
 
-  // Rebind - Swaps the underlying quota for this allocator, taking care to
-  // make sure memory allocated is moved to allocations against the new quota.
-  void Rebind(std::shared_ptr<BasicMemoryQuota> memory_quota)
-      ABSL_LOCKS_EXCLUDED(memory_quota_mu_);
-
   // Reserve bytes from the quota.
   // If we enter overcommit, reclamation will begin concurrently.
   // Returns the number of bytes reserved.
@@ -270,59 +405,96 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
     // Add the released memory to our free bytes counter... if this increases
     // from  0 to non-zero, then we have more to do, otherwise, we're actually
     // done.
-    if (free_bytes_.fetch_add(n, std::memory_order_release) != 0) return;
-    MaybeRegisterReclaimer();
+    size_t prev_free = free_bytes_.fetch_add(n, std::memory_order_release);
+    if ((!IsUnconstrainedMaxQuotaBufferSizeEnabled() &&
+         prev_free + n > kMaxQuotaBufferSize) ||
+        donate_back_.Tick([](Duration) {})) {
+      // Try to immediately return some free'ed memory back to the total quota.
+      MaybeDonateBack();
+    }
+    size_t new_free = free_bytes_.load(std::memory_order_relaxed);
+    memory_quota_->MaybeMoveAllocator(this, prev_free, new_free);
+  }
+
+  // Return all free bytes to quota.
+  void ReturnFree() {
+    size_t ret = free_bytes_.exchange(0, std::memory_order_acq_rel);
+    if (ret == 0) return;
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+      gpr_log(GPR_INFO, "Allocator %p returning %zu bytes to quota", this, ret);
+    }
+    taken_bytes_.fetch_sub(ret, std::memory_order_relaxed);
+    memory_quota_->Return(ret);
+    memory_quota_->MaybeMoveAllocator(this, /*old_free_bytes=*/ret,
+                                      /*new_free_bytes=*/0);
   }
 
   // Post a reclamation function.
-  void PostReclaimer(ReclamationPass pass, ReclamationFunction fn);
+  template <typename F>
+  void PostReclaimer(ReclamationPass pass, F fn) {
+    MutexLock lock(&reclaimer_mu_);
+    GPR_ASSERT(!shutdown_);
+    InsertReclaimer(static_cast<size_t>(pass), std::move(fn));
+  }
 
   // Shutdown the allocator.
   void Shutdown() override;
 
   // Read the instantaneous memory pressure
-  double InstantaneousPressure() const {
-    MutexLock lock(&memory_quota_mu_);
-    return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
-        .first;
+  BasicMemoryQuota::PressureInfo GetPressureInfo() const {
+    return memory_quota_->GetPressureInfo();
   }
 
   // Name of this allocator
   absl::string_view name() const { return name_; }
 
+  size_t GetFreeBytes() const {
+    return free_bytes_.load(std::memory_order_relaxed);
+  }
+
+  size_t IncrementShardIndex() {
+    return chosen_shard_idx_.fetch_add(1, std::memory_order_relaxed);
+  }
+
  private:
+  static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
+
   // Primitive reservation function.
   absl::optional<size_t> TryReserve(MemoryRequest request) GRPC_MUST_USE_RESULT;
+  // This function may be invoked during a memory release operation.
+  // It will try to return half of our free pool to the quota.
+  void MaybeDonateBack();
   // Replenish bytes from the quota, without blocking, possibly entering
   // overcommit.
-  void Replenish() ABSL_LOCKS_EXCLUDED(memory_quota_mu_);
-  // If we have not already, register a reclamation function against the quota
-  // to sweep any free memory back to that quota.
-  void MaybeRegisterReclaimer() ABSL_LOCKS_EXCLUDED(memory_quota_mu_);
-  void MaybeRegisterReclaimerLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(memory_quota_mu_);
+  void Replenish();
+  template <typename F>
+  void InsertReclaimer(size_t pass, F fn)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(reclaimer_mu_) {
+    reclamation_handles_[pass] =
+        memory_quota_->reclaimer_queue(pass)->Insert(std::move(fn));
+  }
 
+  // Backing resource quota.
+  const std::shared_ptr<BasicMemoryQuota> memory_quota_;
   // Amount of memory this allocator has cached for its own use: to avoid quota
   // contention, each MemoryAllocator can keep some memory in addition to what
   // it is immediately using, and the quota can pull it back under memory
   // pressure.
   std::atomic<size_t> free_bytes_{0};
-  // Mutex guarding the backing resource quota.
-  mutable Mutex memory_quota_mu_;
-  // Backing resource quota.
-  std::shared_ptr<BasicMemoryQuota> memory_quota_
-      ABSL_GUARDED_BY(memory_quota_mu_);
   // Amount of memory taken from the quota by this allocator.
-  size_t taken_bytes_ ABSL_GUARDED_BY(memory_quota_mu_) =
-      sizeof(GrpcMemoryAllocatorImpl);
-  bool shutdown_ ABSL_GUARDED_BY(memory_quota_mu_) = false;
+  std::atomic<size_t> taken_bytes_{sizeof(GrpcMemoryAllocatorImpl)};
+  // Index used to randomly choose shard to return bytes from.
+  std::atomic<size_t> chosen_shard_idx_{0};
+  // We try to donate back some memory periodically to the central quota.
+  PeriodicUpdate donate_back_{Duration::Seconds(10)};
+  Mutex reclaimer_mu_;
+  bool shutdown_ ABSL_GUARDED_BY(reclaimer_mu_) = false;
   // Indices into the various reclaimer queues, used so that we can cancel
   // reclamation should we shutdown or get rebound.
-  ReclaimerQueue::Index
-      reclamation_indices_[kNumReclamationPasses] ABSL_GUARDED_BY(
-          memory_quota_mu_) = {
-          ReclaimerQueue::kInvalidIndex, ReclaimerQueue::kInvalidIndex,
-          ReclaimerQueue::kInvalidIndex, ReclaimerQueue::kInvalidIndex};
+  OrphanablePtr<ReclaimerQueue::Handle>
+      reclamation_handles_[kNumReclamationPasses] ABSL_GUARDED_BY(
+          reclaimer_mu_);
+
   // Name of this allocator.
   std::string name_;
 };
@@ -343,16 +515,15 @@ class MemoryOwner final : public MemoryAllocator {
       : MemoryAllocator(std::move(allocator)) {}
 
   // Post a reclaimer for some reclamation pass.
-  void PostReclaimer(ReclamationPass pass, ReclamationFunction fn) {
+  template <typename F>
+  void PostReclaimer(ReclamationPass pass, F fn) {
     impl()->PostReclaimer(pass, std::move(fn));
   }
 
-  // Rebind to a different quota.
-  void Rebind(MemoryQuota* quota);
-
   // Instantaneous memory pressure in the underlying quota.
-  double InstantaneousPressure() const {
-    return impl()->InstantaneousPressure();
+  BasicMemoryQuota::PressureInfo GetPressureInfo() const {
+    if (!is_valid()) return {};
+    return impl()->GetPressureInfo();
   }
 
   template <typename T, typename... Args>
@@ -399,11 +570,11 @@ class MemoryQuota final
   // Resize the quota to new_size.
   void SetSize(size_t new_size) { memory_quota_->SetSize(new_size); }
 
-  // Return true if the instantaneous memory pressure is high.
+  // Return true if the controlled memory pressure is high.
   bool IsMemoryPressureHigh() const {
-    static constexpr double kMemoryPressureHighThreshold = 0.9;
-    return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
-               .first > kMemoryPressureHighThreshold;
+    static constexpr double kMemoryPressureHighThreshold = 0.99;
+    return memory_quota_->GetPressureInfo().pressure_control_value >
+           kMemoryPressureHighThreshold;
   }
 
  private:
@@ -418,4 +589,4 @@ inline MemoryQuotaRefPtr MakeMemoryQuota(std::string name) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H
+#endif  // GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_MEMORY_QUOTA_H

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

@@ -0,0 +1,78 @@
+// Copyright 2022 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 <grpc/support/port_platform.h>
+
+#include "src/core/lib/resource_quota/periodic_update.h"
+
+#include <atomic>
+
+#include "src/core/lib/gpr/useful.h"
+
+namespace grpc_core {
+
+bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
+  if (period_start_ == Timestamp::ProcessEpoch()) {
+    period_start_ = Timestamp::Now();
+    updates_remaining_.store(1, std::memory_order_release);
+    return false;
+  }
+  // updates_remaining_ just reached 0 and the thread calling this function was
+  // 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_.
+  auto now = Timestamp::Now();
+  Duration time_so_far = now - period_start_;
+  if (time_so_far < period_) {
+    // At most double the number of updates remaining until the next period.
+    // At least try to estimate when we'll reach it.
+    int64_t better_guess;
+    if (time_so_far.millis() == 0) {
+      better_guess = expected_updates_per_period_ * 2;
+    } else {
+      // Determine a scaling factor that would have gotten us to the next
+      // period, but clamp between 1.01 (at least 1% increase in guesses)
+      // and 2.0 (at most doubling) - to avoid running completely out of
+      // control.
+      const double scale =
+          Clamp(period_.seconds() / time_so_far.seconds(), 1.01, 2.0);
+      better_guess = expected_updates_per_period_ * scale;
+      if (better_guess <= expected_updates_per_period_) {
+        better_guess = expected_updates_per_period_ + 1;
+      }
+    }
+    // Store the remainder left. Note that updates_remaining_ may have been
+    // decremented by another thread whilst we performed the above calculations:
+    // we simply discard those decrements.
+    updates_remaining_.store(better_guess - expected_updates_per_period_,
+                             std::memory_order_release);
+    // Not quite done, return, try for longer.
+    return false;
+  }
+  // Finished period, start a new one and return true.
+  // We try to predict how many update periods we'd need to cover the full time
+  // span, and we increase that by 1% to attempt to tend to not enter the above
+  // stanza.
+  expected_updates_per_period_ =
+      period_.seconds() * expected_updates_per_period_ / time_so_far.seconds();
+  if (expected_updates_per_period_ < 1) expected_updates_per_period_ = 1;
+  period_start_ = now;
+  f(time_so_far);
+  updates_remaining_.store(expected_updates_per_period_,
+                           std::memory_order_release);
+  return true;
+}
+
+}  // namespace grpc_core