grpc 1.18.0 → 1.22.0

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

@@ -40,14 +40,6 @@ extern grpc_core::TraceFlag grpc_client_channel_trace;
 
 extern const grpc_channel_filter grpc_client_channel_filter;
 
-void grpc_client_channel_set_channelz_node(
-    grpc_channel_element* elem, grpc_core::channelz::ClientChannelNode* node);
-
-void grpc_client_channel_populate_child_refs(
-    grpc_channel_element* elem,
-    grpc_core::channelz::ChildRefsList* child_subchannels,
-    grpc_core::channelz::ChildRefsList* child_channels);
-
 grpc_connectivity_state grpc_client_channel_check_connectivity_state(
     grpc_channel_element* elem, int try_to_connect);
 
@@ -60,7 +52,7 @@ void grpc_client_channel_watch_connectivity_state(
     grpc_closure* watcher_timer_init);
 
 /* Debug helper: pull the subchannel call from a call stack element */
-grpc_subchannel_call* grpc_client_channel_get_subchannel_call(
-    grpc_call_element* elem);
+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_channelz.cc

@@ -29,96 +29,12 @@
 
 namespace grpc_core {
 namespace channelz {
-namespace {
 
-void* client_channel_channelz_copy(void* p) { return p; }
-
-void client_channel_channelz_destroy(void* p) {}
-
-int client_channel_channelz_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
-
-}  // namespace
-
-static const grpc_arg_pointer_vtable client_channel_channelz_vtable = {
-    client_channel_channelz_copy, client_channel_channelz_destroy,
-    client_channel_channelz_cmp};
-
-ClientChannelNode::ClientChannelNode(grpc_channel* channel,
-                                     size_t channel_tracer_max_nodes,
-                                     bool is_top_level_channel)
-    : ChannelNode(channel, channel_tracer_max_nodes, is_top_level_channel) {
-  client_channel_ =
-      grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
-  grpc_client_channel_set_channelz_node(client_channel_, this);
-  GPR_ASSERT(client_channel_->filter == &grpc_client_channel_filter);
-}
-
-void ClientChannelNode::PopulateConnectivityState(grpc_json* json) {
-  grpc_connectivity_state state;
-  if (ChannelIsDestroyed()) {
-    state = GRPC_CHANNEL_SHUTDOWN;
-  } else {
-    state =
-        grpc_client_channel_check_connectivity_state(client_channel_, false);
-  }
-  json = grpc_json_create_child(nullptr, json, "state", nullptr,
-                                GRPC_JSON_OBJECT, false);
-  grpc_json_create_child(nullptr, json, "state",
-                         grpc_connectivity_state_name(state), GRPC_JSON_STRING,
-                         false);
-}
-
-void ClientChannelNode::PopulateChildRefs(grpc_json* json) {
-  ChildRefsList child_subchannels;
-  ChildRefsList child_channels;
-  grpc_json* json_iterator = nullptr;
-  grpc_client_channel_populate_child_refs(client_channel_, &child_subchannels,
-                                          &child_channels);
-  if (!child_subchannels.empty()) {
-    grpc_json* array_parent = grpc_json_create_child(
-        nullptr, json, "subchannelRef", nullptr, GRPC_JSON_ARRAY, false);
-    for (size_t i = 0; i < child_subchannels.size(); ++i) {
-      json_iterator =
-          grpc_json_create_child(json_iterator, array_parent, nullptr, nullptr,
-                                 GRPC_JSON_OBJECT, false);
-      grpc_json_add_number_string_child(json_iterator, nullptr, "subchannelId",
-                                        child_subchannels[i]);
-    }
-  }
-  if (!child_channels.empty()) {
-    grpc_json* array_parent = grpc_json_create_child(
-        nullptr, json, "channelRef", nullptr, GRPC_JSON_ARRAY, false);
-    json_iterator = nullptr;
-    for (size_t i = 0; i < child_channels.size(); ++i) {
-      json_iterator =
-          grpc_json_create_child(json_iterator, array_parent, nullptr, nullptr,
-                                 GRPC_JSON_OBJECT, false);
-      grpc_json_add_number_string_child(json_iterator, nullptr, "channelId",
-                                        child_channels[i]);
-    }
-  }
-}
-
-grpc_arg ClientChannelNode::CreateChannelArg() {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_CHANNELZ_CHANNEL_NODE_CREATION_FUNC),
-      reinterpret_cast<void*>(MakeClientChannelNode),
-      &client_channel_channelz_vtable);
-}
-
-RefCountedPtr<ChannelNode> ClientChannelNode::MakeClientChannelNode(
-    grpc_channel* channel, size_t channel_tracer_max_nodes,
-    bool is_top_level_channel) {
-  return MakeRefCounted<ClientChannelNode>(channel, channel_tracer_max_nodes,
-                                           is_top_level_channel);
-}
-
-SubchannelNode::SubchannelNode(grpc_subchannel* subchannel,
+SubchannelNode::SubchannelNode(Subchannel* subchannel,
                                size_t channel_tracer_max_nodes)
     : BaseNode(EntityType::kSubchannel),
       subchannel_(subchannel),
-      target_(
-          UniquePtr<char>(gpr_strdup(grpc_subchannel_get_target(subchannel_)))),
+      target_(UniquePtr<char>(gpr_strdup(subchannel_->GetTargetAddress()))),
       trace_(channel_tracer_max_nodes) {}
 
 SubchannelNode::~SubchannelNode() {}
@@ -128,8 +44,9 @@ void SubchannelNode::PopulateConnectivityState(grpc_json* json) {
   if (subchannel_ == nullptr) {
     state = GRPC_CHANNEL_SHUTDOWN;
   } else {
-    state = grpc_subchannel_check_connectivity(
-        subchannel_, nullptr, true /* inhibit_health_checking */);
+    state = subchannel_->CheckConnectivityState(
+        nullptr /* health_check_service_name */,
+        nullptr /* connected_subchannel */);
   }
   json = grpc_json_create_child(nullptr, json, "state", nullptr,
                                 GRPC_JSON_OBJECT, false);
@@ -170,7 +87,7 @@ grpc_json* SubchannelNode::RenderJson() {
   call_counter_.PopulateCallCounts(json);
   json = top_level_json;
   // populate the child socket.
-  intptr_t socket_uuid = grpc_subchannel_get_child_socket_uuid(subchannel_);
+  intptr_t socket_uuid = subchannel_->GetChildSocketUuid();
   if (socket_uuid != 0) {
     grpc_json* array_parent = grpc_json_create_child(
         nullptr, json, "socketRef", nullptr, GRPC_JSON_ARRAY, false);

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

@@ -26,40 +26,15 @@
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 
-typedef struct grpc_subchannel grpc_subchannel;
-
 namespace grpc_core {
-namespace channelz {
-
-// Subtype of ChannelNode that overrides and provides client_channel specific
-// functionality like querying for connectivity_state and subchannel data.
-class ClientChannelNode : public ChannelNode {
- public:
-  static RefCountedPtr<ChannelNode> MakeClientChannelNode(
-      grpc_channel* channel, size_t channel_tracer_max_nodes,
-      bool is_top_level_channel);
 
-  ClientChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes,
-                    bool is_top_level_channel);
-  virtual ~ClientChannelNode() {}
+class Subchannel;
 
-  // Overriding template methods from ChannelNode to render information that
-  // only ClientChannelNode knows about.
-  void PopulateConnectivityState(grpc_json* json) override;
-  void PopulateChildRefs(grpc_json* json) override;
-
-  // Helper to create a channel arg to ensure this type of ChannelNode is
-  // created.
-  static grpc_arg CreateChannelArg();
-
- private:
-  grpc_channel_element* client_channel_;
-};
+namespace channelz {
 
-// Handles channelz bookkeeping for sockets
 class SubchannelNode : public BaseNode {
  public:
-  SubchannelNode(grpc_subchannel* subchannel, size_t channel_tracer_max_nodes);
+  SubchannelNode(Subchannel* subchannel, size_t channel_tracer_max_nodes);
   ~SubchannelNode() override;
 
   void MarkSubchannelDestroyed() {
@@ -70,11 +45,11 @@ class SubchannelNode : public BaseNode {
   grpc_json* RenderJson() override;
 
   // proxy methods to composed classes.
-  void AddTraceEvent(ChannelTrace::Severity severity, grpc_slice data) {
+  void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
     trace_.AddTraceEvent(severity, data);
   }
   void AddTraceEventWithReference(ChannelTrace::Severity severity,
-                                  grpc_slice data,
+                                  const grpc_slice& data,
                                   RefCountedPtr<BaseNode> referenced_channel) {
     trace_.AddTraceEventWithReference(severity, data,
                                       std::move(referenced_channel));
@@ -84,12 +59,12 @@ class SubchannelNode : public BaseNode {
   void RecordCallSucceeded() { call_counter_.RecordCallSucceeded(); }
 
  private:
-  grpc_subchannel* subchannel_;
+  void PopulateConnectivityState(grpc_json* json);
+
+  Subchannel* subchannel_;
   UniquePtr<char> target_;
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
-
-  void PopulateConnectivityState(grpc_json* json);
 };
 
 }  // namespace channelz

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

@@ -21,47 +21,35 @@
 #include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/lib/channel/channel_args.h"
 
-void grpc_client_channel_factory_ref(grpc_client_channel_factory* factory) {
-  factory->vtable->ref(factory);
-}
+// Channel arg key for client channel factory.
+#define GRPC_ARG_CLIENT_CHANNEL_FACTORY "grpc.client_channel_factory"
 
-void grpc_client_channel_factory_unref(grpc_client_channel_factory* factory) {
-  factory->vtable->unref(factory);
-}
+namespace grpc_core {
 
-grpc_subchannel* grpc_client_channel_factory_create_subchannel(
-    grpc_client_channel_factory* factory, const grpc_subchannel_args* args) {
-  return factory->vtable->create_subchannel(factory, args);
-}
+namespace {
 
-grpc_channel* grpc_client_channel_factory_create_channel(
-    grpc_client_channel_factory* factory, const char* target,
-    grpc_client_channel_type type, const grpc_channel_args* args) {
-  return factory->vtable->create_client_channel(factory, target, type, args);
+void* factory_arg_copy(void* f) { return f; }
+void factory_arg_destroy(void* f) {}
+int factory_arg_cmp(void* factory1, void* factory2) {
+  return GPR_ICMP(factory1, factory2);
 }
+const grpc_arg_pointer_vtable factory_arg_vtable = {
+    factory_arg_copy, factory_arg_destroy, factory_arg_cmp};
 
-static void* factory_arg_copy(void* factory) {
-  grpc_client_channel_factory_ref(
-      static_cast<grpc_client_channel_factory*>(factory));
-  return factory;
-}
+}  // namespace
 
-static void factory_arg_destroy(void* factory) {
-  grpc_client_channel_factory_unref(
-      static_cast<grpc_client_channel_factory*>(factory));
+grpc_arg ClientChannelFactory::CreateChannelArg(ClientChannelFactory* factory) {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_CLIENT_CHANNEL_FACTORY), factory,
+      &factory_arg_vtable);
 }
 
-static int factory_arg_cmp(void* factory1, void* factory2) {
-  if (factory1 < factory2) return -1;
-  if (factory1 > factory2) return 1;
-  return 0;
+ClientChannelFactory* ClientChannelFactory::GetFromChannelArgs(
+    const grpc_channel_args* args) {
+  const grpc_arg* arg =
+      grpc_channel_args_find(args, GRPC_ARG_CLIENT_CHANNEL_FACTORY);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
+  return static_cast<ClientChannelFactory*>(arg->value.pointer.p);
 }
 
-static const grpc_arg_pointer_vtable factory_arg_vtable = {
-    factory_arg_copy, factory_arg_destroy, factory_arg_cmp};
-
-grpc_arg grpc_client_channel_factory_create_channel_arg(
-    grpc_client_channel_factory* factory) {
-  return grpc_channel_arg_pointer_create((char*)GRPC_ARG_CLIENT_CHANNEL_FACTORY,
-                                         factory, &factory_arg_vtable);
-}
+}  // namespace grpc_core

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

@@ -24,51 +24,32 @@
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gprpp/abstract.h"
 
-// Channel arg key for client channel factory.
-#define GRPC_ARG_CLIENT_CHANNEL_FACTORY "grpc.client_channel_factory"
+namespace grpc_core {
 
-typedef struct grpc_client_channel_factory grpc_client_channel_factory;
-typedef struct grpc_client_channel_factory_vtable
-    grpc_client_channel_factory_vtable;
+class ClientChannelFactory {
+ public:
+  virtual ~ClientChannelFactory() = default;
 
-typedef enum {
-  GRPC_CLIENT_CHANNEL_TYPE_REGULAR, /** for the user-level regular calls */
-  GRPC_CLIENT_CHANNEL_TYPE_LOAD_BALANCING, /** for communication with a load
-                                              balancing service */
-} grpc_client_channel_type;
+  // Creates a subchannel with the specified args.
+  virtual Subchannel* CreateSubchannel(const grpc_channel_args* args)
+      GRPC_ABSTRACT;
 
-/** Constructor for new configured channels.
-    Creating decorators around this type is encouraged to adapt behavior. */
-struct grpc_client_channel_factory {
-  const grpc_client_channel_factory_vtable* vtable;
-};
-
-struct grpc_client_channel_factory_vtable {
-  void (*ref)(grpc_client_channel_factory* factory);
-  void (*unref)(grpc_client_channel_factory* factory);
-  grpc_subchannel* (*create_subchannel)(grpc_client_channel_factory* factory,
-                                        const grpc_subchannel_args* args);
-  grpc_channel* (*create_client_channel)(grpc_client_channel_factory* factory,
-                                         const char* target,
-                                         grpc_client_channel_type type,
-                                         const grpc_channel_args* args);
-};
+  // Creates a channel for the specified target with the specified args.
+  virtual grpc_channel* CreateChannel(
+      const char* target, const grpc_channel_args* args) GRPC_ABSTRACT;
 
-void grpc_client_channel_factory_ref(grpc_client_channel_factory* factory);
-void grpc_client_channel_factory_unref(grpc_client_channel_factory* factory);
+  // Returns a channel arg containing the specified factory.
+  static grpc_arg CreateChannelArg(ClientChannelFactory* factory);
 
-/** Create a new grpc_subchannel */
-grpc_subchannel* grpc_client_channel_factory_create_subchannel(
-    grpc_client_channel_factory* factory, const grpc_subchannel_args* args);
+  // Returns the factory from args, or null if not found.
+  static ClientChannelFactory* GetFromChannelArgs(
+      const grpc_channel_args* args);
 
-/** Create a new grpc_channel */
-grpc_channel* grpc_client_channel_factory_create_channel(
-    grpc_client_channel_factory* factory, const char* target,
-    grpc_client_channel_type type, const grpc_channel_args* args);
+  GRPC_ABSTRACT_BASE_CLASS
+};
 
-grpc_arg grpc_client_channel_factory_create_channel_arg(
-    grpc_client_channel_factory* factory);
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H */

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

@@ -24,48 +24,46 @@
 
 #include <grpc/support/alloc.h>
 
+#include "src/core/ext/filters/client_channel/backup_poller.h"
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
+#include "src/core/ext/filters/client_channel/global_subchannel_pool.h"
 #include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
 #include "src/core/ext/filters/client_channel/http_proxy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
-#include "src/core/ext/filters/client_channel/subchannel_index.h"
 #include "src/core/lib/surface/channel_init.h"
 
 static bool append_filter(grpc_channel_stack_builder* builder, void* arg) {
-  const grpc_channel_args* args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
-  grpc_arg args_to_add[] = {
-      grpc_core::channelz::ClientChannelNode::CreateChannelArg()};
-  grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
-      args, args_to_add, GPR_ARRAY_SIZE(args_to_add));
-  grpc_channel_stack_builder_set_channel_arguments(builder, new_args);
-  grpc_channel_args_destroy(new_args);
   return grpc_channel_stack_builder_append_filter(
       builder, static_cast<const grpc_channel_filter*>(arg), nullptr, nullptr);
 }
 
 void grpc_client_channel_init(void) {
+  grpc_core::ServiceConfig::Init();
+  grpc_core::internal::ClientChannelServiceConfigParser::Register();
   grpc_core::LoadBalancingPolicyRegistry::Builder::InitRegistry();
   grpc_core::ResolverRegistry::Builder::InitRegistry();
   grpc_core::internal::ServerRetryThrottleMap::Init();
   grpc_proxy_mapper_registry_init();
   grpc_register_http_proxy_mapper();
-  grpc_subchannel_index_init();
+  grpc_core::GlobalSubchannelPool::Init();
   grpc_channel_init_register_stage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, append_filter,
       (void*)&grpc_client_channel_filter);
   grpc_http_connect_register_handshaker_factory();
+  grpc_client_channel_global_init_backup_polling();
 }
 
 void grpc_client_channel_shutdown(void) {
-  grpc_subchannel_index_shutdown();
+  grpc_core::GlobalSubchannelPool::Shutdown();
   grpc_channel_init_shutdown();
   grpc_proxy_mapper_registry_shutdown();
   grpc_core::internal::ServerRetryThrottleMap::Shutdown();
   grpc_core::ResolverRegistry::Builder::ShutdownRegistry();
   grpc_core::LoadBalancingPolicyRegistry::Builder::ShutdownRegistry();
+  grpc_core::ServiceConfig::Shutdown();
 }

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

@@ -0,0 +1,179 @@
+//
+//
+// Copyright 2018 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/global_subchannel_pool.h"
+
+#include "src/core/ext/filters/client_channel/subchannel.h"
+
+namespace grpc_core {
+
+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>());
+}
+
+void GlobalSubchannelPool::Shutdown() {
+  // To ensure Init() was called before.
+  GPR_ASSERT(instance_ != nullptr);
+  // To ensure Shutdown() was not called before.
+  GPR_ASSERT(*instance_ != nullptr);
+  instance_->reset();
+  Delete(instance_);
+}
+
+RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
+  GPR_ASSERT(instance_ != nullptr);
+  GPR_ASSERT(*instance_ != nullptr);
+  return *instance_;
+}
+
+Subchannel* GlobalSubchannelPool::RegisterSubchannel(SubchannelKey* key,
+                                                     Subchannel* constructed) {
+  Subchannel* c = nullptr;
+  // Compare and swap (CAS) loop:
+  while (c == nullptr) {
+    // 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 failed, so retry CAS loop.
+    } 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);
+  }
+}
+
+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;
+}
+
+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* scv_avl_copy(void* p, void* unused) {
+  GRPC_SUBCHANNEL_WEAK_REF((Subchannel*)p, "global_subchannel_pool");
+  return p;
+}
+
+}  // 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

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

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2018 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_GLOBAL_SUBCHANNEL_POOL_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
+
+namespace grpc_core {
+
+// The global subchannel pool. It shares subchannels among channels. There
+// should be only one instance of this class. Init() should be called once at
+// the filter initialization time; Shutdown() should be called once at the
+// filter shutdown time.
+// TODO(juanlishen): Enable subchannel retention.
+class GlobalSubchannelPool final : public SubchannelPoolInterface {
+ public:
+  // The ctor and dtor are not intended to use directly.
+  GlobalSubchannelPool();
+  ~GlobalSubchannelPool() override;
+
+  // Should be called exactly once at filter initialization time.
+  static void Init();
+  // Should be called exactly once at filter shutdown time.
+  static void Shutdown();
+
+  // Gets the singleton instance.
+  static RefCountedPtr<GlobalSubchannelPool> instance();
+
+  // Implements interface methods.
+  Subchannel* RegisterSubchannel(SubchannelKey* key,
+                                 Subchannel* constructed) override;
+  void UnregisterSubchannel(SubchannelKey* key) override;
+  Subchannel* FindSubchannel(SubchannelKey* key) override;
+
+ private:
+  // The singleton instance. (It's a pointer to RefCountedPtr so that this
+  // non-local static object can be trivially destructible.)
+  static RefCountedPtr<GlobalSubchannelPool>* instance_;
+
+  // The vtable for subchannel operations in an AVL tree.
+  static const grpc_avl_vtable subchannel_avl_vtable_;
+  // A map from subchannel key to subchannel.
+  grpc_avl subchannel_map_;
+  // To protect subchannel_map_.
+  gpr_mu mu_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H */