grpc 1.47.0 → 1.48.0.pre1

data/src/core/lib/iomgr/work_serializer.h

@@ -16,6 +16,8 @@
  *
  */
 
+#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
+#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
@@ -30,9 +32,6 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-
 namespace grpc_core {
 
 // WorkSerializer is a mechanism to schedule callbacks in a synchronized manner.

data/src/core/lib/matchers/matchers.cc

@@ -16,11 +16,14 @@
 
 #include "src/core/lib/matchers/matchers.h"
 
+#include <utility>
+
 #include "absl/memory/memory.h"
-#include "absl/strings/str_cat.h"
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/str_split.h"
 
 namespace grpc_core {
 

data/src/core/lib/matchers/matchers.h

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <memory>
 #include <string>
 

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

@@ -26,7 +26,6 @@ namespace grpc_core {
 // GLOBALS
 
 GPR_THREAD_LOCAL(Activity*) Activity::g_current_activity_{nullptr};
-Waker::Unwakeable Waker::unwakeable_;
 
 namespace promise_detail {
 

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

@@ -61,13 +61,13 @@ class Wakeable {
 class Waker {
  public:
   explicit Waker(Wakeable* wakeable) : wakeable_(wakeable) {}
-  Waker() : wakeable_(&unwakeable_) {}
-  ~Waker() { wakeable_->Drop(); }
+  Waker() : Waker(nullptr) {}
+  ~Waker() {
+    if (wakeable_ != nullptr) wakeable_->Drop();
+  }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
-  Waker(Waker&& other) noexcept : wakeable_(other.wakeable_) {
-    other.wakeable_ = &unwakeable_;
-  }
+  Waker(Waker&& other) noexcept : wakeable_(other.Take()) {}
   Waker& operator=(Waker&& other) noexcept {
     std::swap(wakeable_, other.wakeable_);
     return *this;
@@ -75,8 +75,7 @@ class Waker {
 
   // Wake the underlying activity.
   void Wakeup() {
-    wakeable_->Wakeup();
-    wakeable_ = &unwakeable_;
+    if (auto* wakeable = Take()) wakeable->Wakeup();
   }
 
   template <typename H>
@@ -89,14 +88,9 @@ class Waker {
   }
 
  private:
-  class Unwakeable final : public Wakeable {
-   public:
-    void Wakeup() final {}
-    void Drop() final {}
-  };
+  Wakeable* Take() { return absl::exchange(wakeable_, nullptr); }
 
   Wakeable* wakeable_;
-  static Unwakeable unwakeable_;
 };
 
 // An Activity tracks execution of a single promise.

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

@@ -19,6 +19,7 @@
 
 #include <new>
 #include <type_traits>
+#include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"

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

@@ -19,6 +19,7 @@
 
 #include <functional>
 #include <type_traits>
+#include <utility>
 
 #include "absl/status/status.h"
 #include "absl/types/optional.h"

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

@@ -16,60 +16,65 @@
 
 #include "src/core/lib/promise/sleep.h"
 
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/event_engine_factory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
-Sleep::Sleep(Timestamp deadline) : state_(new State(deadline)) {
-  GRPC_CLOSURE_INIT(&state_->on_timer, &OnTimer, state_, nullptr);
-}
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
+
+Sleep::Sleep(Timestamp deadline) : deadline_(deadline) {}
 
 Sleep::~Sleep() {
-  if (state_ == nullptr) return;
-  {
-    MutexLock lock(&state_->mu);
-    switch (state_->stage) {
-      case Stage::kInitial:
-        state_->Unref();
-        break;
-      case Stage::kStarted:
-        grpc_timer_cancel(&state_->timer);
-        break;
-      case Stage::kDone:
-        break;
-    }
+  if (deadline_ == Timestamp::InfPast()) return;
+  ReleasableMutexLock lock(&mu_);
+  switch (stage_) {
+    case Stage::kInitial:
+      break;
+    case Stage::kStarted:
+      if (GetDefaultEventEngine()->Cancel(timer_handle_)) {
+        lock.Release();
+        OnTimer();
+      }
+      break;
+    case Stage::kDone:
+      break;
   }
-  state_->Unref();
 }
 
-void Sleep::OnTimer(void* arg, grpc_error_handle) {
-  auto* state = static_cast<State*>(arg);
-  Waker waker;
+void Sleep::OnTimer() {
+  Waker tmp_waker;
   {
-    MutexLock lock(&state->mu);
-    state->stage = Stage::kDone;
-    waker = std::move(state->waker);
+    MutexLock lock(&mu_);
+    stage_ = Stage::kDone;
+    tmp_waker = std::move(waker_);
   }
-  waker.Wakeup();
-  state->Unref();
+  tmp_waker.Wakeup();
 }
 
 Poll<absl::Status> Sleep::operator()() {
-  MutexLock lock(&state_->mu);
-  switch (state_->stage) {
+  MutexLock lock(&mu_);
+  switch (stage_) {
     case Stage::kInitial:
-      if (state_->deadline <= ExecCtx::Get()->Now()) {
+      if (deadline_ <= ExecCtx::Get()->Now()) {
         return absl::OkStatus();
       }
-      state_->stage = Stage::kStarted;
-      grpc_timer_init(&state_->timer, state_->deadline, &state_->on_timer);
+      stage_ = Stage::kStarted;
+      timer_handle_ = GetDefaultEventEngine()->RunAfter(
+          deadline_ - ExecCtx::Get()->Now(), [this] {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            OnTimer();
+          });
       break;
     case Stage::kStarted:
       break;
     case Stage::kDone:
       return absl::OkStatus();
   }
-  state_->waker = Activity::current()->MakeNonOwningWaker();
+  waker_ = Activity::current()->MakeNonOwningWaker();
   return Pending{};
 }
 

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

@@ -22,12 +22,10 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 
-#include "src/core/lib/gprpp/ref_counted.h"
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -41,34 +39,36 @@ class Sleep {
 
   Sleep(const Sleep&) = delete;
   Sleep& operator=(const Sleep&) = delete;
-  Sleep(Sleep&& other) noexcept : state_(other.state_) {
-    other.state_ = nullptr;
-  }
+  Sleep(Sleep&& other) noexcept
+      : deadline_(other.deadline_), timer_handle_(other.timer_handle_) {
+    MutexLock lock2(&other.mu_);
+    stage_ = other.stage_;
+    waker_ = std::move(other.waker_);
+    other.deadline_ = Timestamp::InfPast();
+  };
   Sleep& operator=(Sleep&& other) noexcept {
-    std::swap(state_, other.state_);
+    if (&other == this) return *this;
+    MutexLock lock1(&mu_);
+    MutexLock lock2(&other.mu_);
+    deadline_ = other.deadline_;
+    timer_handle_ = other.timer_handle_;
+    stage_ = other.stage_;
+    waker_ = std::move(other.waker_);
+    other.deadline_ = Timestamp::InfPast();
     return *this;
-  }
+  };
 
   Poll<absl::Status> operator()();
 
  private:
-  static void OnTimer(void* arg, grpc_error_handle error);
-
   enum class Stage { kInitial, kStarted, kDone };
-  struct State {
-    explicit State(Timestamp deadline) : deadline(deadline) {}
-    RefCount refs{2};
-    const Timestamp deadline;
-    grpc_timer timer;
-    grpc_closure on_timer;
-    Mutex mu;
-    Stage stage ABSL_GUARDED_BY(mu) = Stage::kInitial;
-    Waker waker ABSL_GUARDED_BY(mu);
-    void Unref() {
-      if (refs.Unref()) delete this;
-    }
-  };
-  State* state_;
+  void OnTimer();
+
+  Timestamp deadline_;
+  grpc_event_engine::experimental::EventEngine::TaskHandle timer_handle_;
+  Mutex mu_;
+  Stage stage_ ABSL_GUARDED_BY(mu_) = Stage::kInitial;
+  Waker waker_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace grpc_core

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

@@ -20,6 +20,11 @@
 
 #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");
 

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

@@ -19,10 +19,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "absl/status/statusor.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/resolver/server_address.h"

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

@@ -19,11 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/string_util.h>
+#include <grpc/impl/codegen/grpc_types.h>
 
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resolver/resolver.h"

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

@@ -18,19 +18,12 @@
 
 #include "src/core/lib/resolver/resolver_registry.h"
 
-#include <string.h>
-
-#include <vector>
-
-#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/resolver/resolver_registry.h"
 
 namespace grpc_core {
 

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

@@ -19,9 +19,20 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/memory.h"
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 

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

@@ -20,16 +20,24 @@
 
 #include "src/core/lib/resolver/server_address.h"
 
+#include <string.h>
+
+#include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 
+// IWYU pragma: no_include <sys/socket.h>
+
 namespace grpc_core {
 
 //

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

@@ -21,10 +21,17 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/memory/memory.h"
 
-#include "absl/container/inlined_vector.h"
+#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
@@ -110,7 +117,7 @@ class ServerAddress {
 // ServerAddressList
 //
 
-typedef absl::InlinedVector<ServerAddress, 1> ServerAddressList;
+using ServerAddressList = std::vector<ServerAddress>;
 
 //
 // ServerAddressWeightAttribute

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

@@ -165,7 +165,7 @@ GrpcMemoryAllocatorImpl::GrpcMemoryAllocatorImpl(
 GrpcMemoryAllocatorImpl::~GrpcMemoryAllocatorImpl() {
   GPR_ASSERT(free_bytes_.load(std::memory_order_acquire) +
                  sizeof(GrpcMemoryAllocatorImpl) ==
-             taken_bytes_);
+             taken_bytes_.load(std::memory_order_relaxed));
   memory_quota_->Return(taken_bytes_);
 }
 
@@ -174,7 +174,7 @@ void GrpcMemoryAllocatorImpl::Shutdown() {
   OrphanablePtr<ReclaimerQueue::Handle>
       reclamation_handles[kNumReclamationPasses];
   {
-    MutexLock lock(&memory_quota_mu_);
+    MutexLock lock(&reclaimer_mu_);
     GPR_ASSERT(!shutdown_);
     shutdown_ = true;
     memory_quota = memory_quota_;
@@ -207,16 +207,11 @@ 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) {
-    double pressure;
-    size_t max_recommended_allocation_size;
-    {
-      MutexLock lock(&memory_quota_mu_);
-      const auto pressure_and_max_recommended_allocation_size =
-          memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize();
-      pressure = pressure_and_max_recommended_allocation_size.first;
-      max_recommended_allocation_size =
-          pressure_and_max_recommended_allocation_size.second;
-    }
+    const auto pressure_and_max_recommended_allocation_size =
+        memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize();
+    double pressure = pressure_and_max_recommended_allocation_size.first;
+    size_t max_recommended_allocation_size =
+        pressure_and_max_recommended_allocation_size.second;
     // Reduce allocation size proportional to the pressure > 80% usage.
     if (pressure > 0.8) {
       scaled_size_over_min =
@@ -265,9 +260,7 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
         gpr_log(GPR_INFO, "[%p|%s] Early return %" PRIdPTR " bytes", this,
                 name_.c_str(), ret);
       }
-      MutexLock lock(&memory_quota_mu_);
-      GPR_ASSERT(taken_bytes_ >= ret);
-      taken_bytes_ -= ret;
+      GPR_ASSERT(taken_bytes_.fetch_sub(ret, std::memory_order_relaxed) >= ret);
       memory_quota_->Return(ret);
       return;
     }
@@ -275,29 +268,26 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
 }
 
 void GrpcMemoryAllocatorImpl::Replenish() {
-  MutexLock lock(&memory_quota_mu_);
-  GPR_ASSERT(!shutdown_);
   // Attempt a fairly low rate exponential growth request size, bounded between
   // some reasonable limits declared at top of file.
-  auto amount = Clamp(taken_bytes_ / 3, kMinReplenishBytes, kMaxReplenishBytes);
+  auto amount = Clamp(taken_bytes_.load(std::memory_order_relaxed) / 3,
+                      kMinReplenishBytes, kMaxReplenishBytes);
   // Take the requested amount from the quota.
   memory_quota_->Take(amount);
   // Record that we've taken it.
-  taken_bytes_ += amount;
+  taken_bytes_.fetch_add(amount, std::memory_order_relaxed);
   // Add the taken amount to the free pool.
   free_bytes_.fetch_add(amount, std::memory_order_acq_rel);
   // See if we can add ourselves as a reclaimer.
-  MaybeRegisterReclaimerLocked();
+  MaybeRegisterReclaimer();
 }
 
 void GrpcMemoryAllocatorImpl::MaybeRegisterReclaimer() {
-  MutexLock lock(&memory_quota_mu_);
-  MaybeRegisterReclaimerLocked();
-}
-
-void GrpcMemoryAllocatorImpl::MaybeRegisterReclaimerLocked() {
   // If the reclaimer is already registered, then there's nothing to do.
-  if (registered_reclaimer_) return;
+  if (registered_reclaimer_.exchange(true, std::memory_order_relaxed)) {
+    return;
+  }
+  MutexLock lock(&reclaimer_mu_);
   if (shutdown_) return;
   // Grab references to the things we'll need
   auto self = shared_from_this();
@@ -308,49 +298,17 @@ void GrpcMemoryAllocatorImpl::MaybeRegisterReclaimerLocked() {
     auto self = self_weak.lock();
     if (self == nullptr) return;
     auto* p = static_cast<GrpcMemoryAllocatorImpl*>(self.get());
-    MutexLock lock(&p->memory_quota_mu_);
-    p->registered_reclaimer_ = false;
+    p->registered_reclaimer_.store(false, std::memory_order_relaxed);
     // Figure out how many bytes we can return to the quota.
     size_t return_bytes = p->free_bytes_.exchange(0, std::memory_order_acq_rel);
     if (return_bytes == 0) return;
     // Subtract that from our outstanding balance.
-    p->taken_bytes_ -= return_bytes;
+    p->taken_bytes_.fetch_sub(return_bytes);
     // And return them to the quota.
     p->memory_quota_->Return(return_bytes);
   });
 }
 
-void GrpcMemoryAllocatorImpl::Rebind(
-    std::shared_ptr<BasicMemoryQuota> memory_quota) {
-  MutexLock lock(&memory_quota_mu_);
-  GPR_ASSERT(!shutdown_);
-  if (memory_quota_ == memory_quota) return;
-  // Return memory to the original memory quota.
-  memory_quota_->Return(taken_bytes_);
-  // Reassign any queued reclaimers
-  for (size_t i = 0; i < kNumReclamationPasses; i++) {
-    if (reclamation_handles_[i] != nullptr) {
-      reclamation_handles_[i]->Requeue(memory_quota->reclaimer_queue(i));
-    }
-  }
-  // Switch to the new memory quota, leaving the old one in memory_quota so that
-  // when we unref it, we are outside of lock.
-  memory_quota_.swap(memory_quota);
-  // Drop our freed memory down to zero, to avoid needing to ask the new
-  // quota for memory we're not currently using.
-  taken_bytes_ -= free_bytes_.exchange(0, std::memory_order_acq_rel);
-  // And let the new quota know how much we're already using.
-  memory_quota_->Take(taken_bytes_);
-}
-
-//
-// MemoryOwner
-//
-
-void MemoryOwner::Rebind(MemoryQuota* quota) {
-  impl()->Rebind(quota->memory_quota_);
-}
-
 //
 // BasicMemoryQuota
 //

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

@@ -288,11 +288,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.
@@ -315,7 +310,7 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   // Post a reclamation function.
   template <typename F>
   void PostReclaimer(ReclamationPass pass, F fn) {
-    MutexLock lock(&memory_quota_mu_);
+    MutexLock lock(&reclaimer_mu_);
     GPR_ASSERT(!shutdown_);
     InsertReclaimer(static_cast<size_t>(pass), std::move(fn));
   }
@@ -325,7 +320,6 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
 
   // Read the instantaneous memory pressure
   double InstantaneousPressure() const {
-    MutexLock lock(&memory_quota_mu_);
     return memory_quota_->InstantaneousPressureAndMaxRecommendedAllocationSize()
         .first;
   }
@@ -344,39 +338,34 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
   void MaybeDonateBack();
   // Replenish bytes from the quota, without blocking, possibly entering
   // overcommit.
-  void Replenish() ABSL_LOCKS_EXCLUDED(memory_quota_mu_);
+  void Replenish();
   // 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 MaybeRegisterReclaimer() ABSL_LOCKS_EXCLUDED(reclaimer_mu_);
   template <typename F>
   void InsertReclaimer(size_t pass, F fn)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(memory_quota_mu_) {
+      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;
-  bool registered_reclaimer_ ABSL_GUARDED_BY(memory_quota_mu_) = false;
+  std::atomic<size_t> taken_bytes_{sizeof(GrpcMemoryAllocatorImpl)};
+  std::atomic<bool> registered_reclaimer_{false};
+  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.
   OrphanablePtr<ReclaimerQueue::Handle>
       reclamation_handles_[kNumReclamationPasses] ABSL_GUARDED_BY(
-          memory_quota_mu_);
+          reclaimer_mu_);
   // Name of this allocator.
   std::string name_;
 };
@@ -402,9 +391,6 @@ class MemoryOwner final : public MemoryAllocator {
     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();