grpc 1.49.1-x86_64-linux → 1.50.0.pre1-x86_64-linux

data/src/core/lib/load_balancing/lb_policy.h

@@ -353,11 +353,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
   /// Updates the policy with new data from the resolver.  Will be invoked
   /// immediately after LB policy is constructed, and then again whenever
-  /// the resolver returns a new result.
-  // TODO(roth): Change this to return some indication as to whether the
-  // update has been accepted, so that we can indicate to the resolver
-  // whether it should go into backoff to retry the resolution.
-  virtual void UpdateLocked(UpdateArgs) = 0;  // NOLINT
+  /// the resolver returns a new result.  The returned status indicates
+  /// whether the LB policy accepted the update; if non-OK, informs
+  /// polling-based resolvers that they should go into backoff delay and
+  /// eventually reattempt the resolution.
+  virtual absl::Status UpdateLocked(UpdateArgs) = 0;  // NOLINT
 
   /// Tries to enter a READY connectivity state.
   /// This is a no-op by default, since most LB policies never go into

data/src/core/lib/load_balancing/lb_policy_registry.cc

@@ -32,75 +32,53 @@
 
 #include <grpc/support/log.h>
 
-namespace grpc_core {
-
-namespace {
-
-class RegistryState {
- public:
-  void RegisterLoadBalancingPolicyFactory(
-      std::unique_ptr<LoadBalancingPolicyFactory> factory) {
-    gpr_log(GPR_DEBUG, "registering LB policy factory for \"%s\"",
-            std::string(factory->name()).c_str());
-    GPR_ASSERT(factories_.find(factory->name()) == factories_.end());
-    factories_.emplace(factory->name(), std::move(factory));
-  }
-
-  LoadBalancingPolicyFactory* GetLoadBalancingPolicyFactory(
-      absl::string_view name) const {
-    auto it = factories_.find(name);
-    if (it == factories_.end()) return nullptr;
-    return it->second.get();
-  }
-
- private:
-  std::map<absl::string_view, std::unique_ptr<LoadBalancingPolicyFactory>>
-      factories_;
-};
-
-RegistryState* g_state = nullptr;
+#include "src/core/lib/load_balancing/lb_policy.h"
 
-}  // namespace
+namespace grpc_core {
 
 //
 // LoadBalancingPolicyRegistry::Builder
 //
 
-void LoadBalancingPolicyRegistry::Builder::InitRegistry() {
-  if (g_state == nullptr) g_state = new RegistryState();
-}
-
-void LoadBalancingPolicyRegistry::Builder::ShutdownRegistry() {
-  delete g_state;
-  g_state = nullptr;
-}
-
 void LoadBalancingPolicyRegistry::Builder::RegisterLoadBalancingPolicyFactory(
     std::unique_ptr<LoadBalancingPolicyFactory> factory) {
-  InitRegistry();
-  g_state->RegisterLoadBalancingPolicyFactory(std::move(factory));
+  gpr_log(GPR_DEBUG, "registering LB policy factory for \"%s\"",
+          std::string(factory->name()).c_str());
+  GPR_ASSERT(factories_.find(factory->name()) == factories_.end());
+  factories_.emplace(factory->name(), std::move(factory));
+}
+
+LoadBalancingPolicyRegistry LoadBalancingPolicyRegistry::Builder::Build() {
+  LoadBalancingPolicyRegistry out;
+  out.factories_ = std::move(factories_);
+  return out;
 }
 
 //
 // LoadBalancingPolicyRegistry
 //
 
+LoadBalancingPolicyFactory*
+LoadBalancingPolicyRegistry::GetLoadBalancingPolicyFactory(
+    absl::string_view name) const {
+  auto it = factories_.find(name);
+  if (it == factories_.end()) return nullptr;
+  return it->second.get();
+}
+
 OrphanablePtr<LoadBalancingPolicy>
 LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-    absl::string_view name, LoadBalancingPolicy::Args args) {
-  GPR_ASSERT(g_state != nullptr);
+    absl::string_view name, LoadBalancingPolicy::Args args) const {
   // Find factory.
-  LoadBalancingPolicyFactory* factory =
-      g_state->GetLoadBalancingPolicyFactory(name);
+  LoadBalancingPolicyFactory* factory = GetLoadBalancingPolicyFactory(name);
   if (factory == nullptr) return nullptr;  // Specified name not found.
   // Create policy via factory.
   return factory->CreateLoadBalancingPolicy(std::move(args));
 }
 
 bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-    absl::string_view name, bool* requires_config) {
-  GPR_ASSERT(g_state != nullptr);
-  auto* factory = g_state->GetLoadBalancingPolicyFactory(name);
+    absl::string_view name, bool* requires_config) const {
+  auto* factory = GetLoadBalancingPolicyFactory(name);
   if (factory == nullptr) return false;
   // If requested, check if the load balancing policy allows an empty config.
   if (requires_config != nullptr) {
@@ -110,12 +88,11 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
   return true;
 }
 
-namespace {
-
 // Returns the JSON node of policy (with both policy name and config content)
 // given the JSON node of a LoadBalancingConfig array.
-absl::StatusOr<Json::Object::const_iterator> ParseLoadBalancingConfigHelper(
-    const Json& lb_config_array) {
+absl::StatusOr<Json::Object::const_iterator>
+LoadBalancingPolicyRegistry::ParseLoadBalancingConfigHelper(
+    const Json& lb_config_array) const {
   if (lb_config_array.type() != Json::Type::ARRAY) {
     return absl::InvalidArgumentError("type should be array");
   }
@@ -146,16 +123,13 @@ absl::StatusOr<Json::Object::const_iterator> ParseLoadBalancingConfigHelper(
       "No known policies in list: ", absl::StrJoin(policies_tried, " ")));
 }
 
-}  // namespace
-
 absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
-LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json) {
-  GPR_ASSERT(g_state != nullptr);
+LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json) const {
   auto policy = ParseLoadBalancingConfigHelper(json);
   if (!policy.ok()) return policy.status();
   // Find factory.
   LoadBalancingPolicyFactory* factory =
-      g_state->GetLoadBalancingPolicyFactory((*policy)->first.c_str());
+      GetLoadBalancingPolicyFactory((*policy)->first.c_str());
   if (factory == nullptr) {
     return absl::FailedPreconditionError(absl::StrFormat(
         "Factory not found for policy \"%s\"", (*policy)->first));

data/src/core/lib/load_balancing/lb_policy_registry.h

@@ -19,6 +19,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
 #include <memory>
 
 #include "absl/status/statusor.h"
@@ -39,30 +40,41 @@ class LoadBalancingPolicyRegistry {
   /// initialization and shutdown.
   class Builder {
    public:
-    /// Global initialization and shutdown hooks.
-    static void InitRegistry();
-    static void ShutdownRegistry();
-
     /// Registers an LB policy factory.  The factory will be used to create an
     /// LB policy whose name matches that of the factory.
-    static void RegisterLoadBalancingPolicyFactory(
+    void RegisterLoadBalancingPolicyFactory(
         std::unique_ptr<LoadBalancingPolicyFactory> factory);
+
+    LoadBalancingPolicyRegistry Build();
+
+   private:
+    std::map<absl::string_view, std::unique_ptr<LoadBalancingPolicyFactory>>
+        factories_;
   };
 
   /// Creates an LB policy of the type specified by \a name.
-  static OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      absl::string_view name, LoadBalancingPolicy::Args args);
+  OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
+      absl::string_view name, LoadBalancingPolicy::Args args) const;
 
   /// Returns true if the LB policy factory specified by \a name exists in this
   /// registry. If the load balancing policy requires a config to be specified
   /// then sets \a requires_config to true.
-  static bool LoadBalancingPolicyExists(absl::string_view name,
-                                        bool* requires_config);
+  bool LoadBalancingPolicyExists(absl::string_view name,
+                                 bool* requires_config) const;
 
   /// Returns a parsed object of the load balancing policy to be used from a
   /// LoadBalancingConfig array \a json.
-  static absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
-  ParseLoadBalancingConfig(const Json& json);
+  absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& json) const;
+
+ private:
+  LoadBalancingPolicyFactory* GetLoadBalancingPolicyFactory(
+      absl::string_view name) const;
+  absl::StatusOr<Json::Object::const_iterator> ParseLoadBalancingConfigHelper(
+      const Json& lb_config_array) const;
+
+  std::map<absl::string_view, std::unique_ptr<LoadBalancingPolicyFactory>>
+      factories_;
 };
 
 }  // namespace grpc_core

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

@@ -28,7 +28,6 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/support/log.h>
 
@@ -100,7 +99,7 @@ class Waker {
   friend class AtomicWaker;
 
   Wakeable* Take() {
-    return absl::exchange(wakeable_, activity_detail::unwakeable());
+    return std::exchange(wakeable_, activity_detail::unwakeable());
   }
 
   Wakeable* wakeable_;
@@ -315,7 +314,7 @@ class FreestandingActivity : public Activity, private Wakeable {
   // Check if we got an internal wakeup since the last time this function was
   // called.
   ActionDuringRun GotActionDuringRun() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    return absl::exchange(action_during_run_, ActionDuringRun::kNone);
+    return std::exchange(action_during_run_, ActionDuringRun::kNone);
   }
 
   // Implementors of Wakeable::Wakeup should call this after the wakeup has

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

@@ -77,7 +77,7 @@ T* GetContext() {
 // Given a promise and a context, return a promise that has that context set.
 template <typename T, typename F>
 promise_detail::WithContext<T, F> WithContext(F f, T* context) {
-  return promise_detail::WithContext<T, F>(f, context);
+  return promise_detail::WithContext<T, F>(std::move(f), context);
 }
 
 }  // namespace grpc_core

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

@@ -24,6 +24,7 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 
@@ -40,25 +41,26 @@ Poll<absl::Status> Sleep::operator()() {
   // TODO(ctiller): the following can be safely removed when we remove ExecCtx.
   ExecCtx::Get()->InvalidateNow();
   // If the deadline is earlier than now we can just return.
-  if (deadline_ <= ExecCtx::Get()->Now()) return absl::OkStatus();
+  if (deadline_ <= Timestamp::Now()) return absl::OkStatus();
   if (closure_ == nullptr) {
     // TODO(ctiller): it's likely we'll want a pool of closures - probably per
     // cpu? - to avoid allocating/deallocating on fast paths.
     closure_ = new ActiveClosure(deadline_);
   }
+  if (closure_->HasRun()) return absl::OkStatus();
   return Pending{};
 }
 
 Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
     : waker_(Activity::current()->MakeOwningWaker()),
       timer_handle_(GetDefaultEventEngine()->RunAfter(
-          deadline - ExecCtx::Get()->Now(), this)) {}
+          deadline - Timestamp::Now(), this)) {}
 
 void Sleep::ActiveClosure::Run() {
   ApplicationCallbackExecCtx callback_exec_ctx;
   ExecCtx exec_ctx;
   auto waker = std::move(waker_);
-  if (refs_.Unref()) {
+  if (Unref()) {
     delete this;
   } else {
     waker.Wakeup();
@@ -69,9 +71,19 @@ void Sleep::ActiveClosure::Cancel() {
   // If we cancel correctly then we must own both refs still and can simply
   // delete without unreffing twice, otherwise try unreffing since this may be
   // the last owned ref.
-  if (GetDefaultEventEngine()->Cancel(timer_handle_) || refs_.Unref()) {
+  if (GetDefaultEventEngine()->Cancel(timer_handle_) || Unref()) {
     delete this;
   }
 }
 
+bool Sleep::ActiveClosure::Unref() {
+  return (refs_.fetch_sub(1, std::memory_order_acq_rel) == 1);
+}
+
+bool Sleep::ActiveClosure::HasRun() const {
+  // If the closure has run (ie woken up the activity) then it will have
+  // decremented this ref count once.
+  return refs_.load(std::memory_order_acquire) == 1;
+}
+
 }  // namespace grpc_core

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

@@ -17,12 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <atomic>
+
 #include "absl/status/status.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
@@ -60,12 +61,17 @@ class Sleep final {
     explicit ActiveClosure(Timestamp deadline);
 
     void Run() override;
+    // After calling Cancel, it's no longer safe to access this object.
     void Cancel();
 
+    bool HasRun() const;
+
    private:
+    bool Unref();
+
     Waker waker_;
     // One ref dropped by Run(), the other by Cancel().
-    RefCount refs_{2};
+    std::atomic<int> refs_{2};
     const grpc_event_engine::experimental::EventEngine::TaskHandle
         timer_handle_;
   };

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

@@ -19,8 +19,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <functional>
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
 #include "src/core/lib/channel/channel_args.h"
@@ -67,6 +69,17 @@ class Resolver : public InternallyRefCounted<Resolver> {
     // TODO(roth): Before making this a public API, figure out a way to
     // avoid exposing channel args this way.
     ChannelArgs args;
+    // If non-null, this callback will be invoked when the LB policy has
+    // processed the result.  The status value passed to the callback
+    // indicates whether the LB policy accepted the update.  For polling
+    // resolvers, if the reported status is non-OK, then the resolver
+    // should put itself into backoff to retry the resolution later.
+    // The resolver impl must not call ResultHandler::ReportResult()
+    // again until after this callback has been invoked.
+    // The callback will be invoked within the channel's WorkSerializer.
+    // It may or may not be invoked before ResultHandler::ReportResult()
+    // returns, which is why it's a separate callback.
+    std::function<void(absl::Status)> result_health_callback;
   };
 
   /// A proxy object used by the resolver to return results to the
@@ -76,9 +89,6 @@ class Resolver : public InternallyRefCounted<Resolver> {
     virtual ~ResultHandler() {}
 
     /// Reports a result to the channel.
-    // TODO(roth): Add a mechanism for the resolver to get back a signal
-    // indicating if the result was accepted by the LB policy, so that it
-    // knows whether to go into backoff to retry to resolution.
     virtual void ReportResult(Result result) = 0;  // NOLINT
   };
 

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

@@ -44,6 +44,15 @@ ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
       ->Ref();
 }
 
+ResourceQuotaRefPtr ResourceQuotaFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config) {
+  void* value = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
+  if (value != nullptr) {
+    return reinterpret_cast<ResourceQuota*>(value)->Ref();
+  }
+  return nullptr;
+}
+
 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

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

@@ -19,6 +19,7 @@
 
 #include <stddef.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/config/core_configuration.h"
@@ -36,6 +37,11 @@ constexpr size_t kResourceQuotaChannelSize = 34 * 1024;
 // UB if not set.
 ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(const grpc_channel_args* args);
 
+// Retrieve the resource quota from the EndpointConfig.
+// Returns nullptr if not set.
+ResourceQuotaRefPtr ResourceQuotaFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config);
+
 void RegisterResourceQuota(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core

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

@@ -23,8 +23,6 @@
 #include <atomic>
 #include <new>
 
-#include "absl/utility/utility.h"
-
 #include <grpc/support/alloc.h>
 
 #include "src/core/lib/gpr/alloc.h"
@@ -81,7 +79,7 @@ size_t Arena::Destroy() {
          nullptr) {
     // Inner loop: destruct a batch of objects.
     while (p != nullptr) {
-      Destruct(absl::exchange(p, p->next));
+      Destruct(std::exchange(p, p->next));
     }
   }
   size_t size = total_used_.load(std::memory_order_relaxed);

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

@@ -24,11 +24,9 @@
 
 #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"
-#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,18 +35,6 @@
 #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.
@@ -191,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);
     }
   }
 }
@@ -262,10 +248,11 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
   size_t free = free_bytes_.load(std::memory_order_relaxed);
   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 (!IsUnconstrainedMaxQuotaBufferSizeEnabled() &&
+        free > kMaxQuotaBufferSize / 2) {
+      ret = std::max(ret, free - kMaxQuotaBufferSize / 2);
     }
-    if (periodic_donate_back()) {
+    if (IsPeriodicResourceQuotaReclamationEnabled()) {
       ret = std::max(ret, free > 8192 ? free / 2 : free);
     }
     const size_t new_free = free - ret;
@@ -463,8 +450,6 @@ void BasicMemoryQuota::Return(size_t amount) {
 }
 
 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();
@@ -472,7 +457,7 @@ BasicMemoryQuota::PressureInfo BasicMemoryQuota::GetPressureInfo() {
   if (size < 1) return PressureInfo{1, 1, 1};
   PressureInfo pressure_info;
   pressure_info.instantaneous_pressure = std::max(0.0, (size - free) / size);
-  if (kSmoothMemoryPressure) {
+  if (IsMemoryPressureControllerEnabled()) {
     pressure_info.pressure_control_value =
         pressure_tracker_.AddSampleAndGetControlValue(
             pressure_info.instantaneous_pressure);
@@ -492,7 +477,7 @@ namespace memory_quota_detail {
 
 double PressureController::Update(double error) {
   bool is_low = error < 0;
-  bool was_low = absl::exchange(last_was_low_, is_low);
+  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.
@@ -563,8 +548,7 @@ std::string PressureController::DebugString() const {
 }
 
 double PressureTracker::AddSampleAndGetControlValue(double sample) {
-  static const double kSetPoint =
-      GPR_GLOBAL_CONFIG_GET(grpc_experimental_resource_quota_set_point) / 100.0;
+  static const double kSetPoint = 95.0;
 
   double max_so_far = max_this_round_.load(std::memory_order_relaxed);
   if (sample > max_so_far) {

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

@@ -34,7 +34,7 @@
 #include <grpc/event_engine/memory_request.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/global_config_generic.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"
@@ -43,11 +43,6 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/periodic_update.h"
 
-GPR_GLOBAL_CONFIG_DECLARE_BOOL(grpc_experimental_smooth_memory_presure);
-GPR_GLOBAL_CONFIG_DECLARE_BOOL(
-    grpc_experimental_enable_periodic_resource_quota_reclamation);
-GPR_GLOBAL_CONFIG_DECLARE_INT32(grpc_experimental_max_quota_buffer_size);
-
 namespace grpc_core {
 
 class BasicMemoryQuota;
@@ -370,9 +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 ((max_quota_buffer_size() > 0 &&
-         prev_free + n > max_quota_buffer_size()) ||
-        (periodic_donate_back() && donate_back_.Tick([](Duration) {}))) {
+    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();
     }
@@ -400,16 +396,7 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   absl::string_view name() const { return name_; }
 
  private:
-  static bool periodic_donate_back() {
-    static const bool value = GPR_GLOBAL_CONFIG_GET(
-        grpc_experimental_enable_periodic_resource_quota_reclamation);
-    return value;
-  }
-  static size_t max_quota_buffer_size() {
-    static const size_t value =
-        GPR_GLOBAL_CONFIG_GET(grpc_experimental_max_quota_buffer_size);
-    return value;
-  }
+  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.

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

@@ -19,13 +19,12 @@
 #include <atomic>
 
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
 bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
   if (period_start_ == Timestamp::ProcessEpoch()) {
-    period_start_ = ExecCtx::Get()->Now();
+    period_start_ = Timestamp::Now();
     updates_remaining_.store(1, std::memory_order_release);
     return false;
   }
@@ -34,7 +33,7 @@ bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
   // 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 = ExecCtx::Get()->Now();
+  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.

data/src/core/{ext/xds → lib/security/certificate_provider}/certificate_provider_factory.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_XDS_CERTIFICATE_PROVIDER_FACTORY_H
-#define GRPC_CORE_EXT_XDS_CERTIFICATE_PROVIDER_FACTORY_H
+#ifndef GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_FACTORY_H
+#define GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -63,4 +63,4 @@ class CertificateProviderFactory {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_XDS_CERTIFICATE_PROVIDER_FACTORY_H
+#endif  // GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_CERTIFICATE_PROVIDER_FACTORY_H