grpc 1.71.0 → 1.74.0

data/src/core/client_channel/connector.h

@@ -53,8 +53,6 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
     Transport* transport = nullptr;
     // Channel args to be passed to filters.
     ChannelArgs channel_args;
-    // Channelz socket node of the connected transport, if any.
-    RefCountedPtr<channelz::SocketNode> socket_node;
 
     void Reset() {
       if (transport != nullptr) {
@@ -62,7 +60,6 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
         transport = nullptr;
       }
       channel_args = ChannelArgs();
-      socket_node.reset();
     }
   };
 

data/src/core/client_channel/direct_channel.cc

@@ -14,11 +14,11 @@
 
 #include "src/core/client_channel/direct_channel.h"
 
+#include "src/core/call/client_call.h"
+#include "src/core/call/interception_chain.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/surface/client_call.h"
-#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/util/orphanable.h"
 
 namespace grpc_core {

data/src/core/client_channel/dynamic_filters.cc

@@ -55,7 +55,6 @@ DynamicFilters::Call::Call(Args args, grpc_error_handle* error)
   const grpc_call_element_args call_args = {
       call_stack,         // call_stack
       nullptr,            // server_transport_data
-      args.path,          // path
       args.start_time,    // start_time
       args.deadline,      // deadline
       args.arena,         // arena
@@ -138,9 +137,9 @@ namespace {
 
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
     const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
-    const Blackboard* old_blackboard, Blackboard* new_blackboard) {
+    const Blackboard* blackboard) {
   ChannelStackBuilderImpl builder("DynamicFilters", GRPC_CLIENT_DYNAMIC, args);
-  builder.SetBlackboards(old_blackboard, new_blackboard);
+  builder.SetBlackboard(blackboard);
   for (auto filter : filters) {
     builder.AppendFilter(filter);
   }
@@ -151,16 +150,15 @@ absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
 
 RefCountedPtr<DynamicFilters> DynamicFilters::Create(
     const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
-    const Blackboard* old_blackboard, Blackboard* new_blackboard) {
+    const Blackboard* blackboard) {
   // Attempt to create channel stack from requested filters.
-  auto p = CreateChannelStack(args, std::move(filters), old_blackboard,
-                              new_blackboard);
+  auto p = CreateChannelStack(args, std::move(filters), blackboard);
   if (!p.ok()) {
     // Channel stack creation failed with requested filters.
     // Create with lame filter instead.
     auto error = p.status();
     p = CreateChannelStack(args.Set(MakeLameClientErrorArg(&error)),
-                           {&LameClientFilter::kFilter}, nullptr, nullptr);
+                           {&LameClientFilter::kFilter}, nullptr);
   }
   return MakeRefCounted<DynamicFilters>(std::move(p.value()));
 }

data/src/core/client_channel/dynamic_filters.h

@@ -49,7 +49,6 @@ class DynamicFilters final : public RefCounted<DynamicFilters> {
     struct Args {
       RefCountedPtr<DynamicFilters> channel_stack;
       grpc_polling_entity* pollent;
-      grpc_slice path;
       gpr_cycle_counter start_time;
       Timestamp deadline;
       Arena* arena;
@@ -91,7 +90,7 @@ class DynamicFilters final : public RefCounted<DynamicFilters> {
 
   static RefCountedPtr<DynamicFilters> Create(
       const ChannelArgs& args, std::vector<const grpc_channel_filter*> filters,
-      const Blackboard* old_blackboard, Blackboard* new_blackboard);
+      const Blackboard* blackboard);
 
   explicit DynamicFilters(RefCountedPtr<grpc_channel_stack> channel_stack)
       : channel_stack_(std::move(channel_stack)) {}

data/src/core/client_channel/global_subchannel_pool.cc

@@ -26,12 +26,13 @@
 
 namespace grpc_core {
 
-RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
-  static GlobalSubchannelPool* p = new GlobalSubchannelPool();
-  return p->RefAsSubclass<GlobalSubchannelPool>();
+RefCountedPtr<LegacyGlobalSubchannelPool>
+LegacyGlobalSubchannelPool::instance() {
+  static LegacyGlobalSubchannelPool* p = new LegacyGlobalSubchannelPool();
+  return p->RefAsSubclass<LegacyGlobalSubchannelPool>();
 }
 
-RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
+RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::RegisterSubchannel(
     const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
   MutexLock lock(&mu_);
   auto it = subchannel_map_.find(key);
@@ -43,8 +44,8 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
   return constructed;
 }
 
-void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
-                                                Subchannel* subchannel) {
+void LegacyGlobalSubchannelPool::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
@@ -54,7 +55,7 @@ void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
   }
 }
 
-RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
+RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::FindSubchannel(
     const SubchannelKey& key) {
   MutexLock lock(&mu_);
   auto it = subchannel_map_.find(key);
@@ -62,4 +63,67 @@ RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
   return it->second->RefIfNonZero();
 }
 
+RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
+  static GlobalSubchannelPool* p = new GlobalSubchannelPool();
+  return p->RefAsSubclass<GlobalSubchannelPool>();
+}
+
+RefCountedPtr<Subchannel> GlobalSubchannelPool::RegisterSubchannel(
+    const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
+  auto shard_index = ShardIndex(key);
+  auto& write_shard = write_shards_[shard_index];
+  auto& read_shard = read_shards_[shard_index];
+  SubchannelMap old_map1;
+  SubchannelMap old_map2;
+  MutexLock lock(&write_shard.mu);
+  auto* existing = write_shard.map.Lookup(key);
+  if (existing != nullptr) {
+    auto existing_ref = (*existing)->RefIfNonZero();
+    if (existing_ref != nullptr) return existing_ref;
+  }
+  old_map1 = std::exchange(write_shard.map,
+                           write_shard.map.Add(key, constructed->WeakRef()));
+  MutexLock lock_read(&read_shard.mu);
+  old_map2 = std::exchange(read_shard.map, write_shard.map);
+  return constructed;
+}
+
+void GlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
+                                                Subchannel* subchannel) {
+  auto shard_index = ShardIndex(key);
+  auto& write_shard = write_shards_[shard_index];
+  auto& read_shard = read_shards_[shard_index];
+  SubchannelMap old_map1;
+  SubchannelMap old_map2;
+  MutexLock lock(&write_shard.mu);
+  auto* existing = write_shard.map.Lookup(key);
+  // delete only if key hasn't been re-registered to a different subchannel
+  // between strong-unreffing and unregistration of subchannel.
+  if (existing == nullptr || existing->get() != subchannel) return;
+  old_map1 = std::exchange(write_shard.map, write_shard.map.Remove(key));
+  MutexLock lock_read(&read_shard.mu);
+  old_map2 = std::exchange(read_shard.map, write_shard.map);
+}
+
+RefCountedPtr<Subchannel> GlobalSubchannelPool::FindSubchannel(
+    const SubchannelKey& key) {
+  auto shard_index = ShardIndex(key);
+  auto& read_shard = read_shards_[shard_index];
+  read_shard.mu.Lock();
+  auto map = read_shard.map;
+  read_shard.mu.Unlock();
+  auto* subchannel = map.Lookup(key);
+  if (subchannel == nullptr) return nullptr;
+  return (*subchannel)->RefIfNonZero();
+}
+
+size_t GlobalSubchannelPool::ShardIndex(const SubchannelKey& key) {
+  absl::string_view addr(key.address().addr, key.address().len);
+  return absl::HashOf(addr) % kShards;
+}
+
+GlobalSubchannelPool::GlobalSubchannelPool() = default;
+
+GlobalSubchannelPool::~GlobalSubchannelPool() = default;
+
 }  // namespace grpc_core

data/src/core/client_channel/global_subchannel_pool.h

@@ -32,10 +32,10 @@ namespace grpc_core {
 
 // The global subchannel pool. It shares subchannels among channels. There
 // should be only one instance of this class.
-class GlobalSubchannelPool final : public SubchannelPoolInterface {
+class LegacyGlobalSubchannelPool final : public SubchannelPoolInterface {
  public:
   // Gets the singleton instance.
-  static RefCountedPtr<GlobalSubchannelPool> instance();
+  static RefCountedPtr<LegacyGlobalSubchannelPool> instance();
 
   // Implements interface methods.
   RefCountedPtr<Subchannel> RegisterSubchannel(
@@ -48,8 +48,8 @@ class GlobalSubchannelPool final : public SubchannelPoolInterface {
       ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
-  GlobalSubchannelPool() {}
-  ~GlobalSubchannelPool() override {}
+  LegacyGlobalSubchannelPool() {}
+  ~LegacyGlobalSubchannelPool() override {}
 
   // A map from subchannel key to subchannel.
   std::map<SubchannelKey, Subchannel*> subchannel_map_ ABSL_GUARDED_BY(mu_);
@@ -57,6 +57,39 @@ class GlobalSubchannelPool final : public SubchannelPoolInterface {
   Mutex mu_;
 };
 
+// The global subchannel pool. It shares subchannels among channels. There
+// should be only one instance of this class.
+class GlobalSubchannelPool final : public SubchannelPoolInterface {
+ public:
+  // Gets the singleton instance.
+  static RefCountedPtr<GlobalSubchannelPool> instance();
+
+  // Implements interface methods.
+  RefCountedPtr<Subchannel> RegisterSubchannel(
+      const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) override;
+  void UnregisterSubchannel(const SubchannelKey& key,
+                            Subchannel* subchannel) override;
+  RefCountedPtr<Subchannel> FindSubchannel(const SubchannelKey& key) override;
+
+ private:
+  GlobalSubchannelPool();
+  ~GlobalSubchannelPool() override;
+
+  static const size_t kShards = 127;
+
+  using SubchannelMap = AVL<SubchannelKey, WeakRefCountedPtr<Subchannel>>;
+  struct LockedMap {
+    Mutex mu;
+    SubchannelMap map ABSL_GUARDED_BY(mu);
+  };
+  using ShardedMap = std::array<LockedMap, kShards>;
+
+  static size_t ShardIndex(const SubchannelKey& key);
+
+  ShardedMap write_shards_;
+  ShardedMap read_shards_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_GLOBAL_SUBCHANNEL_POOL_H

data/src/core/client_channel/lb_metadata.h

@@ -22,7 +22,7 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/load_balancing/lb_policy.h"
 
 namespace grpc_core {

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -15,12 +15,12 @@
 #include "src/core/client_channel/load_balanced_call_destination.h"
 
 #include "absl/log/log.h"
+#include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/lb_metadata.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/promise/loop.h"
 #include "src/core/telemetry/call_tracer.h"
 

data/src/core/client_channel/load_balanced_call_destination.h

@@ -16,9 +16,9 @@
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_LOAD_BALANCED_CALL_DESTINATION_H
 
 #include "absl/functional/any_invocable.h"
+#include "src/core/call/call_destination.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/transport/call_destination.h"
 #include "src/core/load_balancing/lb_policy.h"
 
 namespace grpc_core {

data/src/core/client_channel/retry_filter.cc

@@ -31,7 +31,6 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -93,39 +92,34 @@ namespace grpc_core {
 // RetryFilter
 //
 
-RetryFilter::RetryFilter(const ChannelArgs& args, grpc_error_handle* error)
-    : client_channel_(args.GetObject<ClientChannelFilter>()),
-      event_engine_(args.GetObject<EventEngine>()),
-      per_rpc_retry_buffer_size_(GetMaxPerRpcRetryBufferSize(args)),
-      service_config_parser_index_(
-          internal::RetryServiceConfigParser::ParserIndex()) {
+void RetryFilter::UpdateBlackboard(const ServiceConfig& service_config,
+                                   const Blackboard* old_blackboard,
+                                   Blackboard* new_blackboard) {
   // Get retry throttling parameters from service config.
-  auto* service_config = args.GetObject<ServiceConfig>();
-  if (service_config == nullptr) return;
   const auto* config = static_cast<const RetryGlobalConfig*>(
-      service_config->GetGlobalParsedConfig(
+      service_config.GetGlobalParsedConfig(
           RetryServiceConfigParser::ParserIndex()));
   if (config == nullptr) return;
-  // Get server name from target URI.
-  auto server_uri = args.GetString(GRPC_ARG_SERVER_URI);
-  if (!server_uri.has_value()) {
-    *error = GRPC_ERROR_CREATE(
-        "server URI channel arg missing or wrong type in client channel "
-        "filter");
-    return;
-  }
-  absl::StatusOr<URI> uri = URI::Parse(*server_uri);
-  if (!uri.ok() || uri->path().empty()) {
-    *error = GRPC_ERROR_CREATE("could not extract server name from target URI");
-    return;
+  // Get throttler.
+  RefCountedPtr<internal::RetryThrottler> throttler;
+  if (old_blackboard != nullptr) {
+    throttler = old_blackboard->Get<internal::RetryThrottler>("");
   }
-  std::string server_name(absl::StripPrefix(uri->path(), "/"));
-  // Get throttling config for server_name.
-  retry_throttle_data_ =
-      internal::ServerRetryThrottleMap::Get()->GetDataForServer(
-          server_name, config->max_milli_tokens(), config->milli_token_ratio());
+  throttler = internal::RetryThrottler::Create(config->max_milli_tokens(),
+                                               config->milli_token_ratio(),
+                                               std::move(throttler));
+  new_blackboard->Set("", std::move(throttler));
 }
 
+RetryFilter::RetryFilter(const grpc_channel_element_args& args)
+    : client_channel_(args.channel_args.GetObject<ClientChannelFilter>()),
+      event_engine_(args.channel_args.GetObject<EventEngine>()),
+      per_rpc_retry_buffer_size_(
+          GetMaxPerRpcRetryBufferSize(args.channel_args)),
+      retry_throttler_(args.blackboard->Get<internal::RetryThrottler>("")),
+      service_config_parser_index_(
+          internal::RetryServiceConfigParser::ParserIndex()) {}
+
 const RetryMethodConfig* RetryFilter::GetRetryPolicy(Arena* arena) {
   auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();
   if (svc_cfg_call_data == nullptr) return nullptr;

data/src/core/client_channel/retry_filter.h

@@ -45,6 +45,10 @@ class RetryFilter final {
  public:
   static const grpc_channel_filter kVtable;
 
+  static void UpdateBlackboard(const ServiceConfig& service_config,
+                               const Blackboard* old_blackboard,
+                               Blackboard* blackboard);
+
  private:
   // Old filter-stack style call implementation, in
   // retry_filter_legacy_call_data.{h,cc}
@@ -60,8 +64,8 @@ class RetryFilter final {
 
   const internal::RetryMethodConfig* GetRetryPolicy(Arena* arena);
 
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data() const {
-    return retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler() const {
+    return retry_throttler_;
   }
 
   ClientChannelFilter* client_channel() const { return client_channel_; }
@@ -80,15 +84,14 @@ class RetryFilter final {
                  0, INT_MAX);
   }
 
-  RetryFilter(const ChannelArgs& args, grpc_error_handle* error);
+  explicit RetryFilter(const grpc_channel_element_args& args);
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
     CHECK(args->is_last);
     CHECK(elem->filter == &kVtable);
-    grpc_error_handle error;
-    new (elem->channel_data) RetryFilter(args->channel_args, &error);
-    return error;
+    new (elem->channel_data) RetryFilter(*args);
+    return absl::OkStatus();
   }
 
   static void Destroy(grpc_channel_element* elem) {
@@ -105,7 +108,7 @@ class RetryFilter final {
   ClientChannelFilter* client_channel_;
   grpc_event_engine::experimental::EventEngine* const event_engine_;
   size_t per_rpc_retry_buffer_size_;
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
   const size_t service_config_parser_index_;
 };
 

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -24,11 +24,12 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/retry_service_config.h"
 #include "src/core/client_channel/retry_throttle.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -39,7 +40,6 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/construct_destruct.h"
@@ -53,6 +53,8 @@
 
 namespace grpc_core {
 
+using TaskHandle = grpc_event_engine::experimental::EventEngine::TaskHandle;
+
 //
 // RetryFilter::LegacyCallData::CallStackDestructionBarrier
 //
@@ -220,7 +222,7 @@ void RetryFilter::LegacyCallData::CallAttempt::MaybeSwitchToFastPath() {
   // If we've already switched to fast path, there's nothing to do here.
   if (calld_->committed_call_ != nullptr) return;
   // If the perAttemptRecvTimeout timer is pending, we can't switch yet.
-  if (per_attempt_recv_timer_handle_.has_value()) return;
+  if (per_attempt_recv_timer_handle_ != TaskHandle::kInvalid) return;
   // If there are still send ops to replay, we can't switch yet.
   if (HaveSendOpsToReplay()) return;
   // If we started an internal batch for recv_trailing_metadata but have not
@@ -535,8 +537,8 @@ bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
   // Check status.
   if (status.has_value()) {
     if (GPR_LIKELY(*status == GRPC_STATUS_OK)) {
-      if (calld_->retry_throttle_data_ != nullptr) {
-        calld_->retry_throttle_data_->RecordSuccess();
+      if (calld_->retry_throttler_ != nullptr) {
+        calld_->retry_throttler_->RecordSuccess();
       }
       GRPC_TRACE_LOG(retry, INFO)
           << "chand=" << calld_->chand_ << " calld=" << calld_
@@ -560,8 +562,8 @@ bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
   // things like failures due to malformed requests (INVALID_ARGUMENT).
   // Conversely, it's important for this to come before the remaining
   // checks, so that we don't fail to record failures due to other factors.
-  if (calld_->retry_throttle_data_ != nullptr &&
-      !calld_->retry_throttle_data_->RecordFailure()) {
+  if (calld_->retry_throttler_ != nullptr &&
+      !calld_->retry_throttler_->RecordFailure()) {
     GRPC_TRACE_LOG(retry, INFO)
         << "chand=" << calld_->chand_ << " calld=" << calld_
         << " attempt=" << this << ": retries throttled";
@@ -643,31 +645,33 @@ void RetryFilter::LegacyCallData::CallAttempt::OnPerAttemptRecvTimerLocked(
       << "chand=" << calld->chand_ << " calld=" << calld
       << " attempt=" << call_attempt
       << ": perAttemptRecvTimeout timer fired: error=" << StatusToString(error)
-      << ", per_attempt_recv_timer_handle_.has_value()="
-      << call_attempt->per_attempt_recv_timer_handle_.has_value();
+      << ", per_attempt_recv_timer_handle_ is valid ="
+      << (call_attempt->per_attempt_recv_timer_handle_ != TaskHandle::kInvalid);
   CallCombinerClosureList closures;
-  call_attempt->per_attempt_recv_timer_handle_.reset();
-  // Cancel this attempt.
-  // TODO(roth): When implementing hedging, we should not cancel the
-  // current attempt.
-  call_attempt->MaybeAddBatchForCancelOp(
-      grpc_error_set_int(
-          GRPC_ERROR_CREATE("retry perAttemptRecvTimeout exceeded"),
-          StatusIntProperty::kRpcStatus, GRPC_STATUS_CANCELLED),
-      &closures);
-  // Check whether we should retry.
-  if (call_attempt->ShouldRetry(/*status=*/std::nullopt,
-                                /*server_pushback_ms=*/std::nullopt)) {
-    // Mark current attempt as abandoned.
-    call_attempt->Abandon();
-    // We are retrying.  Start backoff timer.
-    calld->StartRetryTimer(/*server_pushback=*/std::nullopt);
-  } else {
-    // Not retrying, so commit the call.
-    calld->RetryCommit(call_attempt);
-    // If retry state is no longer needed, switch to fast path for
-    // subsequent batches.
-    call_attempt->MaybeSwitchToFastPath();
+  if (call_attempt->per_attempt_recv_timer_handle_ != TaskHandle::kInvalid) {
+    call_attempt->per_attempt_recv_timer_handle_ = TaskHandle::kInvalid;
+    // Cancel this attempt.
+    // TODO(roth): When implementing hedging, we should not cancel the
+    // current attempt.
+    call_attempt->MaybeAddBatchForCancelOp(
+        grpc_error_set_int(
+            GRPC_ERROR_CREATE("retry perAttemptRecvTimeout exceeded"),
+            StatusIntProperty::kRpcStatus, GRPC_STATUS_CANCELLED),
+        &closures);
+    // Check whether we should retry.
+    if (call_attempt->ShouldRetry(/*status=*/std::nullopt,
+                                  /*server_pushback_ms=*/std::nullopt)) {
+      // Mark current attempt as abandoned.
+      call_attempt->Abandon();
+      // We are retrying.  Start backoff timer.
+      calld->StartRetryTimer(/*server_pushback=*/std::nullopt);
+    } else {
+      // Not retrying, so commit the call.
+      calld->RetryCommit(call_attempt);
+      // If retry state is no longer needed, switch to fast path for
+      // subsequent batches.
+      call_attempt->MaybeSwitchToFastPath();
+    }
   }
   closures.RunClosures(calld->call_combiner_);
   call_attempt->Unref(DEBUG_LOCATION, "OnPerAttemptRecvTimer");
@@ -676,16 +680,16 @@ void RetryFilter::LegacyCallData::CallAttempt::OnPerAttemptRecvTimerLocked(
 
 void RetryFilter::LegacyCallData::CallAttempt::
     MaybeCancelPerAttemptRecvTimer() {
-  if (per_attempt_recv_timer_handle_.has_value()) {
+  if (per_attempt_recv_timer_handle_ != TaskHandle::kInvalid) {
     GRPC_TRACE_LOG(retry, INFO)
         << "chand=" << calld_->chand_ << " calld=" << calld_
         << " attempt=" << this << ": cancelling perAttemptRecvTimeout timer";
     if (calld_->chand_->event_engine()->Cancel(
-            *per_attempt_recv_timer_handle_)) {
+            per_attempt_recv_timer_handle_)) {
       Unref(DEBUG_LOCATION, "OnPerAttemptRecvTimer");
       GRPC_CALL_STACK_UNREF(calld_->owning_call_, "OnPerAttemptRecvTimer");
     }
-    per_attempt_recv_timer_handle_.reset();
+    per_attempt_recv_timer_handle_ = TaskHandle::kInvalid;
   }
 }
 
@@ -1467,7 +1471,7 @@ void RetryFilter::LegacyCallData::SetPollent(grpc_call_element* elem,
 RetryFilter::LegacyCallData::LegacyCallData(RetryFilter* chand,
                                             const grpc_call_element_args& args)
     : chand_(chand),
-      retry_throttle_data_(chand->retry_throttle_data()),
+      retry_throttler_(chand->retry_throttler()),
       retry_policy_(chand->GetRetryPolicy(args.arena)),
       retry_backoff_(
           BackOff::Options()
@@ -1481,7 +1485,6 @@ RetryFilter::LegacyCallData::LegacyCallData(RetryFilter* chand,
               .set_max_backoff(retry_policy_ == nullptr
                                    ? Duration::Zero()
                                    : retry_policy_->max_backoff())),
-      path_(CSliceRef(args.path)),
       deadline_(args.deadline),
       arena_(args.arena),
       owning_call_(args.call_stack),
@@ -1497,7 +1500,6 @@ RetryFilter::LegacyCallData::LegacyCallData(RetryFilter* chand,
 
 RetryFilter::LegacyCallData::~LegacyCallData() {
   FreeAllCachedSendOpData();
-  CSliceUnref(path_);
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
     CHECK_EQ(pending_batches_[i].batch, nullptr);
@@ -1550,13 +1552,13 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
       return;
     }
     // Cancel retry timer if needed.
-    if (retry_timer_handle_.has_value()) {
+    if (retry_timer_handle_ != TaskHandle::kInvalid) {
       GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
                                   << ": cancelling retry timer";
-      if (chand_->event_engine()->Cancel(*retry_timer_handle_)) {
+      if (chand_->event_engine()->Cancel(retry_timer_handle_)) {
         GRPC_CALL_STACK_UNREF(owning_call_, "OnRetryTimer");
       }
-      retry_timer_handle_.reset();
+      retry_timer_handle_ = TaskHandle::kInvalid;
       FreeAllCachedSendOpData();
     }
     // We have no call attempt, so there's nowhere to send the cancellation
@@ -1570,7 +1572,7 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
   PendingBatch* pending = PendingBatchesAdd(batch);
   // If the timer is pending, yield the call combiner and wait for it to
   // run, since we don't want to start another call attempt until it does.
-  if (retry_timer_handle_.has_value()) {
+  if (retry_timer_handle_ != TaskHandle::kInvalid) {
     GRPC_CALL_COMBINER_STOP(call_combiner_,
                             "added pending batch while retry timer pending");
     return;
@@ -1627,9 +1629,9 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
 OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
 RetryFilter::LegacyCallData::CreateLoadBalancedCall(
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry) {
-  grpc_call_element_args args = {owning_call_,     nullptr,   path_,
-                                 /*start_time=*/0, deadline_, arena_,
-                                 call_combiner_};
+  grpc_call_element_args args = {owning_call_,     nullptr,
+                                 /*start_time=*/0, deadline_,
+                                 arena_,           call_combiner_};
   return chand_->client_channel()->CreateLoadBalancedCall(
       args, pollent_,
       // This callback holds a ref to the CallStackDestructionBarrier
@@ -1912,8 +1914,8 @@ void RetryFilter::LegacyCallData::OnRetryTimer() {
 void RetryFilter::LegacyCallData::OnRetryTimerLocked(
     void* arg, grpc_error_handle /*error*/) {
   auto* calld = static_cast<RetryFilter::LegacyCallData*>(arg);
-  if (calld->retry_timer_handle_.has_value()) {
-    calld->retry_timer_handle_.reset();
+  if (calld->retry_timer_handle_ != TaskHandle::kInvalid) {
+    calld->retry_timer_handle_ = TaskHandle::kInvalid;
     calld->CreateCallAttempt(/*is_transparent_retry=*/false);
   }
   GRPC_CALL_STACK_UNREF(calld->owning_call_, "OnRetryTimer");