grpc 1.48.0 → 1.50.0

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

@@ -20,6 +20,7 @@
 
 #include "src/core/lib/resource_quota/arena.h"
 
+#include <atomic>
 #include <new>
 
 #include <grpc/support/alloc.h>
@@ -49,7 +50,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 +72,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(std::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 +109,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,11 +21,9 @@
 #include <algorithm>
 #include <atomic>
 #include <tuple>
-#include <type_traits>
 
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/utility/utility.h"
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
@@ -179,7 +177,7 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
     shutdown_ = true;
     memory_quota = memory_quota_;
     for (size_t i = 0; i < kNumReclamationPasses; i++) {
-      reclamation_handles[i] = absl::exchange(reclamation_handles_[i], nullptr);
+      reclamation_handles[i] = std::exchange(reclamation_handles_[i], nullptr);
     }
   }
 }
@@ -207,11 +205,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 +246,17 @@ 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 (!IsUnconstrainedMaxQuotaBufferSizeEnabled() &&
+        free > kMaxQuotaBufferSize / 2) {
+      ret = std::max(ret, free - kMaxQuotaBufferSize / 2);
+    }
+    if (IsPeriodicResourceQuotaReclamationEnabled()) {
+      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 +449,140 @@ 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() {
   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 (IsMemoryPressureControllerEnabled()) {
+    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 = std::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 = 95.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
 //

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

@@ -34,11 +34,14 @@
 #include <grpc/event_engine/memory_request.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/experiments/experiments.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"
 
 namespace grpc_core {
 
@@ -80,7 +83,6 @@ enum class ReclamationPass {
   kDestructive = 3,
 };
 static constexpr size_t kNumReclamationPasses = 4;
-static constexpr size_t kMaxQuotaBufferSize = 1024 * 1024;
 
 // For each reclamation function run we construct a ReclamationSweep.
 // When this object is finally destroyed (it may be moved several times first),
@@ -220,9 +222,72 @@ class ReclaimerQueue {
   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
+
 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;
+    // 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;
+    // Maximum recommended individual allocation size.
+    size_t max_recommended_allocation_size;
+  };
+
   explicit BasicMemoryQuota(std::string name) : name_(std::move(name)) {}
 
   // Start the reclamation activity.
@@ -243,8 +308,7 @@ class BasicMemoryQuota final
   // Return some memory to the quota.
   void Return(size_t amount);
   // Instantaneous memory pressure approximation.
-  std::pair<double, size_t>
-  InstantaneousPressureAndMaxRecommendedAllocationSize() const;
+  PressureInfo GetPressureInfo();
   // Get a reclamation queue
   ReclaimerQueue* reclaimer_queue(size_t i) { return &reclaimers_[i]; }
 
@@ -276,6 +340,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_;
 };
@@ -299,7 +365,10 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
     // from  0 to non-zero, then we have more to do, otherwise, we're actually
     // done.
     size_t prev_free = free_bytes_.fetch_add(n, std::memory_order_release);
-    if (prev_free + n > kMaxQuotaBufferSize) {
+    if ((!IsUnconstrainedMaxQuotaBufferSizeEnabled() &&
+         prev_free + n > kMaxQuotaBufferSize) ||
+        (IsPeriodicResourceQuotaReclamationEnabled() &&
+         donate_back_.Tick([](Duration) {}))) {
       // Try to immediately return some free'ed memory back to the total quota.
       MaybeDonateBack();
     }
@@ -319,22 +388,19 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   void Shutdown() override;
 
   // Read the instantaneous memory pressure
-  double InstantaneousPressure() const {
-    return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
-        .first;
+  BasicMemoryQuota::PressureInfo GetPressureInfo() const {
+    return memory_quota_->GetPressureInfo();
   }
 
   // Name of this allocator
   absl::string_view name() const { return name_; }
 
  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. If the
-  // total free_bytes in this allocator/local cache exceeds
-  // kMaxQuotaBufferSize / 2, donate the excess free_bytes in this cache back
-  // to the total quota immediately. This helps prevent free bytes in any
-  // particular allocator from growing too large.
+  // 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.
@@ -359,6 +425,8 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   // Amount of memory taken from the quota by this allocator.
   std::atomic<size_t> taken_bytes_{sizeof(GrpcMemoryAllocatorImpl)};
   std::atomic<bool> registered_reclaimer_{false};
+  // 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
@@ -392,8 +460,8 @@ class MemoryOwner final : public MemoryAllocator {
   }
 
   // Instantaneous memory pressure in the underlying quota.
-  double InstantaneousPressure() const {
-    return impl()->InstantaneousPressure();
+  BasicMemoryQuota::PressureInfo GetPressureInfo() const {
+    return impl()->GetPressureInfo();
   }
 
   template <typename T, typename... Args>
@@ -442,9 +510,9 @@ class MemoryQuota final
 
   // Return true if the instantaneous memory pressure is high.
   bool IsMemoryPressureHigh() const {
-    static constexpr double kMemoryPressureHighThreshold = 0.9;
-    return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
-               .first > kMemoryPressureHighThreshold;
+    static constexpr double kMemoryPressureHighThreshold = 1.0;
+    return memory_quota_->GetPressureInfo().instantaneous_pressure >
+           kMemoryPressureHighThreshold;
   }
 
  private:

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

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

@@ -0,0 +1,71 @@
+// 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.
+
+#ifndef GRPC_CORE_LIB_RESOURCE_QUOTA_PERIODIC_UPDATE_H
+#define GRPC_CORE_LIB_RESOURCE_QUOTA_PERIODIC_UPDATE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <inttypes.h>
+
+#include <atomic>
+
+#include "absl/functional/function_ref.h"
+
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_core {
+
+// Lightweight timer-like mechanism for periodic updates.
+// Fast path only decrements an atomic int64.
+// Slow path runs corrections and estimates how many ticks are required to hit
+// the target period.
+// This is super inaccurate of course, but for places where we can't run timers,
+// or places where continuous registration/unregistration would cause problems
+// it can be quite useful.
+class PeriodicUpdate {
+ public:
+  explicit PeriodicUpdate(Duration period) : period_(period) {}
+
+  // Tick the update, call f and return true if we think the period expired.
+  bool Tick(absl::FunctionRef<void(Duration)> f) {
+    // Atomically decrement the remaining ticks counter.
+    // If we hit 0 our estimate of period length has expired.
+    // See the comment next to the data members for a description of thread
+    // safety.
+    if (updates_remaining_.fetch_sub(1, std::memory_order_acquire) == 1) {
+      return MaybeEndPeriod(f);
+    }
+    return false;
+  }
+
+ private:
+  bool MaybeEndPeriod(absl::FunctionRef<void(Duration)> f);
+
+  // Thread safety:
+  // When updates_remaining_ reaches 0 the thread that decremented becomes
+  // responsible for updating any mutable variables and then setting
+  // updates_remaining_ to a value greater than zero.
+  // Whilst in this state other threads *may* decrement updates_remaining_, but
+  // this is fine because they'll observe an ignorable negative value.
+
+  std::atomic<int64_t> updates_remaining_{1};
+  const Duration period_;
+  Timestamp period_start_ = Timestamp::ProcessEpoch();
+  int64_t expected_updates_per_period_ = 1;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_RESOURCE_QUOTA_PERIODIC_UPDATE_H