grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -25,6 +24,7 @@
 #include "absl/status/statusor.h"
 
 #include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -116,6 +116,26 @@ using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
 template <typename... Fs>
 using TrySeq = BasicSeq<TrySeqTraits, Fs...>;
 
+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>;
+};
+
 }  // namespace promise_detail
 
 // Try a sequence of operations.
@@ -144,12 +164,12 @@ promise_detail::TrySeq<Functors...> TrySeq(Functors... functors) {
 //   }
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
-promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory, Argument,
-                             Iter>
+typename promise_detail::TrySeqIterResultTraits<Iter, Factory, Argument>::Result
 TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
-  return promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory,
-                                      Argument, Iter>(
-      begin, end, std::move(factory), std::move(argument));
+  using Result =
+      typename promise_detail::TrySeqIterResultTraits<Iter, Factory,
+                                                      Argument>::Result;
+  return Result(begin, end, std::move(factory), std::move(argument));
 }
 
 }  // namespace grpc_core

data/src/core/lib/resolver/resolver.cc

@@ -20,11 +20,6 @@
 
 #include "src/core/lib/resolver/resolver.h"
 
-#include <algorithm>
-#include <utility>
-
-#include "src/core/lib/channel/channel_args.h"
-
 grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
                                                            "resolver_refcount");
 
@@ -39,46 +34,4 @@ Resolver::Resolver()
                                ? "Resolver"
                                : nullptr) {}
 
-//
-// Resolver::Result
-//
-
-Resolver::Result::~Result() { grpc_channel_args_destroy(args); }
-
-Resolver::Result::Result(const Result& other)
-    : addresses(other.addresses),
-      service_config(other.service_config),
-      resolution_note(other.resolution_note),
-      args(grpc_channel_args_copy(other.args)) {}
-
-Resolver::Result::Result(Result&& other) noexcept
-    : addresses(std::move(other.addresses)),
-      service_config(std::move(other.service_config)),
-      resolution_note(std::move(other.resolution_note)),
-      // TODO(roth): Use std::move() once channel args is converted to C++.
-      args(other.args) {
-  other.args = nullptr;
-}
-
-Resolver::Result& Resolver::Result::operator=(const Result& other) {
-  if (&other == this) return *this;
-  addresses = other.addresses;
-  service_config = other.service_config;
-  resolution_note = other.resolution_note;
-  grpc_channel_args_destroy(args);
-  args = grpc_channel_args_copy(other.args);
-  return *this;
-}
-
-Resolver::Result& Resolver::Result::operator=(Result&& other) noexcept {
-  addresses = std::move(other.addresses);
-  service_config = std::move(other.service_config);
-  resolution_note = std::move(other.resolution_note);
-  // TODO(roth): Use std::move() once channel args is converted to C++.
-  grpc_channel_args_destroy(args);
-  args = other.args;
-  other.args = nullptr;
-  return *this;
-}
-
 }  // namespace grpc_core

data/src/core/lib/resolver/resolver.h

@@ -23,8 +23,7 @@
 
 #include "absl/status/statusor.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -67,16 +66,7 @@ class Resolver : public InternallyRefCounted<Resolver> {
     std::string resolution_note;
     // TODO(roth): Before making this a public API, figure out a way to
     // avoid exposing channel args this way.
-    const grpc_channel_args* args = nullptr;
-
-    // TODO(roth): Remove everything below once grpc_channel_args is
-    // converted to a copyable and movable C++ object.
-    Result() = default;
-    ~Result();
-    Result(const Result& other);
-    Result(Result&& other) noexcept;
-    Result& operator=(const Result& other);
-    Result& operator=(Result&& other) noexcept;
+    ChannelArgs args;
   };
 
   /// A proxy object used by the resolver to return results to the

data/src/core/lib/resolver/resolver_factory.h

@@ -25,8 +25,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resolver/resolver.h"
@@ -42,7 +41,7 @@ struct ResolverArgs {
   /// The parsed URI to resolve.
   URI uri;
   /// Channel args to be included in resolver results.
-  const grpc_channel_args* args = nullptr;
+  ChannelArgs args;
   /// Used to drive I/O in the name resolution process.
   grpc_pollset_set* pollset_set = nullptr;
   /// The work_serializer under which all resolver calls will be run.

data/src/core/lib/resolver/resolver_registry.cc

@@ -71,7 +71,7 @@ bool ResolverRegistry::IsValidTarget(absl::string_view target) const {
 }
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
-    absl::string_view target, const grpc_channel_args* args,
+    absl::string_view target, const ChannelArgs& args,
     grpc_pollset_set* pollset_set,
     std::shared_ptr<WorkSerializer> work_serializer,
     std::unique_ptr<Resolver::ResultHandler> result_handler) const {

data/src/core/lib/resolver/resolver_registry.h

@@ -26,8 +26,7 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resolver/resolver.h"
@@ -93,7 +92,7 @@ class ResolverRegistry {
   /// which all resolver calls will be run. \a result_handler is used to return
   /// results from the resolver.
   OrphanablePtr<Resolver> CreateResolver(
-      absl::string_view target, const grpc_channel_args* args,
+      absl::string_view target, const ChannelArgs& args,
       grpc_pollset_set* pollset_set,
       std::shared_ptr<WorkSerializer> work_serializer,
       std::unique_ptr<Resolver::ResultHandler> result_handler) const;

data/src/core/lib/resolver/server_address.cc

@@ -35,6 +35,7 @@
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 
 // IWYU pragma: no_include <sys/socket.h>
 
@@ -51,12 +52,12 @@ const char* ServerAddressWeightAttribute::kServerAddressWeightAttributeKey =
 //
 
 ServerAddress::ServerAddress(
-    const grpc_resolved_address& address, grpc_channel_args* args,
+    const grpc_resolved_address& address, const ChannelArgs& args,
     std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
     : address_(address), args_(args), attributes_(std::move(attributes)) {}
 
 ServerAddress::ServerAddress(
-    const void* address, size_t address_len, grpc_channel_args* args,
+    const void* address, size_t address_len, const ChannelArgs& args,
     std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
     : args_(args), attributes_(std::move(attributes)) {
   memcpy(address_.addr, address, address_len);
@@ -64,7 +65,7 @@ ServerAddress::ServerAddress(
 }
 
 ServerAddress::ServerAddress(const ServerAddress& other)
-    : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {
+    : address_(other.address_), args_(other.args_) {
   for (const auto& p : other.attributes_) {
     attributes_[p.first] = p.second->Copy();
   }
@@ -74,8 +75,7 @@ ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
     return *this;
   }
   address_ = other.address_;
-  grpc_channel_args_destroy(args_);
-  args_ = grpc_channel_args_copy(other.args_);
+  args_ = other.args_;
   attributes_.clear();
   for (const auto& p : other.attributes_) {
     attributes_[p.first] = p.second->Copy();
@@ -85,16 +85,12 @@ ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
 
 ServerAddress::ServerAddress(ServerAddress&& other) noexcept
     : address_(other.address_),
-      args_(other.args_),
-      attributes_(std::move(other.attributes_)) {
-  other.args_ = nullptr;
-}
+      args_(std::move(other.args_)),
+      attributes_(std::move(other.attributes_)) {}
 
 ServerAddress& ServerAddress::operator=(ServerAddress&& other) noexcept {
   address_ = other.address_;
-  grpc_channel_args_destroy(args_);
-  args_ = other.args_;
-  other.args_ = nullptr;
+  args_ = std::move(other.args_);
   attributes_ = std::move(other.attributes_);
   return *this;
 }
@@ -133,7 +129,7 @@ int ServerAddress::Cmp(const ServerAddress& other) const {
   if (address_.len < other.address_.len) return -1;
   int retval = memcmp(address_.addr, other.address_.addr, address_.len);
   if (retval != 0) return retval;
-  retval = grpc_channel_args_compare(args_, other.args_);
+  retval = QsortCompare(args_, other.args_);
   if (retval != 0) return retval;
   return CompareAttributes(attributes_, other.attributes_);
 }
@@ -163,8 +159,8 @@ std::string ServerAddress::ToString() const {
   std::vector<std::string> parts = {
       addr_str.ok() ? addr_str.value() : addr_str.status().ToString(),
   };
-  if (args_ != nullptr) {
-    parts.emplace_back(absl::StrCat("args=", grpc_channel_args_string(args_)));
+  if (args_ != ChannelArgs()) {
+    parts.emplace_back(absl::StrCat("args=", args_.ToString()));
   }
   if (!attributes_.empty()) {
     std::vector<std::string> attrs;

data/src/core/lib/resolver/server_address.h

@@ -31,8 +31,6 @@
 
 #include "absl/memory/memory.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -70,16 +68,14 @@ class ServerAddress {
   };
 
   // Takes ownership of args.
-  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args,
+  ServerAddress(const grpc_resolved_address& address, const ChannelArgs& args,
                 std::map<const char*, std::unique_ptr<AttributeInterface>>
                     attributes = {});
   ServerAddress(const void* address, size_t address_len,
-                grpc_channel_args* args,
+                const ChannelArgs& args,
                 std::map<const char*, std::unique_ptr<AttributeInterface>>
                     attributes = {});
 
-  ~ServerAddress() { grpc_channel_args_destroy(args_); }
-
   // Copyable.
   ServerAddress(const ServerAddress& other);
   ServerAddress& operator=(const ServerAddress& other);
@@ -93,7 +89,7 @@ class ServerAddress {
   int Cmp(const ServerAddress& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
-  const grpc_channel_args* args() const { return args_; }
+  const ChannelArgs& args() const { return args_; }
 
   const AttributeInterface* GetAttribute(const char* key) const;
 
@@ -109,7 +105,7 @@ class ServerAddress {
 
  private:
   grpc_resolved_address address_;
-  grpc_channel_args* args_;
+  ChannelArgs args_;
   std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 

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

@@ -44,7 +44,7 @@ ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
       ->Ref();
 }
 
-ChannelArgs EnsureResourceQuotaInChannelArgs(ChannelArgs args) {
+ChannelArgs EnsureResourceQuotaInChannelArgs(const ChannelArgs& args) {
   if (args.GetObject<ResourceQuota>() != nullptr) return args;
   // If there's no existing quota, add it to the default one - shared between
   // all channel args declared thusly. This prevents us from accidentally not

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

@@ -20,8 +20,11 @@
 
 #include "src/core/lib/resource_quota/arena.h"
 
+#include <atomic>
 #include <new>
 
+#include "absl/utility/utility.h"
+
 #include <grpc/support/alloc.h>
 
 #include "src/core/lib/gpr/alloc.h"
@@ -49,7 +52,7 @@ Arena::~Arena() {
   Zone* z = last_zone_;
   while (z) {
     Zone* prev_z = z->prev;
-    z->~Zone();
+    Destruct(z);
     gpr_free_aligned(z);
     z = prev_z;
   }
@@ -71,6 +74,16 @@ std::pair<Arena*, void*> Arena::CreateWithAlloc(
 }
 
 size_t Arena::Destroy() {
+  ManagedNewObject* p;
+  // Outer loop: clear the managed new object list.
+  // We do this repeatedly in case a destructor ends up allocating something.
+  while ((p = managed_new_head_.exchange(nullptr, std::memory_order_relaxed)) !=
+         nullptr) {
+    // Inner loop: destruct a batch of objects.
+    while (p != nullptr) {
+      Destruct(absl::exchange(p, p->next));
+    }
+  }
   size_t size = total_used_.load(std::memory_order_relaxed);
   memory_allocator_->Release(total_allocated_.load(std::memory_order_relaxed));
   this->~Arena();
@@ -98,4 +111,11 @@ void* Arena::AllocZone(size_t size) {
   return reinterpret_cast<char*>(z) + zone_base_size;
 }
 
+void Arena::ManagedNewObject::Link(std::atomic<ManagedNewObject*>* head) {
+  next = head->load(std::memory_order_relaxed);
+  while (!head->compare_exchange_weak(next, this, std::memory_order_acq_rel,
+                                      std::memory_order_relaxed)) {
+  }
+}
+
 }  // namespace grpc_core

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

@@ -31,12 +31,12 @@
 
 #include <atomic>
 #include <memory>
-#include <new>
 #include <utility>
 
 #include <grpc/event_engine/memory_allocator.h>
 
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
@@ -76,15 +76,36 @@ class Arena {
   template <typename T, typename... Args>
   T* New(Args&&... args) {
     T* t = static_cast<T*>(Alloc(sizeof(T)));
-    new (t) T(std::forward<Args>(args)...);
+    Construct(t, std::forward<Args>(args)...);
     return t;
   }
 
+  // Like New, but has the arena call p->~T() at arena destruction time.
+  template <typename T, typename... Args>
+  T* ManagedNew(Args&&... args) {
+    auto* p = New<ManagedNewImpl<T>>(std::forward<Args>(args)...);
+    p->Link(&managed_new_head_);
+    return &p->t;
+  }
+
  private:
   struct Zone {
     Zone* prev;
   };
 
+  struct ManagedNewObject {
+    ManagedNewObject* next = nullptr;
+    void Link(std::atomic<ManagedNewObject*>* head);
+    virtual ~ManagedNewObject() = default;
+  };
+
+  template <typename T>
+  struct ManagedNewImpl : public ManagedNewObject {
+    T t;
+    template <typename... Args>
+    explicit ManagedNewImpl(Args&&... args) : t(std::forward<Args>(args)...) {}
+  };
+
   // Initialize an arena.
   // Parameters:
   //   initial_size: The initial size of the whole arena in bytes. These bytes
@@ -118,6 +139,7 @@ class Arena {
   // and (2) the allocated memory. The arena itself maintains a pointer to the
   // last zone; the zone list is reverse-walked during arena destruction only.
   std::atomic<Zone*> last_zone_{nullptr};
+  std::atomic<ManagedNewObject*> managed_new_head_{nullptr};
   // The backing memory quota
   MemoryAllocator* const memory_allocator_;
 };

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

@@ -21,7 +21,6 @@
 #include <algorithm>
 #include <atomic>
 #include <tuple>
-#include <type_traits>
 
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -29,6 +28,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/global_config_env.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/promise/exec_ctx_wakeup_scheduler.h"
 #include "src/core/lib/promise/loop.h"
@@ -37,6 +37,18 @@
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/resource_quota/trace.h"
 
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_experimental_smooth_memory_presure, false,
+                              "smooth the value of memory pressure over time");
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(
+    grpc_experimental_enable_periodic_resource_quota_reclamation, false,
+    "Enable experimental feature to reclaim resource quota periodically");
+GPR_GLOBAL_CONFIG_DEFINE_INT32(
+    grpc_experimental_max_quota_buffer_size, 1024 * 1024,
+    "Maximum size for one memory allocators buffer size against a quota");
+GPR_GLOBAL_CONFIG_DEFINE_INT32(
+    grpc_experimental_resource_quota_set_point, 95,
+    "Ask the resource quota to target this percentage of total quota usage.");
+
 namespace grpc_core {
 
 // Maximum number of bytes an allocator will request from a quota in one step.
@@ -207,11 +219,10 @@ absl::optional<size_t> GrpcMemoryAllocatorImpl::TryReserve(
   // Scale the request down according to memory pressure if we have that
   // flexibility.
   if (scaled_size_over_min != 0) {
-    const auto pressure_and_max_recommended_allocation_size =
-        memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize();
-    double pressure = pressure_and_max_recommended_allocation_size.first;
+    const auto pressure_info = memory_quota_->GetPressureInfo();
+    double pressure = pressure_info.pressure_control_value;
     size_t max_recommended_allocation_size =
-        pressure_and_max_recommended_allocation_size.second;
+        pressure_info.max_recommended_allocation_size;
     // Reduce allocation size proportional to the pressure > 80% usage.
     if (pressure > 0.8) {
       scaled_size_over_min =
@@ -249,11 +260,16 @@ absl::optional<size_t> GrpcMemoryAllocatorImpl::TryReserve(
 
 void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
   size_t free = free_bytes_.load(std::memory_order_relaxed);
-  const size_t kReduceToSize = kMaxQuotaBufferSize / 2;
-  while (true) {
-    if (free <= kReduceToSize) return;
-    size_t ret = free - kReduceToSize;
-    if (free_bytes_.compare_exchange_weak(free, kReduceToSize,
+  while (free > 0) {
+    size_t ret = 0;
+    if (max_quota_buffer_size() > 0 && free > max_quota_buffer_size() / 2) {
+      ret = std::max(ret, free - max_quota_buffer_size() / 2);
+    }
+    if (periodic_donate_back()) {
+      ret = std::max(ret, free > 8192 ? free / 2 : free);
+    }
+    const size_t new_free = free - ret;
+    if (free_bytes_.compare_exchange_weak(free, new_free,
                                           std::memory_order_acq_rel,
                                           std::memory_order_acquire)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
@@ -446,19 +462,143 @@ void BasicMemoryQuota::Return(size_t amount) {
   free_bytes_.fetch_add(amount, std::memory_order_relaxed);
 }
 
-std::pair<double, size_t>
-BasicMemoryQuota::InstantaneousPressureAndMaxRecommendedAllocationSize() const {
+BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
+  static const bool kSmoothMemoryPressure =
+      GPR_GLOBAL_CONFIG_GET(grpc_experimental_smooth_memory_presure);
   double free = free_bytes_.load();
   if (free < 0) free = 0;
   size_t quota_size = quota_size_.load();
   double size = quota_size;
-  if (size < 1) return std::make_pair(1.0, 1);
-  double pressure = (size - free) / size;
-  if (pressure < 0.0) pressure = 0.0;
-  if (pressure > 1.0) pressure = 1.0;
-  return std::make_pair(pressure, quota_size / 16);
+  if (size < 1) return PressureInfo{1, 1, 1};
+  PressureInfo pressure_info;
+  pressure_info.instantaneous_pressure = std::max(0.0, (size - free) / size);
+  if (kSmoothMemoryPressure) {
+    pressure_info.pressure_control_value =
+        pressure_tracker_.AddSampleAndGetControlValue(
+            pressure_info.instantaneous_pressure);
+  } else {
+    pressure_info.pressure_control_value =
+        std::min(pressure_info.instantaneous_pressure, 1.0);
+  }
+  pressure_info.max_recommended_allocation_size = quota_size / 16;
+  return pressure_info;
+}
+
+//
+// PressureTracker
+//
+
+namespace memory_quota_detail {
+
+double PressureController::Update(double error) {
+  bool is_low = error < 0;
+  bool was_low = absl::exchange(last_was_low_, is_low);
+  double new_control;  // leave unset to compiler can note bad branches
+  if (is_low && was_low) {
+    // Memory pressure is too low this round, and was last round too.
+    // If we have reached the min reporting value last time, then we will report
+    // the same value again this time and can start to increase the ticks_same_
+    // counter.
+    if (last_control_ == min_) {
+      ticks_same_++;
+      if (ticks_same_ >= max_ticks_same_) {
+        // If it's been the same for too long, reduce the min reported value
+        // down towards zero.
+        min_ /= 2.0;
+        ticks_same_ = 0;
+      }
+    }
+    // Target the min reporting value.
+    new_control = min_;
+  } else if (!is_low && !was_low) {
+    // Memory pressure is high, and was high previously.
+    ticks_same_++;
+    if (ticks_same_ >= max_ticks_same_) {
+      // It's been high for too long, increase the max reporting value up
+      // towards 1.0.
+      max_ = (1.0 + max_) / 2.0;
+      ticks_same_ = 0;
+    }
+    // Target the max reporting value.
+    new_control = max_;
+  } else if (is_low) {
+    // Memory pressure is low, but was high last round.
+    // Target the min reporting value, but first update it to be closer to the
+    // current max (that we've been reporting lately).
+    // In this way the min will gradually climb towards the max as we find a
+    // stable point.
+    // If this is too high, then we'll eventually move it back towards zero.
+    ticks_same_ = 0;
+    min_ = (min_ + max_) / 2.0;
+    new_control = min_;
+  } else {
+    // Memory pressure is high, but was low last round.
+    // Target the max reporting value, but first update it to be closer to the
+    // last reported value.
+    // 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
+    // 1.0 after max_ticks_same_ ticks.
+    ticks_same_ = 0;
+    max_ = (last_control_ + max_) / 2.0;
+    new_control = max_;
+  }
+  // If the control value is decreasing we do it slowly. This avoids rapid
+  // oscillations.
+  // (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);
+  }
+  last_control_ = new_control;
+  return new_control;
+}
+
+std::string PressureController::DebugString() const {
+  return absl::StrCat(last_was_low_ ? "low" : "high", " min=", min_,
+                      " max=", max_, " ticks=", ticks_same_,
+                      " last_control=", last_control_);
 }
 
+double PressureTracker::AddSampleAndGetControlValue(double sample) {
+  static const double kSetPoint =
+      GPR_GLOBAL_CONFIG_GET(grpc_experimental_resource_quota_set_point) / 100.0;
+
+  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,
+                                          std::memory_order_relaxed,
+                                          std::memory_order_relaxed);
+  }
+  // If memory pressure is almost done, immediately hit the brakes and report
+  // full memory usage.
+  if (sample >= 0.99) {
+    report_.store(1.0, std::memory_order_relaxed);
+  }
+  update_.Tick([&](Duration) {
+    // Reset the round tracker with the new sample.
+    const double current_estimate =
+        max_this_round_.exchange(sample, std::memory_order_relaxed);
+    double report;
+    if (current_estimate > 0.99) {
+      // Under very high memory pressure we... just max things out.
+      report = controller_.Update(1e99);
+    } else {
+      report = controller_.Update(current_estimate - kSetPoint);
+    }
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
+      gpr_log(GPR_INFO, "RQ: pressure:%lf report:%lf controller:%s",
+              current_estimate, report, controller_.DebugString().c_str());
+    }
+    report_.store(report, std::memory_order_relaxed);
+  });
+  return report_.load(std::memory_order_relaxed);
+}
+
+}  // namespace memory_quota_detail
+
 //
 // MemoryQuota
 //