grpc 1.43.1 → 1.44.0.pre2

data/src/core/lib/iomgr/unix_sockets_posix_noop.cc

@@ -33,18 +33,14 @@ void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   GPR_ASSERT(0);
 }
 
-grpc_error_handle grpc_resolve_unix_domain_address(
-    absl::string_view /* name */, grpc_resolved_addresses** addresses) {
-  *addresses = NULL;
-  return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-      "Unix domain sockets are not supported on Windows");
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_domain_address(absl::string_view /* name */) {
+  return absl::UnknownError("Unix domain sockets are not supported on Windows");
 }
 
-grpc_error_handle grpc_resolve_unix_abstract_domain_address(
-    absl::string_view, grpc_resolved_addresses** addresses) {
-  *addresses = NULL;
-  return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-      "Unix domain sockets are not supported on Windows");
+absl::StatusOr<std::vector<grpc_resolved_address>>
+grpc_resolve_unix_abstract_domain_address(absl::string_view /* name */) {
+  return absl::UnknownError("Unix domain sockets are not supported on Windows");
 }
 
 int grpc_is_unix_socket(const grpc_resolved_address* /* addr */) {
@@ -54,9 +50,4 @@ int grpc_is_unix_socket(const grpc_resolved_address* /* addr */) {
 void grpc_unlink_if_unix_domain_socket(
     const grpc_resolved_address* /* addr */) {}
 
-std::string grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address* /* addr */) {
-  return "";
-}
-
 #endif

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

@@ -291,7 +291,7 @@ bool HeaderMatcher::Match(
     match = value.has_value() == present_match_;
   } else if (!value.has_value()) {
     // All other types fail to match if field is not present.
-    match = false;
+    return false;
   } else if (type_ == Type::kRange) {
     int64_t int_value;
     match = absl::SimpleAtoi(value.value(), &int_value) &&

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

@@ -24,6 +24,7 @@
 #include <atomic>
 #include <functional>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -267,6 +268,8 @@ namespace promise_detail {
 template <typename Context>
 class ContextHolder {
  public:
+  using ContextType = Context;
+
   explicit ContextHolder(Context value) : value_(std::move(value)) {}
   Context* GetContext() { return &value_; }
 
@@ -277,6 +280,8 @@ class ContextHolder {
 template <typename Context>
 class ContextHolder<Context*> {
  public:
+  using ContextType = Context;
+
   explicit ContextHolder(Context* value) : value_(value) {}
   Context* GetContext() { return value_; }
 
@@ -284,11 +289,35 @@ class ContextHolder<Context*> {
   Context* value_;
 };
 
+template <typename Context, typename Deleter>
+class ContextHolder<std::unique_ptr<Context, Deleter>> {
+ public:
+  using ContextType = Context;
+
+  explicit ContextHolder(std::unique_ptr<Context, Deleter> value)
+      : value_(std::move(value)) {}
+  Context* GetContext() { return value_.get(); }
+
+ private:
+  std::unique_ptr<Context, Deleter> value_;
+};
+
+template <typename HeldContext>
+using ContextTypeFromHeld = typename ContextHolder<HeldContext>::ContextType;
+
 template <typename... Contexts>
-class EnterContexts : public promise_detail::Context<Contexts>... {
+class ActivityContexts : public ContextHolder<Contexts>... {
  public:
-  explicit EnterContexts(Contexts*... contexts)
-      : promise_detail::Context<Contexts>(contexts)... {}
+  explicit ActivityContexts(Contexts&&... contexts)
+      : ContextHolder<Contexts>(std::forward<Contexts>(contexts))... {}
+
+  class ScopedContext : public Context<ContextTypeFromHeld<Contexts>>... {
+   public:
+    explicit ScopedContext(ActivityContexts* contexts)
+        : Context<ContextTypeFromHeld<Contexts>>(
+              static_cast<ContextHolder<Contexts>*>(contexts)
+                  ->GetContext())... {}
+  };
 };
 
 // Implementation details for an Activity of an arbitrary type of promise.
@@ -303,15 +332,14 @@ class EnterContexts : public promise_detail::Context<Contexts>... {
 // invoked, and that a given activity will not be concurrently scheduled again
 // until its RunScheduledWakeup() has been invoked.
 template <class F, class WakeupScheduler, class OnDone, typename... Contexts>
-class PromiseActivity final
-    : public Activity,
-      private promise_detail::ContextHolder<Contexts>... {
+class PromiseActivity final : public Activity,
+                              private ActivityContexts<Contexts...> {
  public:
   using Factory = PromiseFactory<void, F>;
   PromiseActivity(F promise_factory, WakeupScheduler wakeup_scheduler,
-                  OnDone on_done, Contexts... contexts)
+                  OnDone on_done, Contexts&&... contexts)
       : Activity(),
-        ContextHolder<Contexts>(std::move(contexts))...,
+        ActivityContexts<Contexts...>(std::forward<Contexts>(contexts)...),
         wakeup_scheduler_(std::move(wakeup_scheduler)),
         on_done_(std::move(on_done)) {
     // Lock, construct an initial promise from the factory, and step it.
@@ -361,6 +389,8 @@ class PromiseActivity final
   }
 
  private:
+  using typename ActivityContexts<Contexts...>::ScopedContext;
+
   // Wakeup this activity. Arrange to poll the activity again at a convenient
   // time: this could be inline if it's deemed safe, or it could be by passing
   // the activity to an external threadpool to run. If the activity is already
@@ -412,28 +442,27 @@ class PromiseActivity final
   }
 
   // The main body of a step: set the current activity, and any contexts, and
-  // then run the main polling loop. Contained in a function by itself in order
-  // to keep the scoping rules a little easier in Step().
+  // then run the main polling loop. Contained in a function by itself in
+  // order to keep the scoping rules a little easier in Step().
   absl::optional<absl::Status> RunStep() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     ScopedActivity scoped_activity(this);
-    EnterContexts<Contexts...> contexts(
-        static_cast<ContextHolder<Contexts>*>(this)->GetContext()...);
+    ScopedContext contexts(this);
     return StepLoop();
   }
 
-  // Similarly to RunStep, but additionally construct the promise from a promise
-  // factory before entering the main loop. Called once from the constructor.
+  // Similarly to RunStep, but additionally construct the promise from a
+  // promise factory before entering the main loop. Called once from the
+  // constructor.
   absl::optional<absl::Status> Start(Factory promise_factory)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     ScopedActivity scoped_activity(this);
-    EnterContexts<Contexts...> contexts(
-        static_cast<ContextHolder<Contexts>*>(this)->GetContext()...);
+    ScopedContext contexts(this);
     Construct(&promise_holder_.promise, promise_factory.Once());
     return StepLoop();
   }
 
-  // Until there are no wakeups from within and the promise is incomplete: poll
-  // the promise.
+  // Until there are no wakeups from within and the promise is incomplete:
+  // poll the promise.
   absl::optional<absl::Status> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     GPR_ASSERT(is_current());
     while (true) {
@@ -486,12 +515,12 @@ template <typename Factory, typename WakeupScheduler, typename OnDone,
           typename... Contexts>
 ActivityPtr MakeActivity(Factory promise_factory,
                          WakeupScheduler wakeup_scheduler, OnDone on_done,
-                         Contexts... contexts) {
+                         Contexts&&... contexts) {
   return ActivityPtr(
       new promise_detail::PromiseActivity<Factory, WakeupScheduler, OnDone,
                                           Contexts...>(
           std::move(promise_factory), std::move(wakeup_scheduler),
-          std::move(on_done), std::move(contexts)...));
+          std::move(on_done), std::forward<Contexts>(contexts)...));
 }
 
 }  // namespace grpc_core

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

@@ -41,4 +41,9 @@ inline absl::Status IntoStatus(absl::Status* status) {
 }  // namespace promise_detail
 }  // namespace grpc_core
 
+// Return true if the status represented by the argument is ok, false if not.
+// By implementing this function for other, non-absl::Status types, those types
+// can participate in TrySeq as result types that affect control flow.
+inline bool IsStatusOk(const absl::Status& status) { return status.ok(); }
+
 #endif  // GRPC_CORE_LIB_PROMISE_DETAIL_STATUS_H

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/resolver.h"
+#include "src/core/lib/resolver/resolver.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
                                                            "resolver_refcount");
@@ -38,35 +38,28 @@ Resolver::Resolver()
 // Resolver::Result
 //
 
-Resolver::Result::~Result() {
-  GRPC_ERROR_UNREF(service_config_error);
-  grpc_channel_args_destroy(args);
-}
+Resolver::Result::~Result() { grpc_channel_args_destroy(args); }
 
-Resolver::Result::Result(const Result& other) {
-  addresses = other.addresses;
-  service_config = other.service_config;
-  service_config_error = GRPC_ERROR_REF(other.service_config_error);
-  args = grpc_channel_args_copy(other.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);
-  service_config_error = other.service_config_error;
-  other.service_config_error = GRPC_ERROR_NONE;
-  args = 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;
-  }
+  if (&other == this) return *this;
   addresses = other.addresses;
   service_config = other.service_config;
-  GRPC_ERROR_UNREF(service_config_error);
-  service_config_error = GRPC_ERROR_REF(other.service_config_error);
+  resolution_note = other.resolution_note;
   grpc_channel_args_destroy(args);
   args = grpc_channel_args_copy(other.args);
   return *this;
@@ -75,9 +68,8 @@ Resolver::Result& Resolver::Result::operator=(const Result& other) {
 Resolver::Result& Resolver::Result::operator=(Result&& other) noexcept {
   addresses = std::move(other.addresses);
   service_config = std::move(other.service_config);
-  GRPC_ERROR_UNREF(service_config_error);
-  service_config_error = other.service_config_error;
-  other.service_config_error = GRPC_ERROR_NONE;
+  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;

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver.h

@@ -1,34 +1,32 @@
-/*
- *
- * Copyright 2015 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_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H
+//
+// Copyright 2015 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_RESOLVER_RESOLVER_H
+#define GRPC_CORE_LIB_RESOLVER_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
 
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/service_config/service_config.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/service_config/service_config.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
 
@@ -53,13 +51,23 @@ class Resolver : public InternallyRefCounted<Resolver> {
  public:
   /// Results returned by the resolver.
   struct Result {
-    ServerAddressList addresses;
-    RefCountedPtr<ServiceConfig> service_config;
-    grpc_error_handle service_config_error = GRPC_ERROR_NONE;
+    /// A list of addresses, or an error.
+    absl::StatusOr<ServerAddressList> addresses;
+    /// A service config, or an error.
+    absl::StatusOr<RefCountedPtr<ServiceConfig>> service_config = nullptr;
+    /// An optional human-readable note describing context about the resolution,
+    /// to be passed along to the LB policy for inclusion in RPC failure status
+    /// messages in cases where neither \a addresses nor \a service_config
+    /// has a non-OK status.  For example, a resolver that returns an empty
+    /// address list but a valid service config may set to this to something
+    /// like "no DNS entries found for <name>".
+    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_error and
-    // grpc_channel_args are convert to copyable and movable C++ objects.
+    // 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);
@@ -74,17 +82,11 @@ class Resolver : public InternallyRefCounted<Resolver> {
    public:
     virtual ~ResultHandler() {}
 
-    /// Returns a result to the channel.
-    /// Takes ownership of \a result.args.
-    virtual void ReturnResult(Result result) = 0;  // NOLINT
-
-    /// Returns a transient error to the channel.
-    /// If the resolver does not set the GRPC_ERROR_INT_GRPC_STATUS
-    /// attribute on the error, calls will be failed with status UNKNOWN.
-    virtual void ReturnError(grpc_error_handle error) = 0;
-
-    // TODO(yashkt): As part of the service config error handling
-    // changes, add a method to parse the service config JSON string.
+    /// 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
   };
 
   // Not copyable nor movable.
@@ -113,9 +115,6 @@ class Resolver : public InternallyRefCounted<Resolver> {
   /// Resets the re-resolution backoff, if any.
   /// This needs to be implemented only by pull-based implementations;
   /// for push-based implementations, it will be a no-op.
-  /// TODO(roth): Pull the backoff code out of resolver and into
-  /// client_channel, so that it can be shared across resolver
-  /// implementations.  At that point, this method can go away.
   virtual void ResetBackoffLocked() {}
 
   // Note: This must be invoked while holding the work_serializer.
@@ -133,4 +132,4 @@ class Resolver : public InternallyRefCounted<Resolver> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H */
+#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_H

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver_factory.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H
+#ifndef GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
+#define GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,14 +25,19 @@
 
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/uri/uri_parser.h"
 
+typedef struct grpc_pollset_set grpc_pollset_set;
+
 namespace grpc_core {
 
+// TODO(yashkt): Move WorkSerializer to its own Bazel target, depend on that
+// target from this one, and remove this forward declaration.
+class WorkSerializer;
+
 struct ResolverArgs {
   /// The parsed URI to resolve.
   URI uri;
@@ -72,4 +77,4 @@ class ResolverFactory {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H */
+#endif /* GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H */

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver_registry.cc

@@ -18,11 +18,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/lib/resolver/resolver_registry.h"
 
 #include <string.h>
 
-#include "absl/container/inlined_vector.h"
+#include <vector>
+
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 

data/src/core/{ext/filters/client_channel → lib/resolver}/resolver_registry.h

@@ -16,15 +16,14 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H
+#ifndef GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
+#define GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/resolver_factory.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/resolver/resolver_factory.h"
 
 namespace grpc_core {
 
@@ -85,4 +84,4 @@ class ResolverRegistry {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H */
+#endif /* GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H */

data/src/core/{ext/filters/client_channel → lib/resolver}/server_address.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/lib/resolver/server_address.h"
 
 #include <memory>
 #include <string>

data/src/core/{ext/filters/client_channel → lib/resolver}/server_address.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVER_ADDRESS_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVER_ADDRESS_H
+#ifndef GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
+#define GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -29,7 +29,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
@@ -141,4 +141,4 @@ class ServerAddressWeightAttribute : public ServerAddress::AttributeInterface {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVER_ADDRESS_H */
+#endif /* GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H */

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

@@ -27,7 +27,6 @@ namespace grpc_core {
 
 // TODO(ctiller): This is a hack. We need to do real accounting instead of
 // hard coding.
-constexpr size_t kResourceQuotaCallSize = 15 * 1024;
 constexpr size_t kResourceQuotaChannelSize = 50 * 1024;
 
 // Retrieve the resource quota from the channel args.

data/src/core/lib/{gprpp → resource_quota}/arena.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/resource_quota/arena.h"
 
 #include <string.h>
 
@@ -61,22 +61,24 @@ Arena::~Arena() {
   }
 }
 
-Arena* Arena::Create(size_t initial_size) {
-  return new (ArenaStorage(initial_size)) Arena(initial_size);
+Arena* Arena::Create(size_t initial_size, MemoryAllocator* memory_allocator) {
+  return new (ArenaStorage(initial_size))
+      Arena(initial_size, 0, memory_allocator);
 }
 
-std::pair<Arena*, void*> Arena::CreateWithAlloc(size_t initial_size,
-                                                size_t alloc_size) {
+std::pair<Arena*, void*> Arena::CreateWithAlloc(
+    size_t initial_size, size_t alloc_size, MemoryAllocator* memory_allocator) {
   static constexpr size_t base_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
-  auto* new_arena =
-      new (ArenaStorage(initial_size)) Arena(initial_size, alloc_size);
+  auto* new_arena = new (ArenaStorage(initial_size))
+      Arena(initial_size, alloc_size, memory_allocator);
   void* first_alloc = reinterpret_cast<char*>(new_arena) + base_size;
   return std::make_pair(new_arena, first_alloc);
 }
 
 size_t Arena::Destroy() {
   size_t size = total_used_.load(std::memory_order_relaxed);
+  memory_allocator_->Release(total_allocated_.load(std::memory_order_relaxed));
   this->~Arena();
   gpr_free_aligned(this);
   return size;
@@ -91,13 +93,14 @@ void* Arena::AllocZone(size_t size) {
   static constexpr size_t zone_base_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Zone));
   size_t alloc_size = zone_base_size + size;
+  memory_allocator_->Reserve(alloc_size);
+  total_allocated_.fetch_add(alloc_size, std::memory_order_relaxed);
   Zone* z = new (gpr_malloc_aligned(alloc_size, GPR_MAX_ALIGNMENT)) Zone();
-  {
-    gpr_spinlock_lock(&arena_growth_spinlock_);
-    z->prev = last_zone_;
-    last_zone_ = z;
-    gpr_spinlock_unlock(&arena_growth_spinlock_);
-  }
+  auto* prev = last_zone_.load(std::memory_order_relaxed);
+  do {
+    z->prev = prev;
+  } while (!last_zone_.compare_exchange_weak(prev, z, std::memory_order_relaxed,
+                                             std::memory_order_relaxed));
   return reinterpret_cast<char*>(z) + zone_base_size;
 }