grpc 1.72.0 → 1.74.0.pre2

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

@@ -537,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_
@@ -562,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";
@@ -1471,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()

data/src/core/client_channel/retry_filter_legacy_call_data.h

@@ -370,7 +370,7 @@ class RetryFilter::LegacyCallData final {
 
   RetryFilter* chand_;
   grpc_polling_entity* pollent_;
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
   const internal::RetryMethodConfig* retry_policy_ = nullptr;
   BackOff retry_backoff_;
 

data/src/core/client_channel/retry_interceptor.cc

@@ -35,11 +35,10 @@ size_t GetMaxPerRpcRetryBufferSize(const ChannelArgs& args) {
 
 namespace retry_detail {
 
-RetryState::RetryState(
-    const internal::RetryMethodConfig* retry_policy,
-    RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data)
+RetryState::RetryState(const internal::RetryMethodConfig* retry_policy,
+                       RefCountedPtr<internal::RetryThrottler> retry_throttler)
     : retry_policy_(retry_policy),
-      retry_throttle_data_(std::move(retry_throttle_data)),
+      retry_throttler_(std::move(retry_throttler)),
       retry_backoff_(
           BackOff::Options()
               .set_initial_backoff(retry_policy_ == nullptr
@@ -67,8 +66,8 @@ std::optional<Duration> RetryState::ShouldRetry(
   const auto status = md.get(GrpcStatusMetadata());
   if (status.has_value()) {
     if (GPR_LIKELY(*status == GRPC_STATUS_OK)) {
-      if (retry_throttle_data_ != nullptr) {
-        retry_throttle_data_->RecordSuccess();
+      if (retry_throttler_ != nullptr) {
+        retry_throttler_->RecordSuccess();
       }
       GRPC_TRACE_LOG(retry, INFO)
           << lazy_attempt_debug_string() << " call succeeded";
@@ -89,8 +88,7 @@ std::optional<Duration> RetryState::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 (retry_throttle_data_ != nullptr &&
-      !retry_throttle_data_->RecordFailure()) {
+  if (retry_throttler_ != nullptr && !retry_throttler_->RecordFailure()) {
     GRPC_TRACE_LOG(retry, INFO)
         << lazy_attempt_debug_string() << " retries throttled";
     return std::nullopt;
@@ -131,55 +129,43 @@ std::optional<Duration> RetryState::ShouldRetry(
   return next_attempt_timeout;
 }
 
-absl::StatusOr<RefCountedPtr<internal::ServerRetryThrottleData>>
-ServerRetryThrottleDataFromChannelArgs(const ChannelArgs& args) {
-  // Get retry throttling parameters from service config.
-  auto* service_config = args.GetObject<ServiceConfig>();
-  if (service_config == nullptr) return nullptr;
-  const auto* config = static_cast<const internal::RetryGlobalConfig*>(
-      service_config->GetGlobalParsedConfig(
-          internal::RetryServiceConfigParser::ParserIndex()));
-  if (config == nullptr) return nullptr;
-  // Get server name from target URI.
-  auto server_uri = args.GetString(GRPC_ARG_SERVER_URI);
-  if (!server_uri.has_value()) {
-    return GRPC_ERROR_CREATE(
-        "server URI channel arg missing or wrong type in client channel "
-        "filter");
-  }
-  absl::StatusOr<URI> uri = URI::Parse(*server_uri);
-  if (!uri.ok() || uri->path().empty()) {
-    return GRPC_ERROR_CREATE("could not extract server name from target URI");
-  }
-  std::string server_name(absl::StripPrefix(uri->path(), "/"));
-  // Get throttling config for server_name.
-  return internal::ServerRetryThrottleMap::Get()->GetDataForServer(
-      server_name, config->max_milli_tokens(), config->milli_token_ratio());
-}
-
 }  // namespace retry_detail
 
 ////////////////////////////////////////////////////////////////////////////////
 // RetryInterceptor
 
 absl::StatusOr<RefCountedPtr<RetryInterceptor>> RetryInterceptor::Create(
-    const ChannelArgs& args, const FilterArgs&) {
-  auto retry_throttle_data =
-      retry_detail::ServerRetryThrottleDataFromChannelArgs(args);
-  if (!retry_throttle_data.ok()) {
-    return retry_throttle_data.status();
+    const ChannelArgs& args, const FilterArgs& filter_args) {
+  auto retry_throttler = filter_args.GetState<internal::RetryThrottler>("");
+  return MakeRefCounted<RetryInterceptor>(args, std::move(retry_throttler));
+}
+
+void RetryInterceptor::UpdateBlackboard(const ServiceConfig& service_config,
+                                        const Blackboard* old_blackboard,
+                                        Blackboard* new_blackboard) {
+  const auto* config = static_cast<const internal::RetryGlobalConfig*>(
+      service_config.GetGlobalParsedConfig(
+          internal::RetryServiceConfigParser::ParserIndex()));
+  if (config == nullptr) return;
+  // Get existing throttle state.
+  RefCountedPtr<internal::RetryThrottler> throttler;
+  if (old_blackboard != nullptr) {
+    throttler = old_blackboard->Get<internal::RetryThrottler>("");
   }
-  return MakeRefCounted<RetryInterceptor>(args,
-                                          std::move(*retry_throttle_data));
+  throttler = internal::RetryThrottler::Create(config->max_milli_tokens(),
+                                               config->milli_token_ratio(),
+                                               std::move(throttler));
+  CHECK_NE(new_blackboard, nullptr);
+  new_blackboard->Set("", std::move(throttler));
 }
 
 RetryInterceptor::RetryInterceptor(
     const ChannelArgs& args,
-    RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data)
+    RefCountedPtr<internal::RetryThrottler> retry_throttler)
     : per_rpc_retry_buffer_size_(GetMaxPerRpcRetryBufferSize(args)),
       service_config_parser_index_(
           internal::RetryServiceConfigParser::ParserIndex()),
-      retry_throttle_data_(std::move(retry_throttle_data)) {}
+      retry_throttler_(std::move(retry_throttler)) {}
 
 void RetryInterceptor::InterceptCall(
     UnstartedCallHandler unstarted_call_handler) {
@@ -206,7 +192,7 @@ RetryInterceptor::Call::Call(RefCountedPtr<RetryInterceptor> interceptor,
     : call_handler_(std::move(call_handler)),
       interceptor_(std::move(interceptor)),
       retry_state_(interceptor_->GetRetryPolicy(),
-                   interceptor_->retry_throttle_data_) {
+                   interceptor_->retry_throttler_) {
   GRPC_TRACE_LOG(retry, INFO)
       << DebugTag() << " retry call created: " << retry_state_;
 }

data/src/core/client_channel/retry_interceptor.h

@@ -26,11 +26,11 @@
 namespace grpc_core {
 
 namespace retry_detail {
+
 class RetryState {
  public:
-  RetryState(
-      const internal::RetryMethodConfig* retry_policy,
-      RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data);
+  RetryState(const internal::RetryMethodConfig* retry_policy,
+             RefCountedPtr<internal::RetryThrottler> retry_throttler);
 
   // if nullopt --> commit & don't retry
   // if duration --> retry after duration
@@ -41,36 +41,37 @@ class RetryState {
 
   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_));
+    sink.Append(absl::StrCat("policy:{",
+                             state.retry_policy_ != nullptr
+                                 ? absl::StrCat(*state.retry_policy_)
+                                 : "none",
+                             "} throttler:", state.retry_throttler_ != nullptr,
+                             " attempts:", state.num_attempts_completed_));
   }
 
  private:
   const internal::RetryMethodConfig* const retry_policy_;
-  RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
   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);
+  RetryInterceptor(const ChannelArgs& args,
+                   RefCountedPtr<internal::RetryThrottler> retry_throttler);
 
   static absl::StatusOr<RefCountedPtr<RetryInterceptor>> Create(
-      const ChannelArgs& args, const FilterArgs&);
+      const ChannelArgs& args, const FilterArgs& filter_args);
 
   void Orphaned() override {}
 
+  static void UpdateBlackboard(const ServiceConfig& service_config,
+                               const Blackboard* old_blackboard,
+                               Blackboard* new_blackboard);
+
  protected:
   void InterceptCall(UnstartedCallHandler unstarted_call_handler) override;
 
@@ -149,7 +150,7 @@ class RetryInterceptor : public Interceptor {
 
   const size_t per_rpc_retry_buffer_size_;
   const size_t service_config_parser_index_;
-  const RefCountedPtr<internal::ServerRetryThrottleData> retry_throttle_data_;
+  const RefCountedPtr<internal::RetryThrottler> retry_throttler_;
 };
 
 }  // namespace grpc_core

data/src/core/client_channel/retry_throttle.cc

@@ -18,14 +18,9 @@
 
 #include "src/core/client_channel/retry_throttle.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"
 
@@ -33,6 +28,7 @@ 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);
@@ -43,45 +39,74 @@ T ClampedAdd(std::atomic<T>& value, T delta, T min, T max) {
                                         std::memory_order_relaxed));
   return new_value;
 }
+
 }  // namespace
 
 //
-// ServerRetryThrottleData
+// RetryThrottler
 //
 
-ServerRetryThrottleData::ServerRetryThrottleData(uintptr_t max_milli_tokens,
-                                                 uintptr_t milli_token_ratio,
-                                                 uintptr_t milli_tokens)
+RefCountedPtr<RetryThrottler> RetryThrottler::Create(
+    uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+    RefCountedPtr<RetryThrottler> previous) {
+  if (previous != nullptr && previous->max_milli_tokens_ == max_milli_tokens &&
+      previous->milli_token_ratio_ == milli_token_ratio) {
+    return previous;
+  }
+  // previous is null or has different parameters.  Create a new one.
+  uintptr_t initial_milli_tokens = max_milli_tokens;
+  // If there was a pre-existing entry for this server name, initialize
+  // the token count by scaling proportionately to the old data.  This
+  // ensures that if we're already throttling retries on the old scale,
+  // we will start out doing the same thing on the new one.
+  if (previous != nullptr) {
+    double token_fraction = static_cast<double>(previous->milli_tokens_) /
+                            static_cast<double>(previous->max_milli_tokens_);
+    initial_milli_tokens =
+        static_cast<uintptr_t>(token_fraction * max_milli_tokens);
+  }
+  auto throttle_data = MakeRefCounted<RetryThrottler>(
+      max_milli_tokens, milli_token_ratio, initial_milli_tokens);
+  if (previous != nullptr) previous->SetReplacement(throttle_data);
+  return throttle_data;
+}
+
+UniqueTypeName RetryThrottler::Type() {
+  static UniqueTypeName::Factory factory("retry_throttle");
+  return factory.Create();
+}
+
+RetryThrottler::RetryThrottler(uintptr_t max_milli_tokens,
+                               uintptr_t milli_token_ratio,
+                               uintptr_t milli_tokens)
     : max_milli_tokens_(max_milli_tokens),
       milli_token_ratio_(milli_token_ratio),
       milli_tokens_(milli_tokens) {}
 
-ServerRetryThrottleData::~ServerRetryThrottleData() {
-  ServerRetryThrottleData* replacement =
-      replacement_.load(std::memory_order_acquire);
+RetryThrottler::~RetryThrottler() {
+  RetryThrottler* replacement = replacement_.load(std::memory_order_acquire);
   if (replacement != nullptr) {
     replacement->Unref();
   }
 }
 
-void ServerRetryThrottleData::SetReplacement(
-    RefCountedPtr<ServerRetryThrottleData> replacement) {
+void RetryThrottler::SetReplacement(RefCountedPtr<RetryThrottler> replacement) {
   replacement_.store(replacement.release(), std::memory_order_release);
 }
 
-void ServerRetryThrottleData::GetReplacementThrottleDataIfNeeded(
-    ServerRetryThrottleData** throttle_data) {
+void RetryThrottler::GetReplacementThrottleDataIfNeeded(
+    RetryThrottler** throttle_data) {
   while (true) {
-    ServerRetryThrottleData* new_throttle_data =
+    RetryThrottler* new_throttle_data =
         (*throttle_data)->replacement_.load(std::memory_order_acquire);
     if (new_throttle_data == nullptr) return;
     *throttle_data = new_throttle_data;
   }
 }
 
-bool ServerRetryThrottleData::RecordFailure() {
+bool RetryThrottler::RecordFailure() {
   // First, check if we are stale and need to be replaced.
-  ServerRetryThrottleData* throttle_data = this;
+  RetryThrottler* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We decrement milli_tokens by 1000 (1 token) for each failure.
   const uintptr_t new_value = ClampedAdd<intptr_t>(
@@ -93,9 +118,9 @@ bool ServerRetryThrottleData::RecordFailure() {
   return new_value > throttle_data->max_milli_tokens_ / 2;
 }
 
-void ServerRetryThrottleData::RecordSuccess() {
+void RetryThrottler::RecordSuccess() {
   // First, check if we are stale and need to be replaced.
-  ServerRetryThrottleData* throttle_data = this;
+  RetryThrottler* throttle_data = this;
   GetReplacementThrottleDataIfNeeded(&throttle_data);
   // We increment milli_tokens by milli_token_ratio for each success.
   ClampedAdd<intptr_t>(
@@ -105,45 +130,5 @@ void ServerRetryThrottleData::RecordSuccess() {
                                  std::numeric_limits<intptr_t>::max())));
 }
 
-//
-// ServerRetryThrottleMap
-//
-
-ServerRetryThrottleMap* ServerRetryThrottleMap::Get() {
-  static ServerRetryThrottleMap* m = new ServerRetryThrottleMap();
-  return m;
-}
-
-RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
-    const std::string& server_name, uintptr_t max_milli_tokens,
-    uintptr_t milli_token_ratio) {
-  MutexLock lock(&mu_);
-  auto& throttle_data = map_[server_name];
-  if (throttle_data == nullptr ||
-      throttle_data->max_milli_tokens() != max_milli_tokens ||
-      throttle_data->milli_token_ratio() != milli_token_ratio) {
-    // Entry not found, or found with old parameters.  Create a new one.
-    auto old_throttle_data = std::move(throttle_data);
-    uintptr_t initial_milli_tokens = max_milli_tokens;
-    // If there was a pre-existing entry for this server name, initialize
-    // the token count by scaling proportionately to the old data.  This
-    // ensures that if we're already throttling retries on the old scale,
-    // we will start out doing the same thing on the new one.
-    if (old_throttle_data != nullptr) {
-      double token_fraction =
-          static_cast<double>(old_throttle_data->milli_tokens()) /
-          static_cast<double>(old_throttle_data->max_milli_tokens());
-      initial_milli_tokens =
-          static_cast<uintptr_t>(token_fraction * max_milli_tokens);
-    }
-    throttle_data = MakeRefCounted<ServerRetryThrottleData>(
-        max_milli_tokens, milli_token_ratio, initial_milli_tokens);
-    if (old_throttle_data != nullptr) {
-      old_throttle_data->SetReplacement(throttle_data);
-    }
-  }
-  return throttle_data;
-}
-
 }  // namespace internal
 }  // namespace grpc_core

data/src/core/client_channel/retry_throttle.h

@@ -19,30 +19,29 @@
 #ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_THROTTLE_H
 
-#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <atomic>
-#include <map>
-#include <string>
 
-#include "absl/base/thread_annotations.h"
-#include "src/core/util/ref_counted.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 namespace internal {
 
-class ServerRetryThrottleMap;
-
 /// Tracks retry throttling data for an individual server name.
-class ServerRetryThrottleData final
-    : public RefCounted<ServerRetryThrottleData> {
+class RetryThrottler final : public Blackboard::Entry {
  public:
-  ServerRetryThrottleData(uintptr_t max_milli_tokens,
-                          uintptr_t milli_token_ratio, uintptr_t milli_tokens);
-  ~ServerRetryThrottleData() override;
+  static RefCountedPtr<RetryThrottler> Create(
+      uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+      RefCountedPtr<RetryThrottler> previous);
+
+  static UniqueTypeName Type();
+
+  // Do not instantiate directly -- use Create() instead.
+  RetryThrottler(uintptr_t max_milli_tokens, uintptr_t milli_token_ratio,
+                 uintptr_t milli_tokens);
+  ~RetryThrottler() override;
 
   /// Records a failure.  Returns true if it's okay to send a retry.
   bool RecordFailure();
@@ -50,6 +49,7 @@ class ServerRetryThrottleData final
   /// Records a success.
   void RecordSuccess();
 
+  // Exposed for testing purposes only.
   uintptr_t max_milli_tokens() const { return max_milli_tokens_; }
   uintptr_t milli_token_ratio() const { return milli_token_ratio_; }
   intptr_t milli_tokens() const {
@@ -57,39 +57,17 @@ class ServerRetryThrottleData final
   }
 
  private:
-  friend ServerRetryThrottleMap;
+  void SetReplacement(RefCountedPtr<RetryThrottler> replacement);
 
-  void SetReplacement(RefCountedPtr<ServerRetryThrottleData> replacement);
-
-  void GetReplacementThrottleDataIfNeeded(
-      ServerRetryThrottleData** throttle_data);
+  void GetReplacementThrottleDataIfNeeded(RetryThrottler** throttle_data);
 
   const uintptr_t max_milli_tokens_;
   const uintptr_t milli_token_ratio_;
   std::atomic<intptr_t> milli_tokens_;
-  // A pointer to the replacement for this ServerRetryThrottleData entry.
+  // A pointer to the replacement for this RetryThrottler entry.
   // If non-nullptr, then this entry is stale and must not be used.
   // We hold a reference to the replacement.
-  std::atomic<ServerRetryThrottleData*> replacement_{nullptr};
-};
-
-/// Global map of server name to retry throttle data.
-class ServerRetryThrottleMap final {
- public:
-  static ServerRetryThrottleMap* Get();
-
-  /// Returns the failure data for \a server_name, creating a new entry if
-  /// needed.
-  RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
-      const std::string& server_name, uintptr_t max_milli_tokens,
-      uintptr_t milli_token_ratio);
-
- private:
-  using StringToDataMap =
-      std::map<std::string, RefCountedPtr<ServerRetryThrottleData>>;
-
-  Mutex mu_;
-  StringToDataMap map_ ABSL_GUARDED_BY(mu_);
+  std::atomic<RetryThrottler*> replacement_{nullptr};
 };
 
 }  // namespace internal