grpc 1.57.0 → 1.58.0.pre1

data/src/core/lib/channel/channel_args.cc

@@ -27,6 +27,8 @@
 #include <algorithm>
 #include <initializer_list>
 #include <map>
+#include <memory>
+#include <string>
 #include <vector>
 
 #include "absl/strings/match.h"
@@ -34,16 +36,41 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/match.h"
 
 namespace grpc_core {
 
+const grpc_arg_pointer_vtable ChannelArgs::Value::int_vtable_{
+    // copy
+    [](void* p) { return p; },
+    // destroy
+    [](void*) {},
+    // cmp
+    [](void* p1, void* p2) -> int {
+      return QsortCompare(reinterpret_cast<intptr_t>(p1),
+                          reinterpret_cast<intptr_t>(p2));
+    },
+};
+
+const grpc_arg_pointer_vtable ChannelArgs::Value::string_vtable_{
+    // copy
+    [](void* p) -> void* {
+      return static_cast<RefCountedString*>(p)->Ref().release();
+    },
+    // destroy
+    [](void* p) { static_cast<RefCountedString*>(p)->Unref(); },
+    // cmp
+    [](void* p1, void* p2) -> int {
+      return QsortCompare(static_cast<RefCountedString*>(p1)->as_string_view(),
+                          static_cast<RefCountedString*>(p2)->as_string_view());
+    },
+};
+
 ChannelArgs::Pointer::Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
     : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
 
@@ -99,7 +126,7 @@ bool ChannelArgs::WantMinimalStack() const {
   return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
 }
 
-ChannelArgs::ChannelArgs(AVL<std::string, Value> args)
+ChannelArgs::ChannelArgs(AVL<RefCountedStringValue, Value> args)
     : args_(std::move(args)) {}
 
 ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
@@ -129,54 +156,25 @@ ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
 
 grpc_arg ChannelArgs::Value::MakeCArg(const char* name) const {
   char* c_name = const_cast<char*>(name);
-  return Match(
-      rep_,
-      [c_name](int i) { return grpc_channel_arg_integer_create(c_name, i); },
-      [c_name](const std::shared_ptr<const std::string>& s) {
-        return grpc_channel_arg_string_create(c_name,
-                                              const_cast<char*>(s->c_str()));
-      },
-      [c_name](const Pointer& p) {
-        return grpc_channel_arg_pointer_create(c_name, p.c_pointer(),
-                                               p.c_vtable());
-      });
-}
-
-bool ChannelArgs::Value::operator<(const Value& rhs) const {
-  if (rhs.rep_.index() != rep_.index()) return rep_.index() < rhs.rep_.index();
-  switch (rep_.index()) {
-    case 0:
-      return absl::get<int>(rep_) < absl::get<int>(rhs.rep_);
-    case 1:
-      return *absl::get<std::shared_ptr<const std::string>>(rep_) <
-             *absl::get<std::shared_ptr<const std::string>>(rhs.rep_);
-    case 2:
-      return absl::get<Pointer>(rep_) < absl::get<Pointer>(rhs.rep_);
-    default:
-      Crash("unreachable");
+  if (rep_.c_vtable() == &int_vtable_) {
+    return grpc_channel_arg_integer_create(
+        c_name, reinterpret_cast<intptr_t>(rep_.c_pointer()));
   }
-}
-
-bool ChannelArgs::Value::operator==(const Value& rhs) const {
-  if (rhs.rep_.index() != rep_.index()) return false;
-  switch (rep_.index()) {
-    case 0:
-      return absl::get<int>(rep_) == absl::get<int>(rhs.rep_);
-    case 1:
-      return *absl::get<std::shared_ptr<const std::string>>(rep_) ==
-             *absl::get<std::shared_ptr<const std::string>>(rhs.rep_);
-    case 2:
-      return absl::get<Pointer>(rep_) == absl::get<Pointer>(rhs.rep_);
-    default:
-      Crash("unreachable");
+  if (rep_.c_vtable() == &string_vtable_) {
+    return grpc_channel_arg_string_create(
+        c_name, const_cast<char*>(
+                    static_cast<RefCountedString*>(rep_.c_pointer())->c_str()));
   }
+  return grpc_channel_arg_pointer_create(c_name, rep_.c_pointer(),
+                                         rep_.c_vtable());
 }
 
 ChannelArgs::CPtr ChannelArgs::ToC() const {
   std::vector<grpc_arg> c_args;
-  args_.ForEach([&c_args](const std::string& key, const Value& value) {
-    c_args.push_back(value.MakeCArg(key.c_str()));
-  });
+  args_.ForEach(
+      [&c_args](const RefCountedStringValue& key, const Value& value) {
+        c_args.push_back(value.MakeCArg(key.c_str()));
+      });
   return CPtr(static_cast<const grpc_channel_args*>(
       grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size())));
 }
@@ -190,7 +188,10 @@ ChannelArgs ChannelArgs::Set(absl::string_view name, int value) const {
 }
 
 ChannelArgs ChannelArgs::Set(absl::string_view name, Value value) const {
-  return ChannelArgs(args_.Add(std::string(name), std::move(value)));
+  if (const auto* p = args_.Lookup(name)) {
+    if (*p == value) return *this;  // already have this value for this key
+  }
+  return ChannelArgs(args_.Add(RefCountedStringValue(name), std::move(value)));
 }
 
 ChannelArgs ChannelArgs::Set(absl::string_view name,
@@ -207,26 +208,23 @@ ChannelArgs ChannelArgs::Set(absl::string_view name, std::string value) const {
 }
 
 ChannelArgs ChannelArgs::Remove(absl::string_view name) const {
+  if (args_.Lookup(name) == nullptr) return *this;
   return ChannelArgs(args_.Remove(name));
 }
 
 ChannelArgs ChannelArgs::RemoveAllKeysWithPrefix(
     absl::string_view prefix) const {
-  ChannelArgs result;
-  args_.ForEach([&](const std::string& key, const Value& value) {
-    if (!absl::StartsWith(key, prefix)) {
-      result.args_ = result.args_.Add(key, value);
-    }
+  auto args = args_;
+  args_.ForEach([&](const RefCountedStringValue& key, const Value&) {
+    if (absl::StartsWith(key.as_string_view(), prefix)) args = args.Remove(key);
   });
-  return result;
+  return ChannelArgs(std::move(args));
 }
 
 absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  const auto* i = v->GetIfInt();
-  if (i == nullptr) return absl::nullopt;
-  return *i;
+  return v->GetIfInt();
 }
 
 absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
@@ -242,9 +240,9 @@ absl::optional<absl::string_view> ChannelArgs::GetString(
     absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  const auto* s = v->GetIfString();
+  const auto s = v->GetIfString();
   if (s == nullptr) return absl::nullopt;
-  return *s;
+  return s->as_string_view();
 }
 
 absl::optional<std::string> ChannelArgs::GetOwnedString(
@@ -265,8 +263,8 @@ void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
 absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return absl::nullopt;
-  auto* i = v->GetIfInt();
-  if (i == nullptr) {
+  auto i = v->GetIfInt();
+  if (!i.has_value()) {
     gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
             std::string(name).c_str());
     return absl::nullopt;
@@ -283,19 +281,24 @@ absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   }
 }
 
+std::string ChannelArgs::Value::ToString() const {
+  if (rep_.c_vtable() == &int_vtable_) {
+    return std::to_string(reinterpret_cast<intptr_t>(rep_.c_pointer()));
+  }
+  if (rep_.c_vtable() == &string_vtable_) {
+    return std::string(
+        static_cast<RefCountedString*>(rep_.c_pointer())->as_string_view());
+  }
+  return absl::StrFormat("%p", rep_.c_pointer());
+}
+
 std::string ChannelArgs::ToString() const {
   std::vector<std::string> arg_strings;
-  args_.ForEach([&arg_strings](const std::string& key, const Value& value) {
-    std::string value_str;
-    if (auto* i = value.GetIfInt()) {
-      value_str = std::to_string(*i);
-    } else if (auto* s = value.GetIfString()) {
-      value_str = *s;
-    } else if (auto* p = value.GetIfPointer()) {
-      value_str = absl::StrFormat("%p", p->c_pointer());
-    }
-    arg_strings.push_back(absl::StrCat(key, "=", value_str));
-  });
+  args_.ForEach(
+      [&arg_strings](const RefCountedStringValue& key, const Value& value) {
+        arg_strings.push_back(
+            absl::StrCat(key.as_string_view(), "=", value.ToString()));
+      });
   return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
 }
 
@@ -303,24 +306,26 @@ ChannelArgs ChannelArgs::UnionWith(ChannelArgs other) const {
   if (args_.Empty()) return other;
   if (other.args_.Empty()) return *this;
   if (args_.Height() <= other.args_.Height()) {
-    args_.ForEach([&other](const std::string& key, const Value& value) {
-      other.args_ = other.args_.Add(key, value);
-    });
+    args_.ForEach(
+        [&other](const RefCountedStringValue& key, const Value& value) {
+          other.args_ = other.args_.Add(key, value);
+        });
     return other;
   } else {
     auto result = *this;
-    other.args_.ForEach([&result](const std::string& key, const Value& value) {
-      if (result.args_.Lookup(key) == nullptr) {
-        result.args_ = result.args_.Add(key, value);
-      }
-    });
+    other.args_.ForEach(
+        [&result](const RefCountedStringValue& key, const Value& value) {
+          if (result.args_.Lookup(key) == nullptr) {
+            result.args_ = result.args_.Add(key, value);
+          }
+        });
     return result;
   }
 }
 
 ChannelArgs ChannelArgs::FuzzingReferenceUnionWith(ChannelArgs other) const {
   // DO NOT OPTIMIZE THIS!!
-  args_.ForEach([&other](const std::string& key, const Value& value) {
+  args_.ForEach([&other](const RefCountedStringValue& key, const Value& value) {
     other.args_ = other.args_.Add(key, value);
   });
   return other;

data/src/core/lib/channel/channel_args.h

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include <algorithm>  // IWYU pragma: keep
 #include <iosfwd>
@@ -33,7 +34,6 @@
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
@@ -44,6 +44,7 @@
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
@@ -283,32 +284,43 @@ class ChannelArgs {
 
   class Value {
    public:
-    explicit Value(int n) : rep_(n) {}
+    explicit Value(int n) : rep_(reinterpret_cast<void*>(n), &int_vtable_) {}
     explicit Value(std::string s)
-        : rep_(std::make_shared<const std::string>(std::move(s))) {}
+        : rep_(RefCountedString::Make(s).release(), &string_vtable_) {}
     explicit Value(Pointer p) : rep_(std::move(p)) {}
 
-    const int* GetIfInt() const { return absl::get_if<int>(&rep_); }
-    const std::string* GetIfString() const {
-      auto* p = absl::get_if<std::shared_ptr<const std::string>>(&rep_);
-      if (p == nullptr) return nullptr;
-      return p->get();
+    absl::optional<int> GetIfInt() const {
+      if (rep_.c_vtable() != &int_vtable_) return absl::nullopt;
+      return reinterpret_cast<intptr_t>(rep_.c_pointer());
+    }
+    RefCountedPtr<RefCountedString> GetIfString() const {
+      if (rep_.c_vtable() != &string_vtable_) return nullptr;
+      return static_cast<RefCountedString*>(rep_.c_pointer())->Ref();
+    }
+    const Pointer* GetIfPointer() const {
+      if (rep_.c_vtable() == &int_vtable_) return nullptr;
+      if (rep_.c_vtable() == &string_vtable_) return nullptr;
+      return &rep_;
     }
-    const Pointer* GetIfPointer() const { return absl::get_if<Pointer>(&rep_); }
+
+    std::string ToString() const;
 
     grpc_arg MakeCArg(const char* name) const;
 
-    bool operator<(const Value& rhs) const;
-    bool operator==(const Value& rhs) const;
+    bool operator<(const Value& rhs) const { return rep_ < rhs.rep_; }
+    bool operator==(const Value& rhs) const { return rep_ == rhs.rep_; }
     bool operator!=(const Value& rhs) const { return !this->operator==(rhs); }
     bool operator==(absl::string_view rhs) const {
-      auto* p = absl::get_if<std::shared_ptr<const std::string>>(&rep_);
-      if (p == nullptr) return false;
-      return **p == rhs;
+      auto str = GetIfString();
+      if (str == nullptr) return false;
+      return str->as_string_view() == rhs;
     }
 
    private:
-    absl::variant<int, std::shared_ptr<const std::string>, Pointer> rep_;
+    static const grpc_arg_pointer_vtable int_vtable_;
+    static const grpc_arg_pointer_vtable string_vtable_;
+
+    Pointer rep_;
   };
 
   struct ChannelArgsDeleter {
@@ -462,12 +474,12 @@ class ChannelArgs {
   std::string ToString() const;
 
  private:
-  explicit ChannelArgs(AVL<std::string, Value> args);
+  explicit ChannelArgs(AVL<RefCountedStringValue, Value> args);
 
   GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
                                        Value value) const;
 
-  AVL<std::string, Value> args_;
+  AVL<RefCountedStringValue, Value> args_;
 };
 
 std::ostream& operator<<(std::ostream& out, const ChannelArgs& args);

data/src/core/lib/channel/connected_channel.cc

@@ -57,7 +57,6 @@
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"

data/src/core/lib/channel/promise_based_filter.cc

@@ -38,7 +38,7 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/seq.h"
 #include "src/core/lib/slice/slice.h"
 
 extern grpc_core::TraceFlag grpc_trace_channel;
@@ -302,6 +302,9 @@ BaseCallData::Flusher::~Flusher() {
     gpr_log(GPR_INFO, "FLUSHER:forward batch: %s",
             grpc_transport_stream_op_batch_string(release_[0], false).c_str());
   }
+  if (call_->call_context_ != nullptr && call_->call_context_->traced()) {
+    release_[0]->is_traced = true;
+  }
   grpc_call_next_op(call_->elem(), release_[0]);
   GRPC_CALL_STACK_UNREF(call_->call_stack(), "flusher");
 }

data/src/core/lib/compression/compression_internal.cc

@@ -32,6 +32,8 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/surface/api_trace.h"
 
 namespace grpc_core {
@@ -227,11 +229,13 @@ absl::optional<grpc_compression_algorithm>
 DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args) {
   auto* value = args.Get(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
   if (value == nullptr) return absl::nullopt;
-  if (auto* p = value->GetIfInt()) {
-    return static_cast<grpc_compression_algorithm>(*p);
+  auto ival = value->GetIfInt();
+  if (ival.has_value()) {
+    return static_cast<grpc_compression_algorithm>(*ival);
   }
-  if (auto* p = value->GetIfString()) {
-    return ParseCompressionAlgorithm(*p);
+  auto sval = value->GetIfString();
+  if (sval != nullptr) {
+    return ParseCompressionAlgorithm(sval->as_string_view());
   }
   return absl::nullopt;
 }

data/src/core/lib/debug/stats_data.cc

@@ -54,6 +54,19 @@ Histogram_16777216_20 operator-(const Histogram_16777216_20& left,
   }
   return result;
 }
+void HistogramCollector_10000_20::Collect(Histogram_10000_20* result) const {
+  for (int i = 0; i < 20; i++) {
+    result->buckets_[i] += buckets_[i].load(std::memory_order_relaxed);
+  }
+}
+Histogram_10000_20 operator-(const Histogram_10000_20& left,
+                             const Histogram_10000_20& right) {
+  Histogram_10000_20 result;
+  for (int i = 0; i < 20; i++) {
+    result.buckets_[i] = left.buckets_[i] - right.buckets_[i];
+  }
+  return result;
+}
 void HistogramCollector_80_10::Collect(Histogram_80_10* result) const {
   for (int i = 0; i < 10; i++) {
     result->buckets_[i] += buckets_[i].load(std::memory_order_relaxed);
@@ -69,15 +82,25 @@ Histogram_80_10 operator-(const Histogram_80_10& left,
 }
 const absl::string_view
     GlobalStats::counter_name[static_cast<int>(Counter::COUNT)] = {
-        "client_calls_created",    "server_calls_created",
-        "client_channels_created", "client_subchannels_created",
-        "server_channels_created", "insecure_connections_created",
-        "syscall_write",           "syscall_read",
-        "tcp_read_alloc_8k",       "tcp_read_alloc_64k",
-        "http2_settings_writes",   "http2_pings_sent",
-        "http2_writes_begun",      "http2_transport_stalls",
-        "http2_stream_stalls",     "cq_pluck_creates",
-        "cq_next_creates",         "cq_callback_creates",
+        "client_calls_created",
+        "server_calls_created",
+        "client_channels_created",
+        "client_subchannels_created",
+        "server_channels_created",
+        "insecure_connections_created",
+        "syscall_write",
+        "syscall_read",
+        "tcp_read_alloc_8k",
+        "tcp_read_alloc_64k",
+        "http2_settings_writes",
+        "http2_pings_sent",
+        "http2_writes_begun",
+        "http2_transport_stalls",
+        "http2_stream_stalls",
+        "cq_pluck_creates",
+        "cq_next_creates",
+        "cq_callback_creates",
+        "wrr_updates",
 };
 const absl::string_view GlobalStats::counter_doc[static_cast<int>(
     Counter::COUNT)] = {
@@ -105,12 +128,15 @@ const absl::string_view GlobalStats::counter_doc[static_cast<int>(
     "usage)",
     "Number of completion queues created for cq_callback (indicates callback "
     "api usage)",
+    "Number of wrr updates that have been received",
 };
-const absl::string_view GlobalStats::histogram_name[static_cast<int>(
-    Histogram::COUNT)] = {
-    "call_initial_size",       "tcp_write_size",      "tcp_write_iov_size",
-    "tcp_read_size",           "tcp_read_offer",      "tcp_read_offer_iov_size",
-    "http2_send_message_size", "http2_metadata_size",
+const absl::string_view
+    GlobalStats::histogram_name[static_cast<int>(Histogram::COUNT)] = {
+        "call_initial_size",        "tcp_write_size",
+        "tcp_write_iov_size",       "tcp_read_size",
+        "tcp_read_offer",           "tcp_read_offer_iov_size",
+        "http2_send_message_size",  "http2_metadata_size",
+        "wrr_subchannel_list_size", "wrr_subchannel_ready_size",
 };
 const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     Histogram::COUNT)] = {
@@ -122,6 +148,8 @@ const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     "Number of byte segments offered to each syscall_read",
     "Size of messages received by HTTP2 transport",
     "Number of bytes consumed by metadata, according to HPACK accounting rules",
+    "Number of subchannels in a subchannel list at picker creation time",
+    "Number of READY subchannels in a subchannel list at picker creation time",
 };
 namespace {
 const int kStatsTable0[27] = {0,    1,     2,     4,     7,     11,   17,
@@ -138,8 +166,14 @@ const int kStatsTable2[21] = {
 const uint8_t kStatsTable3[23] = {2,  3,  3,  4,  5,  6,  7,  8,
                                   8,  9,  10, 11, 12, 12, 13, 14,
                                   15, 16, 16, 17, 18, 19, 20};
-const int kStatsTable4[11] = {0, 1, 2, 4, 7, 11, 17, 26, 38, 56, 80};
-const uint8_t kStatsTable5[9] = {3, 3, 4, 5, 6, 6, 7, 8, 9};
+const int kStatsTable4[21] = {0,   1,    2,    4,    7,    12,   19,
+                              30,  47,   74,   116,  182,  285,  445,
+                              695, 1084, 1691, 2637, 4113, 6414, 10000};
+const uint8_t kStatsTable5[23] = {3,  3,  4,  5,  5,  6,  7,  8,
+                                  9,  9,  10, 11, 12, 12, 13, 14,
+                                  15, 15, 16, 17, 18, 18, 19};
+const int kStatsTable6[11] = {0, 1, 2, 4, 7, 11, 17, 26, 38, 56, 80};
+const uint8_t kStatsTable7[9] = {3, 3, 4, 5, 6, 6, 7, 8, 9};
 }  // namespace
 int Histogram_65536_26::BucketFor(int value) {
   if (value < 3) {
@@ -179,7 +213,7 @@ int Histogram_16777216_20::BucketFor(int value) {
     }
   }
 }
-int Histogram_80_10::BucketFor(int value) {
+int Histogram_10000_20::BucketFor(int value) {
   if (value < 3) {
     if (value < 0) {
       return 0;
@@ -187,12 +221,35 @@ int Histogram_80_10::BucketFor(int value) {
       return value;
     }
   } else {
-    if (value < 49) {
+    if (value < 6145) {
       DblUint val;
       val.dbl = value;
       const int bucket =
           kStatsTable5[((val.uint - 4613937818241073152ull) >> 51)];
       return bucket - (value < kStatsTable4[bucket]);
+    } else {
+      if (value < 6414) {
+        return 18;
+      } else {
+        return 19;
+      }
+    }
+  }
+}
+int Histogram_80_10::BucketFor(int value) {
+  if (value < 3) {
+    if (value < 0) {
+      return 0;
+    } else {
+      return value;
+    }
+  } else {
+    if (value < 49) {
+      DblUint val;
+      val.dbl = value;
+      const int bucket =
+          kStatsTable7[((val.uint - 4613937818241073152ull) >> 51)];
+      return bucket - (value < kStatsTable6[bucket]);
     } else {
       if (value < 56) {
         return 8;
@@ -220,7 +277,8 @@ GlobalStats::GlobalStats()
       http2_stream_stalls{0},
       cq_pluck_creates{0},
       cq_next_creates{0},
-      cq_callback_creates{0} {}
+      cq_callback_creates{0},
+      wrr_updates{0} {}
 HistogramView GlobalStats::histogram(Histogram which) const {
   switch (which) {
     default:
@@ -232,7 +290,7 @@ HistogramView GlobalStats::histogram(Histogram which) const {
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable2, 20,
                            tcp_write_size.buckets()};
     case Histogram::kTcpWriteIovSize:
-      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable4, 10,
+      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable6, 10,
                            tcp_write_iov_size.buckets()};
     case Histogram::kTcpReadSize:
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable2, 20,
@@ -241,7 +299,7 @@ HistogramView GlobalStats::histogram(Histogram which) const {
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable2, 20,
                            tcp_read_offer.buckets()};
     case Histogram::kTcpReadOfferIovSize:
-      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable4, 10,
+      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable6, 10,
                            tcp_read_offer_iov_size.buckets()};
     case Histogram::kHttp2SendMessageSize:
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable2, 20,
@@ -249,6 +307,12 @@ HistogramView GlobalStats::histogram(Histogram which) const {
     case Histogram::kHttp2MetadataSize:
       return HistogramView{&Histogram_65536_26::BucketFor, kStatsTable0, 26,
                            http2_metadata_size.buckets()};
+    case Histogram::kWrrSubchannelListSize:
+      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable4, 20,
+                           wrr_subchannel_list_size.buckets()};
+    case Histogram::kWrrSubchannelReadySize:
+      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable4, 20,
+                           wrr_subchannel_ready_size.buckets()};
   }
 }
 std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
@@ -288,6 +352,7 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
         data.cq_next_creates.load(std::memory_order_relaxed);
     result->cq_callback_creates +=
         data.cq_callback_creates.load(std::memory_order_relaxed);
+    result->wrr_updates += data.wrr_updates.load(std::memory_order_relaxed);
     data.call_initial_size.Collect(&result->call_initial_size);
     data.tcp_write_size.Collect(&result->tcp_write_size);
     data.tcp_write_iov_size.Collect(&result->tcp_write_iov_size);
@@ -296,6 +361,8 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
     data.tcp_read_offer_iov_size.Collect(&result->tcp_read_offer_iov_size);
     data.http2_send_message_size.Collect(&result->http2_send_message_size);
     data.http2_metadata_size.Collect(&result->http2_metadata_size);
+    data.wrr_subchannel_list_size.Collect(&result->wrr_subchannel_list_size);
+    data.wrr_subchannel_ready_size.Collect(&result->wrr_subchannel_ready_size);
   }
   return result;
 }
@@ -327,6 +394,7 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
   result->cq_pluck_creates = cq_pluck_creates - other.cq_pluck_creates;
   result->cq_next_creates = cq_next_creates - other.cq_next_creates;
   result->cq_callback_creates = cq_callback_creates - other.cq_callback_creates;
+  result->wrr_updates = wrr_updates - other.wrr_updates;
   result->call_initial_size = call_initial_size - other.call_initial_size;
   result->tcp_write_size = tcp_write_size - other.tcp_write_size;
   result->tcp_write_iov_size = tcp_write_iov_size - other.tcp_write_iov_size;
@@ -337,6 +405,10 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
   result->http2_send_message_size =
       http2_send_message_size - other.http2_send_message_size;
   result->http2_metadata_size = http2_metadata_size - other.http2_metadata_size;
+  result->wrr_subchannel_list_size =
+      wrr_subchannel_list_size - other.wrr_subchannel_list_size;
+  result->wrr_subchannel_ready_size =
+      wrr_subchannel_ready_size - other.wrr_subchannel_ready_size;
   return result;
 }
 }  // namespace grpc_core