grpc 1.33.0.pre1 → 1.37.0.pre1

data/src/core/ext/filters/client_channel/client_channel.h

@@ -26,8 +26,6 @@
 #include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/channel/channel_stack.h"
 
-extern grpc_core::TraceFlag grpc_client_channel_trace;
-
 // Channel arg key for server URI string.
 #define GRPC_ARG_SERVER_URI "grpc.server_uri"
 
@@ -75,8 +73,4 @@ void grpc_client_channel_stop_connectivity_watch(
     grpc_channel_element* elem,
     grpc_core::AsyncConnectivityStateWatcherInterface* watcher);
 
-/* Debug helper: pull the subchannel call from a call stack element */
-grpc_core::RefCountedPtr<grpc_core::SubchannelCall>
-grpc_client_channel_get_subchannel_call(grpc_call_element* elem);
-
 #endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_H

data/src/core/ext/filters/client_channel/client_channel_factory.h

@@ -32,7 +32,8 @@ class ClientChannelFactory {
   virtual ~ClientChannelFactory() = default;
 
   // Creates a subchannel with the specified args.
-  virtual Subchannel* CreateSubchannel(const grpc_channel_args* args) = 0;
+  virtual RefCountedPtr<Subchannel> CreateSubchannel(
+      const grpc_channel_args* args) = 0;
 
   // Returns a channel arg containing the specified factory.
   static grpc_arg CreateChannelArg(ClientChannelFactory* factory);

data/src/core/ext/filters/client_channel/client_channel_plugin.cc

@@ -54,7 +54,7 @@ void grpc_client_channel_init(void) {
   grpc_core::GlobalSubchannelPool::Init();
   grpc_channel_init_register_stage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, append_filter,
-      (void*)&grpc_client_channel_filter);
+      const_cast<grpc_channel_filter*>(&grpc_client_channel_filter));
   grpc_http_connect_register_handshaker_factory();
   grpc_client_channel_global_init_backup_polling();
 }

data/src/core/ext/filters/client_channel/config_selector.h

@@ -21,14 +21,15 @@
 
 #include <functional>
 #include <map>
+#include <vector>
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/slice.h>
+#include <grpc/grpc.h>
 
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_parser.h"
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -66,7 +67,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
     std::function<void()> on_call_committed;
   };
 
-  virtual ~ConfigSelector() = default;
+  ~ConfigSelector() override = default;
 
   virtual const char* name() const = 0;
 
@@ -81,6 +82,16 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
     return cs1->Equals(cs2);
   }
 
+  // The channel will call this when the resolver returns a new ConfigSelector
+  // to determine what set of dynamic filters will be configured.
+  virtual std::vector<const grpc_channel_filter*> GetFilters() { return {}; }
+
+  // Modifies channel args to be passed to the dynamic filter stack.
+  // Takes ownership of argument.  Caller takes ownership of result.
+  virtual grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) {
+    return args;
+  }
+
   virtual CallConfig GetCallConfig(GetCallConfigArgs args) = 0;
 
   grpc_arg MakeChannelArg() const;
@@ -103,7 +114,7 @@ class DefaultConfigSelector : public ConfigSelector {
 
   // Only comparing the ConfigSelector itself, not the underlying
   // service config, so we always return true.
-  bool Equals(const ConfigSelector* other) const override { return true; }
+  bool Equals(const ConfigSelector* /*other*/) const override { return true; }
 
   CallConfig GetCallConfig(GetCallConfigArgs args) override {
     CallConfig call_config;

data/src/core/ext/filters/client_channel/dynamic_filters.cc

@@ -0,0 +1,191 @@
+//
+// Copyright 2020 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/ext/filters/client_channel/dynamic_filters.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/surface/lame_client.h"
+
+// Conversion between call and call stack.
+#define CALL_TO_CALL_STACK(call)                                     \
+  (grpc_call_stack*)((char*)(call) + GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \
+                                         sizeof(DynamicFilters::Call)))
+#define CALL_STACK_TO_CALL(callstack)                     \
+  (DynamicFilters::Call*)(((char*)(call_stack)) -         \
+                          GPR_ROUND_UP_TO_ALIGNMENT_SIZE( \
+                              sizeof(DynamicFilters::Call)))
+
+namespace grpc_core {
+
+//
+// DynamicFilters::Call
+//
+
+DynamicFilters::Call::Call(Args args, grpc_error** error)
+    : channel_stack_(std::move(args.channel_stack)) {
+  grpc_call_stack* call_stack = CALL_TO_CALL_STACK(this);
+  const grpc_call_element_args call_args = {
+      call_stack,        /* call_stack */
+      nullptr,           /* server_transport_data */
+      args.context,      /* context */
+      args.path,         /* path */
+      args.start_time,   /* start_time */
+      args.deadline,     /* deadline */
+      args.arena,        /* arena */
+      args.call_combiner /* call_combiner */
+  };
+  *error = grpc_call_stack_init(channel_stack_->channel_stack_, 1, Destroy,
+                                this, &call_args);
+  if (GPR_UNLIKELY(*error != GRPC_ERROR_NONE)) {
+    const char* error_string = grpc_error_string(*error);
+    gpr_log(GPR_ERROR, "error: %s", error_string);
+    return;
+  }
+  grpc_call_stack_set_pollset_or_pollset_set(call_stack, args.pollent);
+}
+
+void DynamicFilters::Call::StartTransportStreamOpBatch(
+    grpc_transport_stream_op_batch* batch) {
+  grpc_call_stack* call_stack = CALL_TO_CALL_STACK(this);
+  grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
+  GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
+  top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
+}
+
+void DynamicFilters::Call::SetAfterCallStackDestroy(grpc_closure* closure) {
+  GPR_ASSERT(after_call_stack_destroy_ == nullptr);
+  GPR_ASSERT(closure != nullptr);
+  after_call_stack_destroy_ = closure;
+}
+
+RefCountedPtr<DynamicFilters::Call> DynamicFilters::Call::Ref() {
+  IncrementRefCount();
+  return RefCountedPtr<DynamicFilters::Call>(this);
+}
+
+RefCountedPtr<DynamicFilters::Call> DynamicFilters::Call::Ref(
+    const grpc_core::DebugLocation& location, const char* reason) {
+  IncrementRefCount(location, reason);
+  return RefCountedPtr<DynamicFilters::Call>(this);
+}
+
+void DynamicFilters::Call::Unref() {
+  GRPC_CALL_STACK_UNREF(CALL_TO_CALL_STACK(this), "");
+}
+
+void DynamicFilters::Call::Unref(const DebugLocation& /*location*/,
+                                 const char* reason) {
+  GRPC_CALL_STACK_UNREF(CALL_TO_CALL_STACK(this), reason);
+}
+
+void DynamicFilters::Call::Destroy(void* arg, grpc_error* /*error*/) {
+  DynamicFilters::Call* self = static_cast<DynamicFilters::Call*>(arg);
+  // Keep some members before destroying the subchannel call.
+  grpc_closure* after_call_stack_destroy = self->after_call_stack_destroy_;
+  RefCountedPtr<DynamicFilters> channel_stack = std::move(self->channel_stack_);
+  // Destroy the subchannel call.
+  self->~Call();
+  // Destroy the call stack. This should be after destroying the call, because
+  // call->after_call_stack_destroy(), if not null, will free the call arena.
+  grpc_call_stack_destroy(CALL_TO_CALL_STACK(self), nullptr,
+                          after_call_stack_destroy);
+  // Automatically reset channel_stack. This should be after destroying the call
+  // stack, because destroying call stack needs access to the channel stack.
+}
+
+void DynamicFilters::Call::IncrementRefCount() {
+  GRPC_CALL_STACK_REF(CALL_TO_CALL_STACK(this), "");
+}
+
+void DynamicFilters::Call::IncrementRefCount(
+    const grpc_core::DebugLocation& /*location*/, const char* reason) {
+  GRPC_CALL_STACK_REF(CALL_TO_CALL_STACK(this), reason);
+}
+
+//
+// DynamicFilters
+//
+
+namespace {
+
+void DestroyChannelStack(void* arg, grpc_error* /*error*/) {
+  grpc_channel_stack* channel_stack = static_cast<grpc_channel_stack*>(arg);
+  grpc_channel_stack_destroy(channel_stack);
+  gpr_free(channel_stack);
+}
+
+std::pair<grpc_channel_stack*, grpc_error*> CreateChannelStack(
+    const grpc_channel_args* args,
+    std::vector<const grpc_channel_filter*> filters) {
+  // Allocate memory for channel stack.
+  const size_t channel_stack_size =
+      grpc_channel_stack_size(filters.data(), filters.size());
+  grpc_channel_stack* channel_stack =
+      reinterpret_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
+  // Initialize stack.
+  grpc_error* error = grpc_channel_stack_init(
+      /*initial_refs=*/1, DestroyChannelStack, channel_stack, filters.data(),
+      filters.size(), args, /*optional_transport=*/nullptr, "DynamicFilters",
+      channel_stack);
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "error initializing client internal stack: %s",
+            grpc_error_string(error));
+    grpc_channel_stack_destroy(channel_stack);
+    gpr_free(channel_stack);
+    return {nullptr, error};
+  }
+  return {channel_stack, GRPC_ERROR_NONE};
+}
+
+}  // namespace
+
+RefCountedPtr<DynamicFilters> DynamicFilters::Create(
+    const grpc_channel_args* args,
+    std::vector<const grpc_channel_filter*> filters) {
+  // Attempt to create channel stack from requested filters.
+  auto p = CreateChannelStack(args, std::move(filters));
+  if (p.second != GRPC_ERROR_NONE) {
+    // Channel stack creation failed with requested filters.
+    // Create with lame filter instead.
+    grpc_error* error = p.second;
+    grpc_arg error_arg = MakeLameClientErrorArg(error);
+    grpc_channel_args* new_args =
+        grpc_channel_args_copy_and_add(args, &error_arg, 1);
+    GRPC_ERROR_UNREF(error);
+    p = CreateChannelStack(new_args, {&grpc_lame_filter});
+    GPR_ASSERT(p.second == GRPC_ERROR_NONE);
+    grpc_channel_args_destroy(new_args);
+  }
+  return MakeRefCounted<DynamicFilters>(p.first);
+}
+
+DynamicFilters::~DynamicFilters() {
+  GRPC_CHANNEL_STACK_UNREF(channel_stack_, "~DynamicFilters");
+}
+
+RefCountedPtr<DynamicFilters::Call> DynamicFilters::CreateCall(
+    DynamicFilters::Call::Args args, grpc_error** error) {
+  size_t allocation_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Call)) +
+                           channel_stack_->call_stack_size;
+  Call* call = static_cast<Call*>(args.arena->Alloc(allocation_size));
+  new (call) Call(std::move(args), error);
+  return call;
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/dynamic_filters.h

@@ -0,0 +1,99 @@
+//
+// Copyright 2020 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_DYNAMIC_FILTERS_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_DYNAMIC_FILTERS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <vector>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/arena.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+
+namespace grpc_core {
+
+class DynamicFilters : public RefCounted<DynamicFilters> {
+ public:
+  // Implements the interface of RefCounted<>.
+  class Call {
+   public:
+    struct Args {
+      RefCountedPtr<DynamicFilters> channel_stack;
+      grpc_polling_entity* pollent;
+      grpc_slice path;
+      gpr_cycle_counter start_time;
+      grpc_millis deadline;
+      Arena* arena;
+      grpc_call_context_element* context;
+      CallCombiner* call_combiner;
+    };
+
+    Call(Args args, grpc_error** error);
+
+    // Continues processing a transport stream op batch.
+    void StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch);
+
+    // Sets the 'then_schedule_closure' argument for call stack destruction.
+    // Must be called once per call.
+    void SetAfterCallStackDestroy(grpc_closure* closure);
+
+    // Interface of RefCounted<>.
+    RefCountedPtr<Call> Ref() GRPC_MUST_USE_RESULT;
+    RefCountedPtr<Call> Ref(const DebugLocation& location,
+                            const char* reason) GRPC_MUST_USE_RESULT;
+    // When refcount drops to 0, destroys itself and the associated call stack,
+    // but does NOT free the memory because it's in the call arena.
+    void Unref();
+    void Unref(const DebugLocation& location, const char* reason);
+
+   private:
+    // Allow RefCountedPtr<> to access IncrementRefCount().
+    template <typename T>
+    friend class RefCountedPtr;
+
+    // Interface of RefCounted<>.
+    void IncrementRefCount();
+    void IncrementRefCount(const DebugLocation& location, const char* reason);
+
+    static void Destroy(void* arg, grpc_error* error);
+
+    RefCountedPtr<DynamicFilters> channel_stack_;
+    grpc_closure* after_call_stack_destroy_ = nullptr;
+  };
+
+  static RefCountedPtr<DynamicFilters> Create(
+      const grpc_channel_args* args,
+      std::vector<const grpc_channel_filter*> filters);
+
+  explicit DynamicFilters(grpc_channel_stack* channel_stack)
+      : channel_stack_(channel_stack) {}
+
+  ~DynamicFilters() override;
+
+  RefCountedPtr<Call> CreateCall(Call::Args args, grpc_error** error);
+
+ private:
+  grpc_channel_stack* channel_stack_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_DYNAMIC_FILTERS_H

data/src/core/ext/filters/client_channel/global_subchannel_pool.cc

@@ -27,16 +27,6 @@ namespace grpc_core {
 #define GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_AFTER_ATTEMPTS 100
 #define GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_MICROS 10
 
-GlobalSubchannelPool::GlobalSubchannelPool() {
-  subchannel_map_ = grpc_avl_create(&subchannel_avl_vtable_);
-  gpr_mu_init(&mu_);
-}
-
-GlobalSubchannelPool::~GlobalSubchannelPool() {
-  gpr_mu_destroy(&mu_);
-  grpc_avl_unref(subchannel_map_, nullptr);
-}
-
 void GlobalSubchannelPool::Init() {
   instance_ = new RefCountedPtr<GlobalSubchannelPool>(
       MakeRefCounted<GlobalSubchannelPool>());
@@ -57,145 +47,37 @@ RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
   return *instance_;
 }
 
-Subchannel* GlobalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
-                                                     Subchannel* constructed) {
-  Subchannel* c = nullptr;
-  // Compare and swap (CAS) loop:
-  for (int attempt_count = 0; c == nullptr; attempt_count++) {
-    // Ref the shared map to have a local copy.
-    gpr_mu_lock(&mu_);
-    grpc_avl old_map = grpc_avl_ref(subchannel_map_, nullptr);
-    gpr_mu_unlock(&mu_);
-    // Check to see if a subchannel already exists.
-    c = static_cast<Subchannel*>(grpc_avl_get(old_map, key, nullptr));
-    if (c != nullptr) {
-      // The subchannel already exists. Try to reuse it.
-      c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(c, "subchannel_register+reuse");
-      if (c != nullptr) {
-        GRPC_SUBCHANNEL_UNREF(constructed,
-                              "subchannel_register+found_existing");
-        // Exit the CAS loop without modifying the shared map.
-      } else {
-        // Reuse of the subchannel failed, so retry CAS loop
-        if (attempt_count >=
-            GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_AFTER_ATTEMPTS) {
-          // GRPC_SUBCHANNEL_REF_FROM_WEAK_REF returning nullptr means that the
-          // subchannel we got is no longer valid and it's going to be removed
-          // from the AVL tree soon. Spinning here excesively here can actually
-          // prevent another thread from removing the subchannel, basically
-          // resulting in a live lock. See b/157516542 for more details.
-          // TODO(jtattermusch): the entire ref-counting mechanism for
-          // subchannels should be overhaulded, but the current workaround
-          // is fine for short-term.
-          // TODO(jtattermusch): gpr does not support thread yield operation,
-          // so a very short wait is the best we can do.
-          gpr_sleep_until(gpr_time_add(
-              gpr_now(GPR_CLOCK_REALTIME),
-              gpr_time_from_micros(GRPC_REGISTER_SUBCHANNEL_CALM_DOWN_MICROS,
-                                   GPR_TIMESPAN)));
-        }
-      }
-    } else {
-      // There hasn't been such subchannel. Add one.
-      // Note that we should ref the old map first because grpc_avl_add() will
-      // unref it while we still need to access it later.
-      grpc_avl new_map = grpc_avl_add(
-          grpc_avl_ref(old_map, nullptr), new SubchannelKey(*key),
-          GRPC_SUBCHANNEL_WEAK_REF(constructed, "subchannel_register+new"),
-          nullptr);
-      // Try to publish the change to the shared map. It may happen (but
-      // unlikely) that some other thread has changed the shared map, so compare
-      // to make sure it's unchanged before swapping. Retry if it's changed.
-      gpr_mu_lock(&mu_);
-      if (old_map.root == subchannel_map_.root) {
-        GPR_SWAP(grpc_avl, new_map, subchannel_map_);
-        c = constructed;
-      }
-      gpr_mu_unlock(&mu_);
-      grpc_avl_unref(new_map, nullptr);
-    }
-    grpc_avl_unref(old_map, nullptr);
-  }
-  return c;
-}
-
-void GlobalSubchannelPool::UnregisterSubchannel(SubchannelKey* key) {
-  bool done = false;
-  // Compare and swap (CAS) loop:
-  while (!done) {
-    // Ref the shared map to have a local copy.
-    gpr_mu_lock(&mu_);
-    grpc_avl old_map = grpc_avl_ref(subchannel_map_, nullptr);
-    gpr_mu_unlock(&mu_);
-    // Remove the subchannel.
-    // Note that we should ref the old map first because grpc_avl_remove() will
-    // unref it while we still need to access it later.
-    grpc_avl new_map =
-        grpc_avl_remove(grpc_avl_ref(old_map, nullptr), key, nullptr);
-    // Try to publish the change to the shared map. It may happen (but
-    // unlikely) that some other thread has changed the shared map, so compare
-    // to make sure it's unchanged before swapping. Retry if it's changed.
-    gpr_mu_lock(&mu_);
-    if (old_map.root == subchannel_map_.root) {
-      GPR_SWAP(grpc_avl, new_map, subchannel_map_);
-      done = true;
-    }
-    gpr_mu_unlock(&mu_);
-    grpc_avl_unref(new_map, nullptr);
-    grpc_avl_unref(old_map, nullptr);
+RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
+    const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
+  MutexLock lock(&mu_);
+  auto it = subchannel_map_.find(key);
+  if (it != subchannel_map_.end()) {
+    RefCountedPtr<Subchannel> existing = it->second->RefIfNonZero();
+    if (existing != nullptr) return existing;
   }
-}
-
-Subchannel* GlobalSubchannelPool::FindSubchannel(SubchannelKey* key) {
-  // Lock, and take a reference to the subchannel map.
-  // We don't need to do the search under a lock as AVL's are immutable.
-  gpr_mu_lock(&mu_);
-  grpc_avl index = grpc_avl_ref(subchannel_map_, nullptr);
-  gpr_mu_unlock(&mu_);
-  Subchannel* c = static_cast<Subchannel*>(grpc_avl_get(index, key, nullptr));
-  if (c != nullptr) c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(c, "found_from_pool");
-  grpc_avl_unref(index, nullptr);
-  return c;
+  subchannel_map_[key] = constructed.get();
+  return constructed;
 }
 
 RefCountedPtr<GlobalSubchannelPool>* GlobalSubchannelPool::instance_ = nullptr;
 
-namespace {
-
-void sck_avl_destroy(void* p, void* /*user_data*/) {
-  SubchannelKey* key = static_cast<SubchannelKey*>(p);
-  delete key;
-}
-
-void* sck_avl_copy(void* p, void* /*unused*/) {
-  const SubchannelKey* key = static_cast<const SubchannelKey*>(p);
-  auto* new_key = new SubchannelKey(*key);
-  return static_cast<void*>(new_key);
-}
-
-long sck_avl_compare(void* a, void* b, void* /*unused*/) {
-  const SubchannelKey* key_a = static_cast<const SubchannelKey*>(a);
-  const SubchannelKey* key_b = static_cast<const SubchannelKey*>(b);
-  return key_a->Cmp(*key_b);
-}
-
-void scv_avl_destroy(void* p, void* /*user_data*/) {
-  GRPC_SUBCHANNEL_WEAK_UNREF((Subchannel*)p, "global_subchannel_pool");
+void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
+                                                Subchannel* subchannel) {
+  MutexLock lock(&mu_);
+  auto it = subchannel_map_.find(key);
+  // delete only if key hasn't been re-registered to a different subchannel
+  // between strong-unreffing and unregistration of subchannel.
+  if (it != subchannel_map_.end() && it->second == subchannel) {
+    subchannel_map_.erase(it);
+  }
 }
 
-void* scv_avl_copy(void* p, void* /*unused*/) {
-  GRPC_SUBCHANNEL_WEAK_REF((Subchannel*)p, "global_subchannel_pool");
-  return p;
+RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
+    const SubchannelKey& key) {
+  MutexLock lock(&mu_);
+  auto it = subchannel_map_.find(key);
+  if (it == subchannel_map_.end()) return nullptr;
+  return it->second->RefIfNonZero();
 }
 
-}  // namespace
-
-const grpc_avl_vtable GlobalSubchannelPool::subchannel_avl_vtable_ = {
-    sck_avl_destroy,  // destroy_key
-    sck_avl_copy,     // copy_key
-    sck_avl_compare,  // compare_keys
-    scv_avl_destroy,  // destroy_value
-    scv_avl_copy      // copy_value
-};
-
 }  // namespace grpc_core