grpc 1.41.0 → 1.43.1

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

@@ -1,20 +1,18 @@
-/*
- *
- * 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.
- *
- */
+//
+// 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_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
@@ -39,9 +37,6 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata.h"
 
-// Channel arg containing a URI indicating the address to connect to.
-#define GRPC_ARG_SUBCHANNEL_ADDRESS "grpc.subchannel_address"
-
 namespace grpc_core {
 
 class SubchannelCall;
@@ -153,7 +148,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
     struct ConnectivityStateChange {
       grpc_connectivity_state state;
       absl::Status status;
-      RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     };
 
     ~ConnectivityStateWatcherInterface() override = default;
@@ -190,10 +184,10 @@ class Subchannel : public DualRefCounted<Subchannel> {
         ABSL_GUARDED_BY(&mu_);
   };
 
-  // Creates a subchannel given \a connector and \a args.
+  // Creates a subchannel.
   static RefCountedPtr<Subchannel> Create(
       OrphanablePtr<SubchannelConnector> connector,
-      const grpc_channel_args* args);
+      const grpc_resolved_address& address, const grpc_channel_args* args);
 
   // The ctor and dtor are not intended to use directly.
   Subchannel(SubchannelKey key, OrphanablePtr<SubchannelConnector> connector,
@@ -205,10 +199,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // will have an affect when the subchannel creates a new ConnectedSubchannel.
   void ThrottleKeepaliveTime(int new_keepalive_time) ABSL_LOCKS_EXCLUDED(mu_);
 
-  // Gets the string representing the subchannel address.
-  // Caller doesn't take ownership.
-  const char* GetTargetAddress();
-
   const grpc_channel_args* channel_args() const { return args_; }
 
   channelz::SubchannelNode* channelz_node();
@@ -217,10 +207,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // If health_check_service_name is non-null, the returned connectivity
   // state will be based on the state reported by the backend for that
   // service name.
-  // If the return value is GRPC_CHANNEL_READY, also sets *connected_subchannel.
   grpc_connectivity_state CheckConnectivityState(
-      const absl::optional<std::string>& health_check_service_name,
-      RefCountedPtr<ConnectedSubchannel>* connected_subchannel)
+      const absl::optional<std::string>& health_check_service_name)
       ABSL_LOCKS_EXCLUDED(mu_);
 
   // Starts watching the subchannel's connectivity state.
@@ -243,31 +231,21 @@ class Subchannel : public DualRefCounted<Subchannel> {
       const absl::optional<std::string>& health_check_service_name,
       ConnectivityStateWatcherInterface* watcher) ABSL_LOCKS_EXCLUDED(mu_);
 
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel()
+      ABSL_LOCKS_EXCLUDED(mu_) {
+    MutexLock lock(&mu_);
+    return connected_subchannel_;
+  }
+
   // Attempt to connect to the backend.  Has no effect if already connected.
   void AttemptToConnect() ABSL_LOCKS_EXCLUDED(mu_);
 
   // Resets the connection backoff of the subchannel.
-  // TODO(roth): Move connection backoff out of subchannels and up into LB
-  // policy code (probably by adding a SubchannelGroup between
-  // SubchannelList and SubchannelData), at which point this method can
-  // go away.
   void ResetBackoff() ABSL_LOCKS_EXCLUDED(mu_);
 
   // Tears down any existing connection, and arranges for destruction
   void Orphan() override ABSL_LOCKS_EXCLUDED(mu_);
 
-  // Returns a new channel arg encoding the subchannel address as a URI
-  // string. Caller is responsible for freeing the string.
-  static grpc_arg CreateSubchannelAddressArg(const grpc_resolved_address* addr);
-
-  // Returns the URI string from the subchannel address arg in \a args.
-  static const char* GetUriFromSubchannelAddressArg(
-      const grpc_channel_args* args);
-
-  // Sets \a addr from the subchannel address arg in \a args.
-  static void GetAddressFromSubchannelAddressArg(const grpc_channel_args* args,
-                                                 grpc_resolved_address* addr);
-
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.
@@ -280,7 +258,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
     void RemoveWatcherLocked(ConnectivityStateWatcherInterface* watcher);
 
     // Notifies all watchers in the list about a change to state.
-    void NotifyLocked(Subchannel* subchannel, grpc_connectivity_state state,
+    void NotifyLocked(grpc_connectivity_state state,
                       const absl::Status& status);
 
     void Clear() { watchers_.clear(); }
@@ -350,9 +328,11 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   // The subchannel pool this subchannel is in.
   RefCountedPtr<SubchannelPoolInterface> subchannel_pool_;
-  // TODO(juanlishen): Consider using args_ as key_ directly.
   // Subchannel key that identifies this subchannel in the subchannel pool.
   const SubchannelKey key_;
+  // Actual address to connect to.  May be different than the address in
+  // key_ if overridden by proxy mapper.
+  grpc_resolved_address address_for_connect_;
   // Channel args.
   grpc_channel_args* args_;
   // pollset_set tracking who's interested in a connection being setup.
@@ -399,4 +379,4 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H

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

@@ -20,10 +20,11 @@
 
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/useful.h"
 
 // The subchannel pool to reuse subchannels.
-#define GRPC_ARG_SUBCHANNEL_POOL "grpc.subchannel_pool"
+#define GRPC_ARG_SUBCHANNEL_POOL "grpc.internal.subchannel_pool"
 // The subchannel key ID that is only used in test to make each key unique.
 #define GRPC_ARG_SUBCHANNEL_KEY_TEST_ONLY_ID "grpc.subchannel_key_test_only_id"
 
@@ -31,8 +32,9 @@ namespace grpc_core {
 
 TraceFlag grpc_subchannel_pool_trace(false, "subchannel_pool");
 
-SubchannelKey::SubchannelKey(const grpc_channel_args* args) {
-  Init(args, grpc_channel_args_normalize);
+SubchannelKey::SubchannelKey(const grpc_resolved_address& address,
+                             const grpc_channel_args* args) {
+  Init(address, args, grpc_channel_args_normalize);
 }
 
 SubchannelKey::~SubchannelKey() {
@@ -40,7 +42,7 @@ SubchannelKey::~SubchannelKey() {
 }
 
 SubchannelKey::SubchannelKey(const SubchannelKey& other) {
-  Init(other.args_, grpc_channel_args_copy);
+  Init(other.address_, other.args_, grpc_channel_args_copy);
 }
 
 SubchannelKey& SubchannelKey::operator=(const SubchannelKey& other) {
@@ -48,31 +50,44 @@ SubchannelKey& SubchannelKey::operator=(const SubchannelKey& other) {
     return *this;
   }
   grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
-  Init(other.args_, grpc_channel_args_copy);
+  Init(other.address_, other.args_, grpc_channel_args_copy);
   return *this;
 }
 
 SubchannelKey::SubchannelKey(SubchannelKey&& other) noexcept {
+  address_ = other.address_;
   args_ = other.args_;
   other.args_ = nullptr;
 }
 
 SubchannelKey& SubchannelKey::operator=(SubchannelKey&& other) noexcept {
+  address_ = other.address_;
   args_ = other.args_;
   other.args_ = nullptr;
   return *this;
 }
 
 bool SubchannelKey::operator<(const SubchannelKey& other) const {
+  if (address_.len < other.address_.len) return true;
+  if (address_.len > other.address_.len) return false;
+  int r = memcmp(address_.addr, other.address_.addr, address_.len);
+  if (r < 0) return true;
+  if (r > 0) return false;
   return grpc_channel_args_compare(args_, other.args_) < 0;
 }
 
 void SubchannelKey::Init(
-    const grpc_channel_args* args,
+    const grpc_resolved_address& address, const grpc_channel_args* args,
     grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args)) {
+  address_ = address;
   args_ = copy_channel_args(args);
 }
 
+std::string SubchannelKey::ToString() const {
+  return absl::StrCat("{address=", grpc_sockaddr_to_uri(&address_),
+                      ", args=", grpc_channel_args_string(args_), "}");
+}
+
 namespace {
 
 void* arg_copy(void* p) {
@@ -86,7 +101,7 @@ void arg_destroy(void* p) {
   subchannel_pool->Unref();
 }
 
-int arg_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
+int arg_cmp(void* a, void* b) { return QsortCompare(a, b); }
 
 const grpc_arg_pointer_vtable subchannel_pool_arg_vtable = {
     arg_copy, arg_destroy, arg_cmp};

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

@@ -25,6 +25,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/iomgr/resolve_address.h"
 
 namespace grpc_core {
 
@@ -35,7 +36,8 @@ extern TraceFlag grpc_subchannel_pool_trace;
 // A key that can uniquely identify a subchannel.
 class SubchannelKey {
  public:
-  explicit SubchannelKey(const grpc_channel_args* args);
+  SubchannelKey(const grpc_resolved_address& address,
+                const grpc_channel_args* args);
   ~SubchannelKey();
 
   // Copyable.
@@ -47,13 +49,20 @@ class SubchannelKey {
 
   bool operator<(const SubchannelKey& other) const;
 
+  const grpc_resolved_address& address() const { return address_; }
+  const grpc_channel_args* args() const { return args_; }
+
+  // Human-readable string suitable for logging.
+  std::string ToString() const;
+
  private:
   // Initializes the subchannel key with the given \a args and the function to
   // copy channel args.
   void Init(
-      const grpc_channel_args* args,
+      const grpc_resolved_address& address, const grpc_channel_args* args,
       grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args));
 
+  grpc_resolved_address address_;
   const grpc_channel_args* args_;
 };
 

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -22,10 +22,11 @@
 
 #include <atomic>
 
+#include "src/core/ext/filters/client_idle/idle_filter_state.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/http2_errors.h"
 
 // TODO(juanlishen): The idle filter is disabled in client channel by default
@@ -47,78 +48,8 @@ TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
 
 namespace {
 
-/*
-  client_idle_filter maintains a state tracking if there are active calls in the
-  channel and its internal idle_timer_. The states are specified as following:
-
-  +--------------------------------------------+-------------+---------+
-  |               ChannelState                 | idle_timer_ | channel |
-  +--------------------------------------------+-------------+---------+
-  | IDLE                                       | unset       | idle    |
-  | CALLS_ACTIVE                               | unset       | busy    |
-  | TIMER_PENDING                              | set-valid   | idle    |
-  | TIMER_PENDING_CALLS_ACTIVE                 | set-invalid | busy    |
-  | TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START | set-invalid | idle    |
-  +--------------------------------------------+-------------+---------+
-
-  IDLE: The initial state of the client_idle_filter, indicating the channel is
-  in IDLE.
-
-  CALLS_ACTIVE: The channel has 1 or 1+ active calls and the timer is not set.
-
-  TIMER_PENDING: The state after the timer is set and no calls have arrived
-  after the timer is set. The channel must have 0 active call in this state. If
-  the timer is fired in this state, the channel will go into IDLE state.
-
-  TIMER_PENDING_CALLS_ACTIVE: The state after the timer is set and at least one
-  call has arrived after the timer is set. The channel must have 1 or 1+ active
-  calls in this state. If the timer is fired in this state, we won't reschedule
-  it.
-
-  TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START: The state after the timer is set
-  and at least one call has arrived after the timer is set, BUT the channel
-  currently has 0 active call. If the timer is fired in this state, we will
-  reschedule it according to the finish time of the latest call.
-
-  PROCESSING: The state set to block other threads when the setting thread is
-  doing some work to keep state consistency.
-
-  idle_timer_ will not be cancelled (unless the channel is shutting down).
-  If the timer callback is called when the idle_timer_ is valid (i.e. idle_state
-  is TIMER_PENDING), the channel will enter IDLE, otherwise the channel won't be
-  changed.
-
-  State transitions:
-                                            IDLE
-                                            |  ^
-            ---------------------------------  *
-            |                                  *
-            v                                  *
-      CALLS_ACTIVE =================> TIMER_PENDING
-            ^                               |  ^
-            *  ------------------------------  *
-            *  |                               *
-            *  v                               *
-TIMER_PENDING_CALLS_ACTIVE ===> TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START
-            ^                               |
-            |                               |
-            ---------------------------------
-
-  ---> Triggered by IncreaseCallCount()
-  ===> Triggered by DecreaseCallCount()
-  ***> Triggered by IdleTimerCallback()
-*/
-enum ChannelState {
-  IDLE,
-  CALLS_ACTIVE,
-  TIMER_PENDING,
-  TIMER_PENDING_CALLS_ACTIVE,
-  TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
-  PROCESSING
-};
-
 grpc_millis GetClientIdleTimeout(const grpc_channel_args* args) {
-  return GPR_MAX(
+  return std::max(
       grpc_channel_arg_get_integer(
           grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
           {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX}),
@@ -159,9 +90,7 @@ class ChannelData {
   const grpc_millis client_idle_timeout_;
 
   // Member data used to track the state of channel.
-  grpc_millis last_idle_time_;
-  std::atomic<intptr_t> call_count_{0};
-  std::atomic<ChannelState> state_{IDLE};
+  IdleFilterState idle_filter_state_{false};
 
   // Idle timer and its callback closure.
   grpc_timer idle_timer_;
@@ -202,86 +131,13 @@ void ChannelData::StartTransportOp(grpc_channel_element* elem,
 }
 
 void ChannelData::IncreaseCallCount() {
-  const intptr_t previous_value =
-      call_count_.fetch_add(1, std::memory_order_relaxed);
-  GRPC_IDLE_FILTER_LOG("call counter has increased to %" PRIuPTR,
-                       previous_value + 1);
-  if (previous_value == 0) {
-    // This call is the one that makes the channel busy.
-    // Loop here to make sure the previous decrease operation has finished.
-    ChannelState state = state_.load(std::memory_order_relaxed);
-    while (true) {
-      switch (state) {
-        // Timer has not been set. Switch to CALLS_ACTIVE.
-        case IDLE:
-          // In this case, no other threads will modify the state, so we can
-          // just store the value.
-          state_.store(CALLS_ACTIVE, std::memory_order_relaxed);
-          return;
-        // Timer has been set. Switch to TIMER_PENDING_CALLS_ACTIVE.
-        case TIMER_PENDING:
-        case TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START:
-          // At this point, the state may have been switched to IDLE by the
-          // idle timer callback. Therefore, use CAS operation to change the
-          // state atomically.
-          // Use std::memory_order_acquire on success to ensure last_idle_time_
-          // has been properly set in DecreaseCallCount().
-          if (state_.compare_exchange_weak(state, TIMER_PENDING_CALLS_ACTIVE,
-                                           std::memory_order_acquire,
-                                           std::memory_order_relaxed)) {
-            return;
-          }
-          break;
-        default:
-          // The state has not been switched to desired value yet, try again.
-          state = state_.load(std::memory_order_relaxed);
-          break;
-      }
-    }
-  }
+  idle_filter_state_.IncreaseCallCount();
 }
 
 void ChannelData::DecreaseCallCount() {
-  const intptr_t previous_value =
-      call_count_.fetch_sub(1, std::memory_order_relaxed);
-  GRPC_IDLE_FILTER_LOG("call counter has decreased to %" PRIuPTR,
-                       previous_value - 1);
-  if (previous_value == 1) {
-    // This call is the one that makes the channel idle.
-    // last_idle_time_ does not need to be std::atomic<> because busy-loops in
-    // IncreaseCallCount(), DecreaseCallCount() and IdleTimerCallback() will
-    // prevent multiple threads from simultaneously accessing this variable.
-    last_idle_time_ = ExecCtx::Get()->Now();
-    ChannelState state = state_.load(std::memory_order_relaxed);
-    while (true) {
-      switch (state) {
-        // Timer has not been set. Set the timer and switch to TIMER_PENDING
-        case CALLS_ACTIVE:
-          // Release store here to make other threads see the updated value of
-          // last_idle_time_.
-          StartIdleTimer();
-          state_.store(TIMER_PENDING, std::memory_order_release);
-          return;
-        // Timer has been set. Switch to
-        // TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START
-        case TIMER_PENDING_CALLS_ACTIVE:
-          // At this point, the state may have been switched to CALLS_ACTIVE by
-          // the idle timer callback. Therefore, use CAS operation to change the
-          // state atomically.
-          // Release store here to make the idle timer callback see the updated
-          // value of last_idle_time_ to properly reset the idle timer.
-          if (state_.compare_exchange_weak(
-                  state, TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START,
-                  std::memory_order_release, std::memory_order_relaxed)) {
-            return;
-          }
-          break;
-        default:
-          // The state has not been switched to desired value yet, try again.
-          state = state_.load(std::memory_order_relaxed);
-          break;
-      }
-    }
+  if (idle_filter_state_.DecreaseCallCount()) {
+    // If there are no more calls in progress, start the idle timer.
+    StartIdleTimer();
   }
 }
 
@@ -315,44 +171,10 @@ void ChannelData::IdleTimerCallback(void* arg, grpc_error_handle error) {
     GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
     return;
   }
-  bool finished = false;
-  ChannelState state = chand->state_.load(std::memory_order_relaxed);
-  while (!finished) {
-    switch (state) {
-      case TIMER_PENDING:
-        // Change the state to PROCESSING to block IncreaseCallCout() until the
-        // EnterIdle() operation finishes, preventing mistakenly entering IDLE
-        // when active RPC exists.
-        finished = chand->state_.compare_exchange_weak(
-            state, PROCESSING, std::memory_order_acquire,
-            std::memory_order_relaxed);
-        if (finished) {
-          chand->EnterIdle();
-          chand->state_.store(IDLE, std::memory_order_relaxed);
-        }
-        break;
-      case TIMER_PENDING_CALLS_ACTIVE:
-        finished = chand->state_.compare_exchange_weak(
-            state, CALLS_ACTIVE, std::memory_order_relaxed,
-            std::memory_order_relaxed);
-        break;
-      case TIMER_PENDING_CALLS_SEEN_SINCE_TIMER_START:
-        // Change the state to PROCESSING to block IncreaseCallCount() until the
-        // StartIdleTimer() operation finishes, preventing mistakenly restarting
-        // the timer after grpc_timer_cancel() when shutdown.
-        finished = chand->state_.compare_exchange_weak(
-            state, PROCESSING, std::memory_order_acquire,
-            std::memory_order_relaxed);
-        if (finished) {
-          chand->StartIdleTimer();
-          chand->state_.store(TIMER_PENDING, std::memory_order_relaxed);
-        }
-        break;
-      default:
-        // The state has not been switched to desired value yet, try again.
-        state = chand->state_.load(std::memory_order_relaxed);
-        break;
-    }
+  if (chand->idle_filter_state_.CheckTimer()) {
+    chand->StartIdleTimer();
+  } else {
+    chand->EnterIdle();
   }
   GRPC_IDLE_FILTER_LOG("timer finishes");
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
@@ -368,7 +190,7 @@ void ChannelData::StartIdleTimer() {
   GRPC_IDLE_FILTER_LOG("timer has started");
   // Hold a ref to the channel stack for the timer callback.
   GRPC_CHANNEL_STACK_REF(channel_stack_, "max idle timer callback");
-  grpc_timer_init(&idle_timer_, last_idle_time_ + client_idle_timeout_,
+  grpc_timer_init(&idle_timer_, ExecCtx::Get()->Now() + client_idle_timeout_,
                   &idle_timer_callback_);
 }
 
@@ -422,26 +244,21 @@ const grpc_channel_filter grpc_client_idle_filter = {
     grpc_channel_next_get_info,
     "client_idle"};
 
-static bool MaybeAddClientIdleFilter(grpc_channel_stack_builder* builder,
-                                     void* /*arg*/) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
-  if (!grpc_channel_args_want_minimal_stack(channel_args) &&
-      GetClientIdleTimeout(channel_args) != INT_MAX) {
-    return grpc_channel_stack_builder_prepend_filter(
-        builder, &grpc_client_idle_filter, nullptr, nullptr);
-  } else {
-    return true;
-  }
-}
-
 }  // namespace
-}  // namespace grpc_core
 
-void grpc_client_idle_filter_init(void) {
-  grpc_channel_init_register_stage(
+void RegisterClientIdleFilter(CoreConfiguration::Builder* builder) {
+  builder->channel_init()->RegisterStage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      grpc_core::MaybeAddClientIdleFilter, nullptr);
+      [](grpc_channel_stack_builder* builder) {
+        const grpc_channel_args* channel_args =
+            grpc_channel_stack_builder_get_channel_arguments(builder);
+        if (!grpc_channel_args_want_minimal_stack(channel_args) &&
+            GetClientIdleTimeout(channel_args) != INT_MAX) {
+          return grpc_channel_stack_builder_prepend_filter(
+              builder, &grpc_client_idle_filter, nullptr, nullptr);
+        } else {
+          return true;
+        }
+      });
 }
-
-void grpc_client_idle_filter_shutdown(void) {}
+}  // namespace grpc_core

data/src/core/ext/filters/client_idle/idle_filter_state.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/ext/filters/client_idle/idle_filter_state.h"
+
+#include <assert.h>
+
+namespace grpc_core {
+
+IdleFilterState::IdleFilterState(bool start_timer)
+    : state_(start_timer ? kTimerStarted : 0) {}
+
+void IdleFilterState::IncreaseCallCount() {
+  uintptr_t state = state_.load(std::memory_order_relaxed);
+  uintptr_t new_state;
+  do {
+    // Increment the counter, and flag that there's been activity.
+    new_state = state;
+    new_state |= kCallsStartedSinceLastTimerCheck;
+    new_state += kCallIncrement;
+  } while (!state_.compare_exchange_weak(
+      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
+}
+
+bool IdleFilterState::DecreaseCallCount() {
+  uintptr_t state = state_.load(std::memory_order_relaxed);
+  uintptr_t new_state;
+  bool start_timer;
+  do {
+    start_timer = false;
+    new_state = state;
+    // Decrement call count (and assert there's at least one call outstanding!)
+    assert(new_state >= kCallIncrement);
+    new_state -= kCallIncrement;
+    // If that decrement reaches a call count of zero and we have not started a
+    // timer
+    if ((new_state >> kCallsInProgressShift) == 0 &&
+        (new_state & kTimerStarted) == 0) {
+      // Flag that we will start a timer, and mark it started so nobody else
+      // does.
+      start_timer = true;
+      new_state |= kTimerStarted;
+      new_state &= ~kCallsInProgressShift;
+    }
+  } while (!state_.compare_exchange_weak(
+      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
+  return start_timer;
+}
+
+bool IdleFilterState::CheckTimer() {
+  uintptr_t state = state_.load(std::memory_order_relaxed);
+  uintptr_t new_state;
+  bool start_timer;
+  do {
+    if ((state >> kCallsInProgressShift) != 0) {
+      // Still calls in progress: nothing needs updating, just return
+      // and keep the timer going!
+      return true;
+    }
+    new_state = state;
+    bool is_active = false;
+    if (new_state & kCallsStartedSinceLastTimerCheck) {
+      // If any calls started since the last time we checked, then consider the
+      // channel still active and try again.
+      is_active = true;
+      new_state &= ~kCallsStartedSinceLastTimerCheck;
+    }
+    if (is_active) {
+      // If we are still active, we should signal that the timer should start
+      // again.
+      start_timer = true;
+    } else {
+      // Otherwise, we should not start the timer again, and we should signal
+      // that in the updated state.
+      start_timer = false;
+      new_state &= ~kTimerStarted;
+    }
+  } while (!state_.compare_exchange_weak(
+      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
+  return start_timer;
+}
+
+}  // namespace grpc_core