grpc 1.42.0 → 1.49.1

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

@@ -0,0 +1,123 @@
+//
+// 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 <map>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/channel/channel_args.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 {
+
+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 ChannelArgs& 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,16 +18,26 @@
 
 #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 <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"
+#include "src/core/lib/channel/channel_args.h"
+
+// IWYU pragma: no_include <sys/socket.h>
 
 namespace grpc_core {
 
@@ -42,12 +52,12 @@ const char* ServerAddressWeightAttribute::kServerAddressWeightAttributeKey =
 //
 
 ServerAddress::ServerAddress(
-    const grpc_resolved_address& address, grpc_channel_args* args,
+    const grpc_resolved_address& address, const ChannelArgs& args,
     std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
     : address_(address), args_(args), attributes_(std::move(attributes)) {}
 
 ServerAddress::ServerAddress(
-    const void* address, size_t address_len, grpc_channel_args* args,
+    const void* address, size_t address_len, const ChannelArgs& args,
     std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
     : args_(args), attributes_(std::move(attributes)) {
   memcpy(address_.addr, address, address_len);
@@ -55,7 +65,7 @@ ServerAddress::ServerAddress(
 }
 
 ServerAddress::ServerAddress(const ServerAddress& other)
-    : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {
+    : address_(other.address_), args_(other.args_) {
   for (const auto& p : other.attributes_) {
     attributes_[p.first] = p.second->Copy();
   }
@@ -65,8 +75,7 @@ ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
     return *this;
   }
   address_ = other.address_;
-  grpc_channel_args_destroy(args_);
-  args_ = grpc_channel_args_copy(other.args_);
+  args_ = other.args_;
   attributes_.clear();
   for (const auto& p : other.attributes_) {
     attributes_[p.first] = p.second->Copy();
@@ -76,15 +85,12 @@ ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
 
 ServerAddress::ServerAddress(ServerAddress&& other) noexcept
     : address_(other.address_),
-      args_(other.args_),
-      attributes_(std::move(other.attributes_)) {
-  other.args_ = nullptr;
-}
+      args_(std::move(other.args_)),
+      attributes_(std::move(other.attributes_)) {}
+
 ServerAddress& ServerAddress::operator=(ServerAddress&& other) noexcept {
   address_ = other.address_;
-  grpc_channel_args_destroy(args_);
-  args_ = other.args_;
-  other.args_ = nullptr;
+  args_ = std::move(other.args_);
   attributes_ = std::move(other.attributes_);
   return *this;
 }
@@ -123,7 +129,7 @@ int ServerAddress::Cmp(const ServerAddress& other) const {
   if (address_.len < other.address_.len) return -1;
   int retval = memcmp(address_.addr, other.address_.addr, address_.len);
   if (retval != 0) return retval;
-  retval = grpc_channel_args_compare(args_, other.args_);
+  retval = QsortCompare(args_, other.args_);
   if (retval != 0) return retval;
   return CompareAttributes(attributes_, other.attributes_);
 }
@@ -149,12 +155,12 @@ ServerAddress ServerAddress::WithAttribute(
 }
 
 std::string ServerAddress::ToString() const {
+  auto addr_str = grpc_sockaddr_to_string(&address_, false);
   std::vector<std::string> parts = {
-      grpc_sockaddr_to_string(&address_, false),
+      addr_str.ok() ? addr_str.value() : addr_str.status().ToString(),
   };
-  if (args_ != nullptr) {
-    parts.emplace_back(
-        absl::StrCat("args={", grpc_channel_args_string(args_), "}"));
+  if (args_ != ChannelArgs()) {
+    parts.emplace_back(absl::StrCat("args=", args_.ToString()));
   }
   if (!attributes_.empty()) {
     std::vector<std::string> attrs;
@@ -167,4 +173,8 @@ std::string ServerAddress::ToString() const {
   return absl::StrJoin(parts, " ");
 }
 
+std::string ServerAddressWeightAttribute::ToString() const {
+  return absl::StrFormat("%d", weight_);
+}
+
 }  // namespace grpc_core

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

@@ -16,20 +16,24 @@
  *
  */
 
-#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>
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <memory>
+#include <string>
+#include <vector>
 
-#include "absl/container/inlined_vector.h"
-#include "absl/strings/str_format.h"
+#include "absl/memory/memory.h"
 
 #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 {
 
@@ -64,16 +68,14 @@ class ServerAddress {
   };
 
   // Takes ownership of args.
-  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args,
+  ServerAddress(const grpc_resolved_address& address, const ChannelArgs& args,
                 std::map<const char*, std::unique_ptr<AttributeInterface>>
                     attributes = {});
   ServerAddress(const void* address, size_t address_len,
-                grpc_channel_args* args,
+                const ChannelArgs& args,
                 std::map<const char*, std::unique_ptr<AttributeInterface>>
                     attributes = {});
 
-  ~ServerAddress() { grpc_channel_args_destroy(args_); }
-
   // Copyable.
   ServerAddress(const ServerAddress& other);
   ServerAddress& operator=(const ServerAddress& other);
@@ -87,7 +89,7 @@ class ServerAddress {
   int Cmp(const ServerAddress& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
-  const grpc_channel_args* args() const { return args_; }
+  const ChannelArgs& args() const { return args_; }
 
   const AttributeInterface* GetAttribute(const char* key) const;
 
@@ -96,11 +98,14 @@ class ServerAddress {
   ServerAddress WithAttribute(const char* key,
                               std::unique_ptr<AttributeInterface> value) const;
 
+  // TODO(ctiller): Prior to making this a public API we should ensure that the
+  // channel args are not part of the generated string, lest we make that debug
+  // format load-bearing via Hyrum's law.
   std::string ToString() const;
 
  private:
   grpc_resolved_address address_;
-  grpc_channel_args* args_;
+  ChannelArgs args_;
   std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 
@@ -108,7 +113,7 @@ class ServerAddress {
 // ServerAddressList
 //
 
-typedef absl::InlinedVector<ServerAddress, 1> ServerAddressList;
+using ServerAddressList = std::vector<ServerAddress>;
 
 //
 // ServerAddressWeightAttribute
@@ -131,9 +136,7 @@ class ServerAddressWeightAttribute : public ServerAddress::AttributeInterface {
     return QsortCompare(weight_, other_locality_attr->weight_);
   }
 
-  std::string ToString() const override {
-    return absl::StrFormat("%d", weight_);
-  }
+  std::string ToString() const override;
 
  private:
   uint32_t weight_;
@@ -141,4 +144,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,96 @@
+// 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 <stdint.h>
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/resource_quota/thread_quota.h"
+
+namespace grpc_core {
+
+ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
+    const grpc_channel_args* args) {
+  return grpc_channel_args_find_pointer<ResourceQuota>(args,
+                                                       GRPC_ARG_RESOURCE_QUOTA)
+      ->Ref();
+}
+
+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
+  // all channel args declared thusly. This prevents us from accidentally not
+  // sharing subchannels due to their channel args not specifying a quota.
+  return args.SetObject(ResourceQuota::Default());
+}
+
+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() {
+  return grpc_core::ChannelArgTypeTraits<grpc_core::ResourceQuota>::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,43 @@
+// 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 <stddef.h>
+
+#include <grpc/impl/codegen/grpc_types.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 = 34 * 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,19 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/arena.h"
-
-#include <string.h>
+#include "src/core/lib/resource_quota/arena.h"
 
+#include <atomic>
 #include <new>
 
+#include "absl/utility/utility.h"
+
 #include <grpc/support/alloc.h>
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
 
 #include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gprpp/memory.h"
 
 namespace {
 
@@ -55,28 +52,40 @@ Arena::~Arena() {
   Zone* z = last_zone_;
   while (z) {
     Zone* prev_z = z->prev;
-    z->~Zone();
+    Destruct(z);
     gpr_free_aligned(z);
     z = prev_z;
   }
 }
 
-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() {
+  ManagedNewObject* p;
+  // Outer loop: clear the managed new object list.
+  // We do this repeatedly in case a destructor ends up allocating something.
+  while ((p = managed_new_head_.exchange(nullptr, std::memory_order_relaxed)) !=
+         nullptr) {
+    // Inner loop: destruct a batch of objects.
+    while (p != nullptr) {
+      Destruct(absl::exchange(p, p->next));
+    }
+  }
   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,14 +100,22 @@ 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;
 }
 
+void Arena::ManagedNewObject::Link(std::atomic<ManagedNewObject*>* head) {
+  next = head->load(std::memory_order_relaxed);
+  while (!head->compare_exchange_weak(next, this, std::memory_order_acq_rel,
+                                      std::memory_order_relaxed)) {
+  }
+}
+
 }  // namespace grpc_core