grpc 1.69.0 → 1.71.0

data/src/core/client_channel/retry_interceptor.h

@@ -0,0 +1,157 @@
+// Copyright 2024 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_RETRY_INTERCEPTOR_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_INTERCEPTOR_H
+
+#include "src/core/call/request_buffer.h"
+#include "src/core/client_channel/client_channel_args.h"
+#include "src/core/client_channel/retry_service_config.h"
+#include "src/core/client_channel/retry_throttle.h"
+#include "src/core/filter/filter_args.h"
+#include "src/core/lib/transport/interception_chain.h"
+#include "src/core/util/backoff.h"
+
+namespace grpc_core {
+
+namespace retry_detail {
+class RetryState {
+ public:
+  RetryState(
+      const internal::RetryMethodConfig* retry_policy,
+      RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data);
+
+  // if nullopt --> commit & don't retry
+  // if duration --> retry after duration
+  std::optional<Duration> ShouldRetry(
+      const ServerMetadata& md, bool committed,
+      absl::FunctionRef<std::string()> lazy_attempt_debug_string);
+  int num_attempts_completed() const { return num_attempts_completed_; }
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const RetryState& state) {
+    sink.Append(absl::StrCat(
+        "policy:{",
+        state.retry_policy_ != nullptr ? absl::StrCat(*state.retry_policy_)
+                                       : "none",
+        "} throttle:", state.retry_throttle_data_ != nullptr,
+        " attempts:", state.num_attempts_completed_));
+  }
+
+ private:
+  const internal::RetryMethodConfig* const retry_policy_;
+  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  int num_attempts_completed_ = 0;
+  BackOff retry_backoff_;
+};
+
+absl::StatusOr<RefCountedPtr<internal::ServerRetryThrottleData>>
+ServerRetryThrottleDataFromChannelArgs(const ChannelArgs& args);
+}  // namespace retry_detail
+
+class RetryInterceptor : public Interceptor {
+ public:
+  RetryInterceptor(
+      const ChannelArgs& args,
+      RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data);
+
+  static absl::StatusOr<RefCountedPtr<RetryInterceptor>> Create(
+      const ChannelArgs& args, const FilterArgs&);
+
+  void Orphaned() override {}
+
+ protected:
+  void InterceptCall(UnstartedCallHandler unstarted_call_handler) override;
+
+ private:
+  class Attempt;
+
+  class Call final
+      : public RefCounted<Call, NonPolymorphicRefCount, UnrefCallDtor> {
+   public:
+    Call(RefCountedPtr<RetryInterceptor> interceptor, CallHandler call_handler);
+
+    void StartAttempt();
+    void Start();
+
+    RequestBuffer* request_buffer() { return &request_buffer_; }
+    CallHandler* call_handler() { return &call_handler_; }
+    RetryInterceptor* interceptor() { return interceptor_.get(); }
+    // if nullopt --> commit & don't retry
+    // if duration --> retry after duration
+    std::optional<Duration> ShouldRetry(
+        const ServerMetadata& md,
+        absl::FunctionRef<std::string()> lazy_attempt_debug_string) {
+      return retry_state_.ShouldRetry(md, request_buffer_.committed(),
+                                      lazy_attempt_debug_string);
+    }
+    int num_attempts_completed() const {
+      return retry_state_.num_attempts_completed();
+    }
+    void RemoveAttempt(Attempt* attempt) {
+      if (current_attempt_ == attempt) current_attempt_ = nullptr;
+    }
+    bool IsCurrentAttempt(Attempt* attempt) {
+      CHECK(attempt != nullptr);
+      return current_attempt_ == attempt;
+    }
+
+    std::string DebugTag();
+
+   private:
+    void MaybeCommit(size_t buffered);
+    auto ClientToBuffer();
+
+    RequestBuffer request_buffer_;
+    CallHandler call_handler_;
+    RefCountedPtr<RetryInterceptor> interceptor_;
+    Attempt* current_attempt_ = nullptr;
+    retry_detail::RetryState retry_state_;
+  };
+
+  class Attempt final
+      : public RefCounted<Attempt, NonPolymorphicRefCount, UnrefCallDtor> {
+   public:
+    explicit Attempt(RefCountedPtr<Call> call);
+    ~Attempt();
+
+    void Start();
+    void Cancel();
+    GRPC_MUST_USE_RESULT bool Commit(SourceLocation whence = {});
+    RequestBuffer::Reader* reader() { return &reader_; }
+
+    std::string DebugTag() const;
+
+   private:
+    auto ClientToServer();
+    auto ServerToClient();
+    auto ServerToClientGotInitialMetadata(ServerMetadataHandle md);
+    auto ServerToClientGotTrailersOnlyResponse();
+
+    RefCountedPtr<Call> call_;
+    RequestBuffer::Reader reader_;
+    CallInitiator initiator_;
+    bool committed_ = false;
+  };
+
+  const internal::RetryMethodConfig* GetRetryPolicy();
+
+  const size_t per_rpc_retry_buffer_size_;
+  const size_t service_config_parser_index_;
+  const RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_INTERCEPTOR_H

data/src/core/client_channel/retry_service_config.cc

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <map>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -29,7 +30,6 @@
 #include "absl/log/log.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"

data/src/core/client_channel/retry_service_config.h

@@ -22,9 +22,9 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
@@ -61,7 +61,7 @@ class RetryMethodConfig final : public ServiceConfigParser::ParsedConfig {
   StatusCodeSet retryable_status_codes() const {
     return retryable_status_codes_;
   }
-  absl::optional<Duration> per_attempt_recv_timeout() const {
+  std::optional<Duration> per_attempt_recv_timeout() const {
     return per_attempt_recv_timeout_;
   }
 
@@ -69,13 +69,26 @@ class RetryMethodConfig final : public ServiceConfigParser::ParsedConfig {
   void JsonPostLoad(const Json& json, const JsonArgs& args,
                     ValidationErrors* errors);
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const RetryMethodConfig& config) {
+    sink.Append(absl::StrCat(
+        "max_attempts:", config.max_attempts_, " initial_backoff:",
+        config.initial_backoff_, " max_backoff:", config.max_backoff_,
+        " backoff_multiplier:", config.backoff_multiplier_,
+        " retryable_status_codes:", config.retryable_status_codes_.ToString(),
+        " per_attempt_recv_timeout:",
+        config.per_attempt_recv_timeout_.has_value()
+            ? absl::StrCat(*config.per_attempt_recv_timeout_)
+            : "none"));
+  }
+
  private:
   int max_attempts_ = 0;
   Duration initial_backoff_;
   Duration max_backoff_;
   float backoff_multiplier_ = 0;
   StatusCodeSet retryable_status_codes_;
-  absl::optional<Duration> per_attempt_recv_timeout_;
+  std::optional<Duration> per_attempt_recv_timeout_;
 };
 
 class RetryServiceConfigParser final : public ServiceConfigParser::Parser {

data/src/core/client_channel/retry_throttle.cc

@@ -18,16 +18,33 @@
 
 #include "src/core/client_channel/retry_throttle.h"
 
-#include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 
+#include <atomic>
+#include <cstdint>
+#include <limits>
 #include <map>
 #include <string>
 #include <utility>
 
+#include "src/core/util/useful.h"
+
 namespace grpc_core {
 namespace internal {
 
+namespace {
+template <typename T>
+T ClampedAdd(std::atomic<T>& value, T delta, T min, T max) {
+  T prev_value = value.load(std::memory_order_relaxed);
+  T new_value;
+  do {
+    new_value = Clamp(SaturatingAdd(prev_value, delta), min, max);
+  } while (!value.compare_exchange_weak(prev_value, new_value,
+                                        std::memory_order_relaxed));
+  return new_value;
+}
+}  // namespace
+
 //
 // ServerRetryThrottleData
 //
@@ -44,26 +61,24 @@ ServerRetryThrottleData::ServerRetryThrottleData(
   // we will start out doing the same thing on the new one.
   if (old_throttle_data != nullptr) {
     double token_fraction =
-        static_cast<uintptr_t>(
-            gpr_atm_acq_load(&old_throttle_data->milli_tokens_)) /
+        static_cast<double>(
+            old_throttle_data->milli_tokens_.load(std::memory_order_relaxed)) /
         static_cast<double>(old_throttle_data->max_milli_tokens_);
     initial_milli_tokens =
         static_cast<uintptr_t>(token_fraction * max_milli_tokens);
   }
-  gpr_atm_rel_store(&milli_tokens_, static_cast<gpr_atm>(initial_milli_tokens));
+  milli_tokens_.store(initial_milli_tokens, std::memory_order_relaxed);
   // If there was a pre-existing entry, mark it as stale and give it a
   // pointer to the new entry, which is its replacement.
   if (old_throttle_data != nullptr) {
     Ref().release();  // Ref held by pre-existing entry.
-    gpr_atm_rel_store(&old_throttle_data->replacement_,
-                      reinterpret_cast<gpr_atm>(this));
+    old_throttle_data->replacement_.store(this, std::memory_order_release);
   }
 }
 
 ServerRetryThrottleData::~ServerRetryThrottleData() {
   ServerRetryThrottleData* replacement =
-      reinterpret_cast<ServerRetryThrottleData*>(
-          gpr_atm_acq_load(&replacement_));
+      replacement_.load(std::memory_order_acquire);
   if (replacement != nullptr) {
     replacement->Unref();
   }
@@ -73,8 +88,7 @@ void ServerRetryThrottleData::GetReplacementThrottleDataIfNeeded(
     ServerRetryThrottleData** throttle_data) {
   while (true) {
     ServerRetryThrottleData* new_throttle_data =
-        reinterpret_cast<ServerRetryThrottleData*>(
-            gpr_atm_acq_load(&(*throttle_data)->replacement_));
+        (*throttle_data)->replacement_.load(std::memory_order_acquire);
     if (new_throttle_data == nullptr) return;
     *throttle_data = new_throttle_data;
   }
@@ -85,10 +99,10 @@ bool ServerRetryThrottleData::RecordFailure() {
   ServerRetryThrottleData* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We decrement milli_tokens by 1000 (1 token) for each failure.
-  const uintptr_t new_value =
-      static_cast<uintptr_t>(gpr_atm_no_barrier_clamped_add(
-          &throttle_data->milli_tokens_, gpr_atm{-1000}, gpr_atm{0},
-          static_cast<gpr_atm>(throttle_data->max_milli_tokens_)));
+  const uintptr_t new_value = ClampedAdd<intptr_t>(
+      throttle_data->milli_tokens_, -1000, 0,
+      std::min<uintptr_t>(throttle_data->max_milli_tokens_,
+                          std::numeric_limits<intptr_t>::max()));
   // Retries are allowed as long as the new value is above the threshold
   // (max_milli_tokens / 2).
   return new_value > throttle_data->max_milli_tokens_ / 2;
@@ -99,10 +113,11 @@ void ServerRetryThrottleData::RecordSuccess() {
   ServerRetryThrottleData* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We increment milli_tokens by milli_token_ratio for each success.
-  gpr_atm_no_barrier_clamped_add(
-      &throttle_data->milli_tokens_,
-      static_cast<gpr_atm>(throttle_data->milli_token_ratio_), gpr_atm{0},
-      static_cast<gpr_atm>(throttle_data->max_milli_tokens_));
+  ClampedAdd<intptr_t>(
+      throttle_data->milli_tokens_, throttle_data->milli_token_ratio_, 0,
+      std::max<intptr_t>(
+          0, std::min<uintptr_t>(throttle_data->max_milli_tokens_,
+                                 std::numeric_limits<intptr_t>::max())));
 }
 
 //

data/src/core/client_channel/retry_throttle.h

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 
-#include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include <atomic>
 #include <map>
 #include <string>
 
@@ -58,11 +58,11 @@ class ServerRetryThrottleData final
 
   const uintptr_t max_milli_tokens_;
   const uintptr_t milli_token_ratio_;
-  gpr_atm milli_tokens_;
+  std::atomic<intptr_t> milli_tokens_;
   // A pointer to the replacement for this ServerRetryThrottleData entry.
   // If non-nullptr, then this entry is stale and must not be used.
   // We hold a reference to the replacement.
-  gpr_atm replacement_ = 0;
+  std::atomic<ServerRetryThrottleData*> replacement_{nullptr};
 };
 
 /// Global map of server name to retry throttle data.

data/src/core/client_channel/subchannel.cc

@@ -26,6 +26,7 @@
 #include <algorithm>
 #include <memory>
 #include <new>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
@@ -34,7 +35,6 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -431,8 +431,6 @@ class Subchannel::ConnectedSubchannelStateWatcher final
         c->backoff_.Reset();
       }
     }
-    // Drain any connectivity state notifications after releasing the mutex.
-    c->work_serializer_.DrainQueue();
   }
 
   WeakRefCountedPtr<Subchannel> subchannel_;
@@ -444,7 +442,7 @@ class Subchannel::ConnectedSubchannelStateWatcher final
 
 void Subchannel::ConnectivityStateWatcherList::AddWatcherLocked(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  watchers_.insert(std::make_pair(watcher.get(), std::move(watcher)));
+  watchers_.insert(std::move(watcher));
 }
 
 void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
@@ -454,14 +452,12 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     grpc_connectivity_state state, const absl::Status& status) {
-  for (const auto& p : watchers_) {
-    subchannel_->work_serializer_.Schedule(
-        [watcher = p.second->Ref(), state, status]() mutable {
-          auto* watcher_ptr = watcher.get();
-          watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
-                                                 status);
-        },
-        DEBUG_LOCATION);
+  for (const auto& watcher : watchers_) {
+    subchannel_->work_serializer_.Run([watcher = watcher->Ref(), state,
+                                       status]() mutable {
+      auto* watcher_ptr = watcher.get();
+      watcher_ptr->OnConnectivityStateChange(std::move(watcher), state, status);
+    });
   }
 }
 
@@ -473,7 +469,7 @@ namespace {
 
 BackOff::Options ParseArgsForBackoffValues(const ChannelArgs& args,
                                            Duration* min_connect_timeout) {
-  const absl::optional<Duration> fixed_reconnect_backoff =
+  const std::optional<Duration> fixed_reconnect_backoff =
       args.GetDurationFromIntMillis("grpc.testing.fixed_reconnect_backoff_ms");
   if (fixed_reconnect_backoff.has_value()) {
     const Duration backoff =
@@ -611,50 +607,36 @@ channelz::SubchannelNode* Subchannel::channelz_node() {
 
 void Subchannel::WatchConnectivityState(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  {
-    MutexLock lock(&mu_);
-    grpc_pollset_set* interested_parties = watcher->interested_parties();
-    if (interested_parties != nullptr) {
-      grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
-    }
-    work_serializer_.Schedule(
-        [watcher = watcher->Ref(), state = state_, status = status_]() mutable {
-          auto* watcher_ptr = watcher.get();
-          watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
-                                                 status);
-        },
-        DEBUG_LOCATION);
-    watcher_list_.AddWatcherLocked(std::move(watcher));
+  MutexLock lock(&mu_);
+  grpc_pollset_set* interested_parties = watcher->interested_parties();
+  if (interested_parties != nullptr) {
+    grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
+  work_serializer_.Run(
+      [watcher = watcher->Ref(), state = state_, status = status_]() mutable {
+        auto* watcher_ptr = watcher.get();
+        watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
+                                               status);
+      },
+      DEBUG_LOCATION);
+  watcher_list_.AddWatcherLocked(std::move(watcher));
 }
 
 void Subchannel::CancelConnectivityStateWatch(
     ConnectivityStateWatcherInterface* watcher) {
-  {
-    MutexLock lock(&mu_);
-    grpc_pollset_set* interested_parties = watcher->interested_parties();
-    if (interested_parties != nullptr) {
-      grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
-    }
-    watcher_list_.RemoveWatcherLocked(watcher);
+  MutexLock lock(&mu_);
+  grpc_pollset_set* interested_parties = watcher->interested_parties();
+  if (interested_parties != nullptr) {
+    grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  // (Shouldn't actually be necessary in this case, but better safe than
-  // sorry.)
-  work_serializer_.DrainQueue();
+  watcher_list_.RemoveWatcherLocked(watcher);
 }
 
 void Subchannel::RequestConnection() {
-  {
-    MutexLock lock(&mu_);
-    if (state_ == GRPC_CHANNEL_IDLE) {
-      StartConnectingLocked();
-    }
+  MutexLock lock(&mu_);
+  if (state_ == GRPC_CHANNEL_IDLE) {
+    StartConnectingLocked();
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
 }
 
 void Subchannel::ResetBackoff() {
@@ -662,18 +644,14 @@ void Subchannel::ResetBackoff() {
   // does not eliminate the last ref and destroy the Subchannel before the
   // method returns.
   auto self = WeakRef(DEBUG_LOCATION, "ResetBackoff");
-  {
-    MutexLock lock(&mu_);
-    backoff_.Reset();
-    if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
-        event_engine_->Cancel(retry_timer_handle_)) {
-      OnRetryTimerLocked();
-    } else if (state_ == GRPC_CHANNEL_CONNECTING) {
-      next_attempt_time_ = Timestamp::Now();
-    }
+  MutexLock lock(&mu_);
+  backoff_.Reset();
+  if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
+      event_engine_->Cancel(retry_timer_handle_)) {
+    OnRetryTimerLocked();
+  } else if (state_ == GRPC_CHANNEL_CONNECTING) {
+    next_attempt_time_ = Timestamp::Now();
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
 }
 
 void Subchannel::Orphaned() {
@@ -683,15 +661,11 @@ void Subchannel::Orphaned() {
     subchannel_pool_->UnregisterSubchannel(key_, this);
     subchannel_pool_.reset();
   }
-  {
-    MutexLock lock(&mu_);
-    CHECK(!shutdown_);
-    shutdown_ = true;
-    connector_.reset();
-    connected_subchannel_.reset();
-  }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
+  MutexLock lock(&mu_);
+  CHECK(!shutdown_);
+  shutdown_ = true;
+  connector_.reset();
+  connected_subchannel_.reset();
 }
 
 void Subchannel::GetOrAddDataProducer(
@@ -743,12 +717,8 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
 }
 
 void Subchannel::OnRetryTimer() {
-  {
-    MutexLock lock(&mu_);
-    OnRetryTimerLocked();
-  }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
+  MutexLock lock(&mu_);
+  OnRetryTimerLocked();
 }
 
 void Subchannel::OnRetryTimerLocked() {
@@ -782,8 +752,6 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
     MutexLock lock(&c->mu_);
     c->OnConnectingFinishedLocked(error);
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  c->work_serializer_.DrainQueue();
   c.reset(DEBUG_LOCATION, "Connect");
 }
 
@@ -810,7 +778,6 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
         time_until_next_attempt,
         [self = WeakRef(DEBUG_LOCATION, "RetryTimer")]() mutable {
           {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             self->OnRetryTimer();
             // Subchannel deletion might require an active ExecCtx. So if

data/src/core/client_channel/subchannel.h

@@ -27,6 +27,7 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
@@ -307,10 +308,9 @@ class Subchannel final : public DualRefCounted<Subchannel> {
 
    private:
     Subchannel* subchannel_;
-    // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
-    // be a set instead of a map.
-    std::map<ConnectivityStateWatcherInterface*,
-             RefCountedPtr<ConnectivityStateWatcherInterface>>
+    absl::flat_hash_set<RefCountedPtr<ConnectivityStateWatcherInterface>,
+                        RefCountedPtrHash<ConnectivityStateWatcherInterface>,
+                        RefCountedPtrEq<ConnectivityStateWatcherInterface>>
         watchers_;
   };
 

data/src/core/client_channel/subchannel_stream_client.cc

@@ -140,7 +140,6 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   }
   retry_timer_handle_ = event_engine_->RunAfter(
       timeout, [self = Ref(DEBUG_LOCATION, "health_retry_timer")]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         self->OnRetryTimer();
         self.reset(DEBUG_LOCATION, "health_retry_timer");

data/src/core/client_channel/subchannel_stream_client.h

@@ -25,11 +25,11 @@
 
 #include <atomic>
 #include <memory>
+#include <optional>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -172,7 +172,7 @@ class SubchannelStreamClient final
     grpc_closure recv_initial_metadata_ready_;
 
     // recv_message
-    absl::optional<SliceBuffer> recv_message_;
+    std::optional<SliceBuffer> recv_message_;
     grpc_closure recv_message_ready_;
     std::atomic<bool> seen_response_{false};
 
@@ -208,7 +208,7 @@ class SubchannelStreamClient final
 
   // Call retry state.
   BackOff retry_backoff_ ABSL_GUARDED_BY(mu_);
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       retry_timer_handle_ ABSL_GUARDED_BY(mu_);
   // A raw pointer will suffice since connected_subchannel_ holds a copy of the
   // ChannelArgs which holds an std::shared_ptr of the EventEngine.

data/src/core/config/config_vars.cc

@@ -22,6 +22,7 @@
 
 #include "absl/flags/flag.h"
 #include "absl/strings/escaping.h"
+#include "absl/types/optional.h"
 #include "src/core/config/load_config.h"
 
 #ifndef GPR_DEFAULT_LOG_VERBOSITY_STRING

data/src/core/config/config_vars.h

@@ -23,6 +23,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <optional>
 #include <string>
 
 #include "absl/strings/string_view.h"

data/src/core/config/load_config.cc

@@ -17,17 +17,18 @@
 #include <grpc/support/port_platform.h>
 #include <stdio.h>
 
+#include <optional>
+
 #include "absl/flags/marshalling.h"
 #include "absl/log/check.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_join.h"
-#include "absl/types/optional.h"
 #include "src/core/util/env.h"
 
 namespace grpc_core {
 
 namespace {
-absl::optional<std::string> LoadEnv(absl::string_view environment_variable) {
+std::optional<std::string> LoadEnv(absl::string_view environment_variable) {
   return GetEnv(std::string(environment_variable).c_str());
 }
 }  // namespace