grpc 1.43.1 → 1.46.2

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

@@ -1,23 +1,21 @@
-/*
- *
- * 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_FACTORY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_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_FACTORY_H
+#define GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,19 +23,22 @@
 
 #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;
-  /// The URI string.
-  std::string uri_string;
   /// Channel args to be included in resolver results.
   const grpc_channel_args* args = nullptr;
   /// Used to drive I/O in the name resolution process.
@@ -50,6 +51,12 @@ struct ResolverArgs {
 
 class ResolverFactory {
  public:
+  virtual ~ResolverFactory() {}
+
+  /// Returns the URI scheme that this factory implements.
+  /// Caller does NOT take ownership of result.
+  virtual absl::string_view scheme() const = 0;
+
   /// Returns a bool indicating whether the input uri is valid to create a
   /// resolver.
   virtual bool IsValidUri(const URI& uri) const = 0;
@@ -62,14 +69,8 @@ class ResolverFactory {
   virtual std::string GetDefaultAuthority(const URI& uri) const {
     return std::string(absl::StripPrefix(uri.path(), "/"));
   }
-
-  /// Returns the URI scheme that this factory implements.
-  /// Caller does NOT take ownership of result.
-  virtual const char* scheme() const = 0;
-
-  virtual ~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/lib/resolver/resolver_registry.cc

@@ -0,0 +1,156 @@
+//
+// 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/resolver/resolver_registry.h"
+
+#include <string.h>
+
+#include <vector>
+
+#include "absl/memory/memory.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 {
+
+//
+// ResolverRegistry::Builder
+//
+
+ResolverRegistry::Builder::Builder() { Reset(); }
+
+void ResolverRegistry::Builder::SetDefaultPrefix(std::string default_prefix) {
+  state_.default_prefix = std::move(default_prefix);
+}
+
+void ResolverRegistry::Builder::RegisterResolverFactory(
+    std::unique_ptr<ResolverFactory> factory) {
+  auto p = state_.factories.emplace(factory->scheme(), std::move(factory));
+  GPR_ASSERT(p.second);
+}
+
+bool ResolverRegistry::Builder::HasResolverFactory(
+    absl::string_view scheme) const {
+  return state_.factories.find(scheme) != state_.factories.end();
+}
+
+void ResolverRegistry::Builder::Reset() {
+  state_.factories.clear();
+  state_.default_prefix = "dns:///";
+}
+
+ResolverRegistry ResolverRegistry::Builder::Build() {
+  return ResolverRegistry(std::move(state_));
+}
+
+//
+// ResolverRegistry
+//
+
+bool ResolverRegistry::IsValidTarget(absl::string_view target) const {
+  std::string canonical_target;
+  URI uri;
+  ResolverFactory* factory =
+      FindResolverFactory(target, &uri, &canonical_target);
+  if (factory == nullptr) return false;
+  return factory->IsValidUri(uri);
+}
+
+OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
+    absl::string_view target, const grpc_channel_args* args,
+    grpc_pollset_set* pollset_set,
+    std::shared_ptr<WorkSerializer> work_serializer,
+    std::unique_ptr<Resolver::ResultHandler> result_handler) const {
+  std::string canonical_target;
+  ResolverArgs resolver_args;
+  ResolverFactory* factory =
+      FindResolverFactory(target, &resolver_args.uri, &canonical_target);
+  if (factory == nullptr) return nullptr;
+  resolver_args.args = args;
+  resolver_args.pollset_set = pollset_set;
+  resolver_args.work_serializer = std::move(work_serializer);
+  resolver_args.result_handler = std::move(result_handler);
+  return factory->CreateResolver(std::move(resolver_args));
+}
+
+std::string ResolverRegistry::GetDefaultAuthority(
+    absl::string_view target) const {
+  std::string canonical_target;
+  URI uri;
+  ResolverFactory* factory =
+      FindResolverFactory(target, &uri, &canonical_target);
+  if (factory == nullptr) return "";
+  return factory->GetDefaultAuthority(uri);
+}
+
+std::string ResolverRegistry::AddDefaultPrefixIfNeeded(
+    absl::string_view target) const {
+  std::string canonical_target;
+  URI uri;
+  FindResolverFactory(target, &uri, &canonical_target);
+  return canonical_target.empty() ? std::string(target) : canonical_target;
+}
+
+ResolverFactory* ResolverRegistry::LookupResolverFactory(
+    absl::string_view scheme) const {
+  auto it = state_.factories.find(scheme);
+  if (it == state_.factories.end()) return nullptr;
+  return it->second.get();
+}
+
+// Returns the factory for the scheme of \a target.  If \a target does
+// not parse as a URI, prepends \a default_prefix_ and tries again.
+// If URI parsing is successful (in either attempt), sets \a uri to
+// point to the parsed URI.
+ResolverFactory* ResolverRegistry::FindResolverFactory(
+    absl::string_view target, URI* uri, std::string* canonical_target) const {
+  GPR_ASSERT(uri != nullptr);
+  absl::StatusOr<URI> tmp_uri = URI::Parse(target);
+  ResolverFactory* factory =
+      tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
+  if (factory != nullptr) {
+    *uri = std::move(*tmp_uri);
+    return factory;
+  }
+  *canonical_target = absl::StrCat(state_.default_prefix, target);
+  absl::StatusOr<URI> tmp_uri2 = URI::Parse(*canonical_target);
+  factory = tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
+  if (factory != nullptr) {
+    *uri = std::move(*tmp_uri2);
+    return factory;
+  }
+  if (!tmp_uri.ok() || !tmp_uri2.ok()) {
+    gpr_log(GPR_ERROR, "%s",
+            absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
+                            tmp_uri.status().ToString(), *canonical_target,
+                            tmp_uri2.status().ToString())
+                .c_str());
+    return nullptr;
+  }
+  gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
+          std::string(target).c_str(), canonical_target->c_str());
+  return nullptr;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,113 @@
+//
+// 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_REGISTRY_H
+#define GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/resolver/resolver_factory.h"
+
+namespace grpc_core {
+
+class ResolverRegistry {
+ private:
+  // Forward declaration needed to use this in Builder.
+  struct State {
+    std::map<absl::string_view, std::unique_ptr<ResolverFactory>> factories;
+    std::string default_prefix;
+  };
+
+ public:
+  /// Methods used to create and populate the ResolverRegistry.
+  /// NOT THREAD SAFE -- to be used only during global gRPC
+  /// initialization and shutdown.
+  class Builder {
+   public:
+    Builder();
+
+    /// Sets the default URI prefix to \a default_prefix.
+    void SetDefaultPrefix(std::string default_prefix);
+
+    /// Registers a resolver factory.  The factory will be used to create a
+    /// resolver for any URI whose scheme matches that of the factory.
+    void RegisterResolverFactory(std::unique_ptr<ResolverFactory> factory);
+
+    /// Returns true iff scheme already has a registered factory.
+    bool HasResolverFactory(absl::string_view scheme) const;
+
+    /// Wipe everything in the registry and reset to empty.
+    void Reset();
+
+    ResolverRegistry Build();
+
+   private:
+    ResolverRegistry::State state_;
+  };
+
+  ResolverRegistry(const ResolverRegistry&) = delete;
+  ResolverRegistry& operator=(const ResolverRegistry&) = delete;
+  ResolverRegistry(ResolverRegistry&&) noexcept;
+  ResolverRegistry& operator=(ResolverRegistry&&) noexcept;
+
+  /// Checks whether the user input \a target is valid to create a resolver.
+  bool IsValidTarget(absl::string_view target) const;
+
+  /// Creates a resolver given \a target.
+  /// First tries to parse \a target as a URI. If this succeeds, tries
+  /// to locate a registered resolver factory based on the URI scheme.
+  /// If parsing fails or there is no factory for the URI's scheme,
+  /// prepends default_prefix to target and tries again.
+  /// If a resolver factory is found, uses it to instantiate a resolver and
+  /// returns it; otherwise, returns nullptr.
+  /// \a args, \a pollset_set, and \a work_serializer are passed to the
+  /// factory's \a CreateResolver() method. \a args are the channel args to be
+  /// included in resolver results. \a pollset_set is used to drive I/O in the
+  /// name resolution process. \a work_serializer is the work_serializer under
+  /// which all resolver calls will be run. \a result_handler is used to return
+  /// results from the resolver.
+  OrphanablePtr<Resolver> CreateResolver(
+      absl::string_view target, const grpc_channel_args* args,
+      grpc_pollset_set* pollset_set,
+      std::shared_ptr<WorkSerializer> work_serializer,
+      std::unique_ptr<Resolver::ResultHandler> result_handler) const;
+
+  /// Returns the default authority to pass from a client for \a target.
+  std::string GetDefaultAuthority(absl::string_view target) const;
+
+  /// Returns \a target with the default prefix prepended, if needed.
+  std::string AddDefaultPrefixIfNeeded(absl::string_view target) const;
+
+  /// Returns the resolver factory for \a scheme.
+  /// Caller does NOT own the return value.
+  ResolverFactory* LookupResolverFactory(absl::string_view scheme) const;
+
+ private:
+  explicit ResolverRegistry(State state) : state_(std::move(state)) {}
+
+  // TODO(ctiller): fix callers such that the canonical_target argument can be
+  // removed, and replaced with uri.ToString().
+  ResolverFactory* FindResolverFactory(absl::string_view target, URI* uri,
+                                       std::string* canonical_target) const;
+
+  State state_;
+};
+
+}  // namespace grpc_core
+
+#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.cc

@@ -20,6 +20,7 @@
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 
 namespace grpc_core {
 
@@ -30,30 +31,13 @@ ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
       ->Ref();
 }
 
-namespace {
-grpc_arg MakeArg(ResourceQuota* quota) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA), quota,
-      grpc_resource_quota_arg_vtable());
-}
-
-const grpc_channel_args* EnsureResourceQuotaInChannelArgs(
-    const grpc_channel_args* args) {
-  const grpc_arg* existing =
-      grpc_channel_args_find(args, GRPC_ARG_RESOURCE_QUOTA);
-  if (existing != nullptr && existing->type == GRPC_ARG_POINTER &&
-      existing->value.pointer.p != nullptr) {
-    return grpc_channel_args_copy(args);
-  }
+ChannelArgs EnsureResourceQuotaInChannelArgs(ChannelArgs args) {
+  if (args.GetObject<ResourceQuota>() != nullptr) return args;
   // If there's no existing quota, add it to the default one - shared between
   // all channel args declared thusly. This prevents us from accidentally not
   // sharing subchannels due to their channel args not specifying a quota.
-  const char* remove[] = {GRPC_ARG_RESOURCE_QUOTA};
-  auto new_arg = MakeArg(ResourceQuota::Default().get());
-  return grpc_channel_args_copy_and_add_and_remove(args, remove, 1, &new_arg,
-                                                   1);
+  return args.SetObject(ResourceQuota::Default());
 }
-}  // namespace
 
 void RegisterResourceQuota(CoreConfiguration::Builder* builder) {
   builder->channel_args_preconditioning()->RegisterStage(
@@ -63,16 +47,7 @@ void RegisterResourceQuota(CoreConfiguration::Builder* builder) {
 }  // namespace grpc_core
 
 extern "C" const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable() {
-  static const grpc_arg_pointer_vtable vtable = {
-      // copy
-      [](void* p) -> void* {
-        return static_cast<grpc_core::ResourceQuota*>(p)->Ref().release();
-      },
-      // destroy
-      [](void* p) { static_cast<grpc_core::ResourceQuota*>(p)->Unref(); },
-      // compare
-      [](void* p, void* q) { return grpc_core::QsortCompare(p, q); }};
-  return &vtable;
+  return grpc_core::ChannelArgTypeTraits<grpc_core::ResourceQuota>::VTable();
 }
 
 extern "C" grpc_resource_quota* grpc_resource_quota_create(const char* name) {

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

@@ -27,8 +27,7 @@ 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;
+constexpr size_t kResourceQuotaChannelSize = 34 * 1024;
 
 // Retrieve the resource quota from the channel args.
 // UB if not set.

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;
 }