grpc 1.41.1 → 1.44.0.pre2

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,17 +25,24 @@
 
 #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.
@@ -70,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"
 
@@ -73,7 +74,7 @@ class RegistryState {
     ResolverFactory* factory =
         tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
     if (factory != nullptr) {
-      *uri = *tmp_uri;
+      *uri = std::move(*tmp_uri);
       return factory;
     }
     *canonical_target = absl::StrCat(default_prefix_.get(), target);
@@ -81,7 +82,7 @@ class RegistryState {
     factory =
         tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
     if (factory != nullptr) {
-      *uri = *tmp_uri2;
+      *uri = std::move(*tmp_uri2);
       return factory;
     }
     if (!tmp_uri.ok() || !tmp_uri2.ok()) {
@@ -104,10 +105,10 @@ class RegistryState {
   // hurting performance (which is unlikely, since these allocations
   // only occur at gRPC initialization time).
   absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
-  grpc_core::UniquePtr<char> default_prefix_;
+  UniquePtr<char> default_prefix_;
 };
 
-static RegistryState* g_state = nullptr;
+RegistryState* g_state = nullptr;
 
 }  // namespace
 
@@ -158,18 +159,16 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     std::shared_ptr<WorkSerializer> work_serializer,
     std::unique_ptr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
-  std::string canonical_target;
   ResolverArgs resolver_args;
   ResolverFactory* factory = g_state->FindResolverFactory(
-      target, &resolver_args.uri, &canonical_target);
+      target, &resolver_args.uri, &resolver_args.uri_string);
+  if (factory == nullptr) return nullptr;
+  if (resolver_args.uri_string.empty()) resolver_args.uri_string = target;
   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);
-  OrphanablePtr<Resolver> resolver =
-      factory == nullptr ? nullptr
-                         : factory->CreateResolver(std::move(resolver_args));
-  return resolver;
+  return factory->CreateResolver(std::move(resolver_args));
 }
 
 std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
@@ -183,15 +182,14 @@ std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
   return authority;
 }
 
-grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
-    const char* target) {
+UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(const char* target) {
   GPR_ASSERT(g_state != nullptr);
   URI uri;
   std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return grpc_core::UniquePtr<char>(canonical_target.empty()
-                                        ? gpr_strdup(target)
-                                        : gpr_strdup(canonical_target.c_str()));
+  return UniquePtr<char>(canonical_target.empty()
+                             ? gpr_strdup(target)
+                             : gpr_strdup(canonical_target.c_str()));
 }
 
 }  // namespace grpc_core

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 {
 
@@ -76,8 +75,7 @@ class ResolverRegistry {
   static std::string GetDefaultAuthority(absl::string_view target);
 
   /// Returns \a target with the default prefix prepended, if needed.
-  static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(
-      const char* target);
+  static UniquePtr<char> AddDefaultPrefixIfNeeded(const char* target);
 
   /// Returns the resolver factory for \a scheme.
   /// Caller does NOT own the return value.
@@ -86,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 {
 
@@ -128,7 +128,7 @@ class ServerAddressWeightAttribute : public ServerAddress::AttributeInterface {
   int Cmp(const AttributeInterface* other) const override {
     const auto* other_locality_attr =
         static_cast<const ServerAddressWeightAttribute*>(other);
-    return GPR_ICMP(weight_, other_locality_attr->weight_);
+    return QsortCompare(weight_, other_locality_attr->weight_);
   }
 
   std::string ToString() const override {
@@ -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

@@ -0,0 +1,108 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/resource_quota/api.h"
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+namespace grpc_core {
+
+ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
+    const grpc_channel_args* args) {
+  return grpc_channel_args_find_pointer<ResourceQuota>(args,
+                                                       GRPC_ARG_RESOURCE_QUOTA)
+      ->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);
+  }
+  // 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);
+}
+}  // namespace
+
+void RegisterResourceQuota(CoreConfiguration::Builder* builder) {
+  builder->channel_args_preconditioning()->RegisterStage(
+      EnsureResourceQuotaInChannelArgs);
+}
+
+}  // 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;
+}
+
+extern "C" grpc_resource_quota* grpc_resource_quota_create(const char* name) {
+  static std::atomic<uintptr_t> anonymous_counter{0};
+  std::string quota_name =
+      name == nullptr
+          ? absl::StrCat("anonymous-quota-", anonymous_counter.fetch_add(1))
+          : name;
+  return (new grpc_core::ResourceQuota(std::move(quota_name)))->c_ptr();
+}
+
+extern "C" void grpc_resource_quota_ref(grpc_resource_quota* resource_quota) {
+  grpc_core::ResourceQuota::FromC(resource_quota)->Ref().release();
+}
+
+extern "C" void grpc_resource_quota_unref(grpc_resource_quota* resource_quota) {
+  grpc_core::ResourceQuota::FromC(resource_quota)->Unref();
+}
+
+extern "C" void grpc_resource_quota_resize(grpc_resource_quota* resource_quota,
+                                           size_t new_size) {
+  grpc_core::ExecCtx exec_ctx;
+  grpc_core::ResourceQuota::FromC(resource_quota)
+      ->memory_quota()
+      ->SetSize(new_size);
+}
+
+extern "C" void grpc_resource_quota_set_max_threads(
+    grpc_resource_quota* resource_quota, int new_max_threads) {
+  grpc_core::ResourceQuota::FromC(resource_quota)
+      ->thread_quota()
+      ->SetMax(new_max_threads);
+}

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

@@ -0,0 +1,40 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
+#define GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+
+typedef struct grpc_resource_quota grpc_resource_quota;
+
+namespace grpc_core {
+
+// TODO(ctiller): This is a hack. We need to do real accounting instead of
+// hard coding.
+constexpr size_t kResourceQuotaChannelSize = 50 * 1024;
+
+// Retrieve the resource quota from the channel args.
+// UB if not set.
+ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(const grpc_channel_args* args);
+
+void RegisterResourceQuota(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_RESOURCE_QUOTA_API_H

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

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

@@ -22,14 +22,15 @@
 // Tracks the total memory allocated against it, so that future arenas can
 // pre-allocate the right amount of memory
 
-#ifndef GRPC_CORE_LIB_GPRPP_ARENA_H
-#define GRPC_CORE_LIB_GPRPP_ARENA_H
+#ifndef GRPC_CORE_LIB_RESOURCE_QUOTA_ARENA_H
+#define GRPC_CORE_LIB_RESOURCE_QUOTA_ARENA_H
 
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
 
 #include <atomic>
+#include <memory>
 #include <new>
 #include <utility>
 
@@ -37,20 +38,22 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gpr/spinlock.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 
 namespace grpc_core {
 
 class Arena {
  public:
   // Create an arena, with \a initial_size bytes in the first allocated buffer.
-  static Arena* Create(size_t initial_size);
+  static Arena* Create(size_t initial_size, MemoryAllocator* memory_allocator);
 
   // Create an arena, with \a initial_size bytes in the first allocated buffer,
   // and return both a void pointer to the returned arena and a void* with the
   // first allocation.
-  static std::pair<Arena*, void*> CreateWithAlloc(size_t initial_size,
-                                                  size_t alloc_size);
+  static std::pair<Arena*, void*> CreateWithAlloc(
+      size_t initial_size, size_t alloc_size,
+      MemoryAllocator* memory_allocator);
 
   // Destroy an arena, returning the total number of bytes allocated.
   size_t Destroy();
@@ -95,9 +98,11 @@ class Arena {
   //   quick optimization (avoiding an atomic fetch-add) for the common case
   //   where we wish to create an arena and then perform an immediate
   //   allocation.
-  explicit Arena(size_t initial_size, size_t initial_alloc = 0)
+  explicit Arena(size_t initial_size, size_t initial_alloc,
+                 MemoryAllocator* memory_allocator)
       : total_used_(GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_alloc)),
-        initial_zone_size_(initial_size) {}
+        initial_zone_size_(initial_size),
+        memory_allocator_(memory_allocator) {}
 
   ~Arena();
 
@@ -106,16 +111,32 @@ class Arena {
   // Keep track of the total used size. We use this in our call sizing
   // hysteresis.
   std::atomic<size_t> total_used_{0};
+  std::atomic<size_t> total_allocated_{0};
   const size_t initial_zone_size_;
-  gpr_spinlock arena_growth_spinlock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   // If the initial arena allocation wasn't enough, we allocate additional zones
   // in a reverse linked list. Each additional zone consists of (1) a pointer to
   // the zone added before this zone (null if this is the first additional zone)
   // and (2) the allocated memory. The arena itself maintains a pointer to the
   // last zone; the zone list is reverse-walked during arena destruction only.
-  Zone* last_zone_ = nullptr;
+  std::atomic<Zone*> last_zone_{nullptr};
+  // The backing memory quota
+  MemoryAllocator* const memory_allocator_;
 };
 
+// Smart pointer for arenas when the final size is not required.
+struct ScopedArenaDeleter {
+  void operator()(Arena* arena) { arena->Destroy(); }
+};
+using ScopedArenaPtr = std::unique_ptr<Arena, ScopedArenaDeleter>;
+inline ScopedArenaPtr MakeScopedArena(size_t initial_size,
+                                      MemoryAllocator* memory_allocator) {
+  return ScopedArenaPtr(Arena::Create(initial_size, memory_allocator));
+}
+
+// Arenas form a context for activities
+template <>
+struct ContextType<Arena> {};
+
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_GPRPP_ARENA_H */
+#endif /* GRPC_CORE_LIB_RESOURCE_QUOTA_ARENA_H */