grpc 1.75.0 → 1.78.1

data/src/core/client_channel/buffered_call.h

@@ -0,0 +1,104 @@
+//
+// 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_SRC_CORE_CLIENT_CHANNEL_BUFFERED_CALL_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_BUFFERED_CALL_H
+
+#include "src/core/call/metadata_batch.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "absl/functional/any_invocable.h"
+
+// Max number of batches that can be pending on a call at any given
+// time.  This includes one batch for each of the following ops:
+//   recv_initial_metadata
+//   send_initial_metadata
+//   recv_message
+//   send_message
+//   recv_trailing_metadata
+//   send_trailing_metadata
+#define MAX_PENDING_BATCHES 6
+
+namespace grpc_core {
+
+// Handles queuing of stream batches for a v1 call.
+class BufferedCall {
+ public:
+  BufferedCall(CallCombiner* call_combiner, TraceFlag* tracer);
+  ~BufferedCall();
+
+  // Enqueues a batch.
+  // Must be called from within the call combiner.
+  void EnqueueBatch(grpc_transport_stream_op_batch* batch);
+
+  // Resumes all queued batches by passing them to start_batch().
+  // Must be called from within the call combiner.
+  void Resume(
+      absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch);
+
+  // A predicate type and some useful implementations for Fail().
+  typedef bool (*YieldCallCombinerPredicate)(
+      const CallCombinerClosureList& closures);
+  static bool YieldCallCombiner(const CallCombinerClosureList& /*closures*/) {
+    return true;
+  }
+  static bool NoYieldCallCombiner(const CallCombinerClosureList& /*closures*/) {
+    return false;
+  }
+  static bool YieldCallCombinerIfPendingBatchesFound(
+      const CallCombinerClosureList& closures) {
+    return closures.size() > 0;
+  }
+  // Fails all queued batches.
+  // Must be called from within the call combiner.
+  // If yield_call_combiner_predicate returns true, assumes responsibility for
+  // yielding the call combiner.
+  void Fail(grpc_error_handle error,
+            YieldCallCombinerPredicate yield_call_combiner_predicate);
+
+  grpc_metadata_batch* send_initial_metadata() const {
+    return pending_batches_[0]
+        ->payload->send_initial_metadata.send_initial_metadata;
+  }
+
+ private:
+  // Returns the index into pending_batches_ to be used for batch.
+  static size_t GetBatchIndex(grpc_transport_stream_op_batch* batch);
+
+  static void FailPendingBatchInCallCombiner(void* arg,
+                                             grpc_error_handle error);
+  static void ResumePendingBatchInCallCombiner(void* arg,
+                                               grpc_error_handle ignored);
+
+  CallCombiner* const call_combiner_;
+  TraceFlag* tracer_;
+
+  // Batches are added to this list when received from above.
+  // They are removed when we are done handling the batch (i.e., when
+  // either we have invoked all of the batch's callbacks or we have
+  // passed the batch down to the next call and are not intercepting any of
+  // its callbacks).
+  grpc_transport_stream_op_batch* pending_batches_[MAX_PENDING_BATCHES] = {};
+
+  // A function that starts a batch on the next call.  Set by calling
+  // Resume().
+  absl::AnyInvocable<void(grpc_transport_stream_op_batch*)> start_batch_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_BUFFERED_CALL_H

data/src/core/client_channel/client_channel.cc

@@ -36,15 +36,6 @@
 #include <variant>
 #include <vector>
 
-#include "absl/cleanup/cleanup.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/call_spine.h"
 #include "src/core/call/client_call.h"
 #include "src/core/call/metadata_batch.h"
@@ -94,6 +85,15 @@
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
 #include "src/core/util/work_serializer.h"
+#include "absl/cleanup/cleanup.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -142,7 +142,8 @@ class ClientChannel::SubchannelWrapper
     : public SubchannelInterfaceWithCallDestination {
  public:
   SubchannelWrapper(WeakRefCountedPtr<ClientChannel> client_channel,
-                    RefCountedPtr<Subchannel> subchannel);
+                    RefCountedPtr<Subchannel> subchannel,
+                    uint32_t max_connections_per_subchannel);
   ~SubchannelWrapper() override;
 
   void Orphaned() override;
@@ -165,7 +166,6 @@ class ClientChannel::SubchannelWrapper
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*client_channel_->work_serializer_);
   void CancelDataWatcher(DataWatcherInterface* watcher) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*client_channel_->work_serializer_);
-  void ThrottleKeepaliveTime(int new_keepalive_time);
   std::string address() const override { return subchannel_->address(); }
 
  private:
@@ -191,6 +191,7 @@ class ClientChannel::SubchannelWrapper
 
   WeakRefCountedPtr<ClientChannel> client_channel_;
   RefCountedPtr<Subchannel> subchannel_;
+  const uint32_t max_connections_per_subchannel_;
   // Maps from the address of the watcher passed to us by the LB policy
   // to the address of the WrapperWatcher that we passed to the underlying
   // subchannel.  This is needed so that when the LB policy calls
@@ -220,7 +221,7 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
   WatcherWrapper(
       std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
           watcher,
-      RefCountedPtr<SubchannelWrapper> subchannel_wrapper)
+      WeakRefCountedPtr<SubchannelWrapper> subchannel_wrapper)
       : watcher_(std::move(watcher)),
         subchannel_wrapper_(std::move(subchannel_wrapper)) {}
 
@@ -233,9 +234,7 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
     GRPC_TRACE_LOG(client_channel, INFO)
         << "client_channel=" << subchannel_wrapper_->client_channel_.get()
         << ": connectivity change for subchannel wrapper "
-        << subchannel_wrapper_.get() << " subchannel "
-        << subchannel_wrapper_->subchannel_.get()
-        << "; hopping into work_serializer";
+        << subchannel_wrapper_.get() << "; hopping into work_serializer";
     auto self = RefAsSubclass<WatcherWrapper>();
     subchannel_wrapper_->client_channel_->work_serializer_->Run(
         [self, state, status]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
@@ -244,6 +243,23 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
         });
   }
 
+  void OnKeepaliveUpdate(Duration new_keepalive_time) override {
+    GRPC_TRACE_LOG(client_channel, INFO)
+        << "client_channel=" << subchannel_wrapper_->client_channel_.get()
+        << ": keepalive update for subchannel wrapper "
+        << subchannel_wrapper_.get() << "; hopping into work_serializer";
+    auto self = RefAsSubclass<WatcherWrapper>();
+    subchannel_wrapper_->client_channel_->work_serializer_->Run(
+        [self, new_keepalive_time]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
+            *self->subchannel_wrapper_->client_channel_->work_serializer_) {
+          self->ApplyKeepaliveThrottlingInWorkSerializer(new_keepalive_time);
+        });
+  }
+
+  uint32_t max_connections_per_subchannel() const override {
+    return subchannel_wrapper_->max_connections_per_subchannel_;
+  }
+
   grpc_pollset_set* interested_parties() override { return nullptr; }
 
  private:
@@ -259,32 +275,37 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
         << subchannel_wrapper_->subchannel_.get()
         << " watcher=" << watcher_.get()
         << " state=" << ConnectivityStateName(state) << " status=" << status;
-    auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
-    if (keepalive_throttling.has_value()) {
-      int new_keepalive_time = -1;
-      if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
-                           &new_keepalive_time)) {
-        if (new_keepalive_time >
-            subchannel_wrapper_->client_channel_->keepalive_time_) {
-          subchannel_wrapper_->client_channel_->keepalive_time_ =
-              new_keepalive_time;
-          GRPC_TRACE_LOG(client_channel, INFO)
-              << "client_channel=" << subchannel_wrapper_->client_channel_.get()
-              << ": throttling keepalive time to "
-              << subchannel_wrapper_->client_channel_->keepalive_time_;
-          // Propagate the new keepalive time to all subchannels. This is so
-          // that new transports created by any subchannel (and not just the
-          // subchannel that received the GOAWAY), use the new keepalive time.
-          for (auto* subchannel_wrapper :
-               subchannel_wrapper_->client_channel_->subchannel_wrappers_) {
-            subchannel_wrapper->ThrottleKeepaliveTime(new_keepalive_time);
+    if (!IsTransportStateWatcherEnabled()) {
+      auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
+      if (keepalive_throttling.has_value()) {
+        int new_keepalive_time_ms = -1;
+        if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
+                             &new_keepalive_time_ms)) {
+          Duration new_keepalive_time =
+              Duration::Milliseconds(new_keepalive_time_ms);
+          if (new_keepalive_time >
+              subchannel_wrapper_->client_channel_->keepalive_time_) {
+            subchannel_wrapper_->client_channel_->keepalive_time_ =
+                new_keepalive_time;
+            GRPC_TRACE_LOG(client_channel, INFO)
+                << "client_channel="
+                << subchannel_wrapper_->client_channel_.get()
+                << ": throttling keepalive time to "
+                << subchannel_wrapper_->client_channel_->keepalive_time_;
+            // Propagate the new keepalive time to all subchannels. This is so
+            // that new transports created by any subchannel (and not just the
+            // subchannel that received the GOAWAY), use the new keepalive time.
+            for (auto& [subchannel, _] :
+                 subchannel_wrapper_->client_channel_->subchannel_map_) {
+              subchannel->ThrottleKeepaliveTime(new_keepalive_time);
+            }
           }
+        } else {
+          LOG(ERROR) << "client_channel="
+                     << subchannel_wrapper_->client_channel_.get()
+                     << ": Illegal keepalive throttling value "
+                     << std::string(keepalive_throttling.value());
         }
-      } else {
-        LOG(ERROR) << "client_channel="
-                   << subchannel_wrapper_->client_channel_.get()
-                   << ": Illegal keepalive throttling value "
-                   << std::string(keepalive_throttling.value());
       }
     }
     // Propagate status only in state TF.
@@ -296,41 +317,61 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
         state == GRPC_CHANNEL_TRANSIENT_FAILURE ? status : absl::OkStatus());
   }
 
+  void ApplyKeepaliveThrottlingInWorkSerializer(Duration new_keepalive_time)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(
+          *subchannel_wrapper_->client_channel_->work_serializer_) {
+    if (new_keepalive_time >
+        subchannel_wrapper_->client_channel_->keepalive_time_) {
+      subchannel_wrapper_->client_channel_->keepalive_time_ =
+          new_keepalive_time;
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "client_channel=" << subchannel_wrapper_->client_channel_.get()
+          << ": throttling keepalive time to "
+          << subchannel_wrapper_->client_channel_->keepalive_time_;
+      // Propagate the new keepalive time to all subchannels. This is so
+      // that new transports created by any subchannel (and not just the
+      // subchannel that received the GOAWAY), use the new keepalive time.
+      for (auto& [subchannel, _] :
+           subchannel_wrapper_->client_channel_->subchannel_map_) {
+        if (subchannel_wrapper_->subchannel_ == subchannel) continue;
+        subchannel->ThrottleKeepaliveTime(new_keepalive_time);
+      }
+    }
+  }
+
   std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
       watcher_;
-  RefCountedPtr<SubchannelWrapper> subchannel_wrapper_;
+  WeakRefCountedPtr<SubchannelWrapper> subchannel_wrapper_;
 };
 
 ClientChannel::SubchannelWrapper::SubchannelWrapper(
     WeakRefCountedPtr<ClientChannel> client_channel,
-    RefCountedPtr<Subchannel> subchannel)
+    RefCountedPtr<Subchannel> subchannel,
+    uint32_t max_connections_per_subchannel)
     : SubchannelInterfaceWithCallDestination(
           GRPC_TRACE_FLAG_ENABLED(client_channel) ? "SubchannelWrapper"
                                                   : nullptr),
       client_channel_(std::move(client_channel)),
-      subchannel_(std::move(subchannel)) {
+      subchannel_(std::move(subchannel)),
+      max_connections_per_subchannel_(max_connections_per_subchannel) {
   GRPC_TRACE_LOG(client_channel, INFO)
       << "client_channel=" << client_channel_.get()
       << ": creating subchannel wrapper " << this << " for subchannel "
-      << subchannel_.get();
+      << subchannel_.get()
+      << ", max_connections_per_subchannel=" << max_connections_per_subchannel;
 #ifndef NDEBUG
   DCHECK(client_channel_->work_serializer_->RunningInWorkSerializer());
 #endif
-  if (client_channel_->channelz_node_ != nullptr) {
+  auto& subchannel_wrappers =
+      client_channel_->subchannel_map_[subchannel_.get()];
+  if (subchannel_wrappers.empty() &&
+      client_channel_->channelz_node_ != nullptr) {
     auto* subchannel_node = subchannel_->channelz_node();
     if (subchannel_node != nullptr) {
-      auto it =
-          client_channel_->subchannel_refcount_map_.find(subchannel_.get());
-      if (it == client_channel_->subchannel_refcount_map_.end()) {
-        subchannel_node->AddParent(client_channel_->channelz_node_);
-        it = client_channel_->subchannel_refcount_map_
-                 .emplace(subchannel_.get(), 0)
-                 .first;
-      }
-      ++it->second;
+      subchannel_node->AddParent(client_channel_->channelz_node_);
     }
   }
-  client_channel_->subchannel_wrappers_.insert(this);
+  subchannel_wrappers.insert(this);
 }
 
 ClientChannel::SubchannelWrapper::~SubchannelWrapper() {
@@ -348,20 +389,34 @@ void ClientChannel::SubchannelWrapper::Orphaned() {
   client_channel_->work_serializer_->Run(
       [self]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
           *self->client_channel_->work_serializer_) {
-        self->client_channel_->subchannel_wrappers_.erase(self.get());
-        if (self->client_channel_->channelz_node_ != nullptr) {
-          auto* subchannel_node = self->subchannel_->channelz_node();
-          if (subchannel_node != nullptr) {
-            auto it = self->client_channel_->subchannel_refcount_map_.find(
-                self->subchannel_.get());
-            CHECK(it != self->client_channel_->subchannel_refcount_map_.end());
-            --it->second;
-            if (it->second == 0) {
+        auto it = self->client_channel_->subchannel_map_.find(
+            self->subchannel_.get());
+        GRPC_CHECK(it != self->client_channel_->subchannel_map_.end());
+        auto& subchannel_wrappers = it->second;
+        subchannel_wrappers.erase(self.get());
+        if (subchannel_wrappers.empty()) {
+          if (self->client_channel_->channelz_node_ != nullptr) {
+            auto* subchannel_node = self->subchannel_->channelz_node();
+            if (subchannel_node != nullptr) {
               subchannel_node->RemoveParent(
                   self->client_channel_->channelz_node_);
-              self->client_channel_->subchannel_refcount_map_.erase(it);
             }
           }
+          self->client_channel_->subchannel_map_.erase(it);
+        }
+        if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
+          // We need to make sure that the internal subchannel gets unreffed
+          // inside of the WorkSerializer, so that updates to the local
+          // subchannel pool are properly synchronized.  To that end, we
+          // drop our ref to the internal subchannel here.  We also cancel
+          // any watchers that were not properly cancelled, in case any of
+          // them are holding a ref to the internal subchannel.
+          for (const auto& [_, watcher] : self->watcher_map_) {
+            self->subchannel_->CancelConnectivityStateWatch(watcher);
+          }
+          self->watcher_map_.clear();
+          self->data_watchers_.clear();
+          self->subchannel_.reset();
         }
       });
 }
@@ -372,7 +427,7 @@ void ClientChannel::SubchannelWrapper::WatchConnectivityState(
   CHECK(watcher_wrapper == nullptr);
   watcher_wrapper = new WatcherWrapper(
       std::move(watcher),
-      RefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
+      WeakRefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
   subchannel_->WatchConnectivityState(
       RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface>(
           watcher_wrapper));
@@ -399,11 +454,6 @@ void ClientChannel::SubchannelWrapper::CancelDataWatcher(
   if (it != data_watchers_.end()) data_watchers_.erase(it);
 }
 
-void ClientChannel::SubchannelWrapper::ThrottleKeepaliveTime(
-    int new_keepalive_time) {
-  subchannel_->ThrottleKeepaliveTime(new_keepalive_time);
-}
-
 //
 // ClientChannel::ClientChannelControlHelper
 //
@@ -425,6 +475,17 @@ class ClientChannel::ClientChannelControlHelper
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*client_channel_->work_serializer_) {
     // If shutting down, do nothing.
     if (client_channel_->resolver_ == nullptr) return nullptr;
+    // Determine max_connections_per_subchannel.
+    const uint32_t cap =
+        args.GetInt(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL_CAP).value_or(10);
+    uint32_t max_connections_per_subchannel =
+        args.GetInt(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
+            .value_or(
+                per_address_args.GetInt(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
+                    .value_or(1));
+    max_connections_per_subchannel =
+        std::min(max_connections_per_subchannel, cap);
+    // Modify args for subchannel.
     ChannelArgs subchannel_args = Subchannel::MakeSubchannelArgs(
         args, per_address_args, client_channel_->subchannel_pool_,
         client_channel_->default_authority_);
@@ -436,8 +497,8 @@ class ClientChannel::ClientChannelControlHelper
     // Make sure the subchannel has updated keepalive time.
     subchannel->ThrottleKeepaliveTime(client_channel_->keepalive_time_);
     // Create and return wrapper for the subchannel.
-    return MakeRefCounted<SubchannelWrapper>(client_channel_,
-                                             std::move(subchannel));
+    return MakeRefCounted<SubchannelWrapper>(
+        client_channel_, std::move(subchannel), max_connections_per_subchannel);
   }
 
   void UpdateState(
@@ -516,11 +577,7 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
   if (args.GetBool(GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL).value_or(false)) {
     return MakeRefCounted<LocalSubchannelPool>();
   }
-  if (IsShardGlobalConnectionPoolEnabled()) {
-    return GlobalSubchannelPool::instance();
-  } else {
-    return LegacyGlobalSubchannelPool::instance();
-  }
+  return GlobalSubchannelPool::instance();
 }
 
 }  // namespace
@@ -635,9 +692,7 @@ ClientChannel::ClientChannel(
   // Set initial keepalive time.
   auto keepalive_arg = channel_args_.GetInt(GRPC_ARG_KEEPALIVE_TIME_MS);
   if (keepalive_arg.has_value()) {
-    keepalive_time_ = Clamp(*keepalive_arg, 1, INT_MAX);
-  } else {
-    keepalive_time_ = -1;  // unset
+    keepalive_time_ = Duration::Milliseconds(Clamp(*keepalive_arg, 1, INT_MAX));
   }
 }
 
@@ -896,8 +951,7 @@ void ClientChannel::StartCall(UnstartedCallHandler unstarted_handler) {
               if (!status.ok()) return status;
               // If the call was queued, add trace annotation.
               if (was_queued) {
-                auto* call_tracer =
-                    MaybeGetContext<CallTracerAnnotationInterface>();
+                auto* call_tracer = MaybeGetContext<CallSpan>();
                 if (call_tracer != nullptr) {
                   call_tracer->RecordAnnotation(
                       "Delayed name resolution complete.");
@@ -1105,6 +1159,12 @@ void ClientChannel::OnResolverResultChangedLocked(Resolver::Result result) {
         static_cast<const internal::ClientChannelGlobalParsedConfig*>(
             service_config->GetGlobalParsedConfig(
                 service_config_parser_index_));
+    // Set max_connections_per_subchannel from service config.
+    if (parsed_service_config->max_connections_per_subchannel() != 0) {
+      result.args = result.args.Set(
+          GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL,
+          parsed_service_config->max_connections_per_subchannel());
+    }
     // Choose LB policy config.
     RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config =
         ChooseLbPolicy(result, parsed_service_config);
@@ -1280,7 +1340,7 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
   if (enable_retries) {
     RetryInterceptor::UpdateBlackboard(*saved_service_config_,
                                        blackboard_.get(), new_blackboard.get());
-    builder.Add<RetryInterceptor>();
+    builder.Add<RetryInterceptor>(nullptr);
   }
   blackboard_ = std::move(new_blackboard);
   // Create call destination.
@@ -1396,7 +1456,7 @@ absl::Status ClientChannel::ApplyServiceConfigToCall(
       const Timestamp per_method_deadline =
           Timestamp::FromCycleCounterRoundUp(call->start_time()) +
           method_params->timeout();
-      call->UpdateDeadline(per_method_deadline);
+      call->UpdateDeadline(per_method_deadline).IgnoreError();
     }
     // If the service config set wait_for_ready and the application
     // did not explicitly set it, use the value from the service config.

data/src/core/client_channel/client_channel.h

@@ -19,9 +19,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata.h"
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
@@ -34,6 +31,9 @@
 #include "src/core/resolver/resolver.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/util/single_set_ptr.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -222,15 +222,12 @@ class ClientChannel : public Channel {
       ABSL_GUARDED_BY(*work_serializer_);
   RefCountedPtr<SubchannelPoolInterface> subchannel_pool_
       ABSL_GUARDED_BY(*work_serializer_);
-  // The number of SubchannelWrapper instances referencing a given Subchannel.
-  std::map<Subchannel*, int> subchannel_refcount_map_
-      ABSL_GUARDED_BY(*work_serializer_);
-  // The set of SubchannelWrappers that currently exist.
-  // No need to hold a ref, since the set is updated in the control-plane
+  // The set of SubchannelWrapper instances referencing a given Subchannel.
+  // No need to hold refs, since the map is updated in the control-plane
   // work_serializer when the SubchannelWrappers are created and destroyed.
-  absl::flat_hash_set<SubchannelWrapper*> subchannel_wrappers_
-      ABSL_GUARDED_BY(*work_serializer_);
-  int keepalive_time_ ABSL_GUARDED_BY(*work_serializer_) = -1;
+  absl::flat_hash_map<Subchannel*, absl::flat_hash_set<SubchannelWrapper*>>
+      subchannel_map_ ABSL_GUARDED_BY(*work_serializer_);
+  Duration keepalive_time_ ABSL_GUARDED_BY(*work_serializer_);
   absl::Status disconnect_error_ ABSL_GUARDED_BY(*work_serializer_);
 
   //

data/src/core/client_channel/client_channel_factory.h

@@ -19,11 +19,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/string_view.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {