grpc 1.54.3 → 1.58.0

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

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

@@ -76,6 +76,29 @@ class HistogramCollector_16777216_20 {
  private:
   std::atomic<uint64_t> buckets_[20]{};
 };
+class HistogramCollector_10000_20;
+class Histogram_10000_20 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  friend Histogram_10000_20 operator-(const Histogram_10000_20& left,
+                                      const Histogram_10000_20& right);
+
+ private:
+  friend class HistogramCollector_10000_20;
+  uint64_t buckets_[20]{};
+};
+class HistogramCollector_10000_20 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_10000_20::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_10000_20* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[20]{};
+};
 class HistogramCollector_80_10;
 class Histogram_80_10 {
  public:
@@ -119,6 +142,7 @@ struct GlobalStats {
     kCqPluckCreates,
     kCqNextCreates,
     kCqCallbackCreates,
+    kWrrUpdates,
     COUNT
   };
   enum class Histogram {
@@ -130,6 +154,8 @@ struct GlobalStats {
     kTcpReadOfferIovSize,
     kHttp2SendMessageSize,
     kHttp2MetadataSize,
+    kWrrSubchannelListSize,
+    kWrrSubchannelReadySize,
     COUNT
   };
   GlobalStats();
@@ -159,6 +185,7 @@ struct GlobalStats {
       uint64_t cq_pluck_creates;
       uint64_t cq_next_creates;
       uint64_t cq_callback_creates;
+      uint64_t wrr_updates;
     };
     uint64_t counters[static_cast<int>(Counter::COUNT)];
   };
@@ -170,6 +197,8 @@ struct GlobalStats {
   Histogram_80_10 tcp_read_offer_iov_size;
   Histogram_16777216_20 http2_send_message_size;
   Histogram_65536_26 http2_metadata_size;
+  Histogram_10000_20 wrr_subchannel_list_size;
+  Histogram_10000_20 wrr_subchannel_ready_size;
   HistogramView histogram(Histogram which) const;
   std::unique_ptr<GlobalStats> Diff(const GlobalStats& other) const;
 };
@@ -240,6 +269,9 @@ class GlobalStatsCollector {
     data_.this_cpu().cq_callback_creates.fetch_add(1,
                                                    std::memory_order_relaxed);
   }
+  void IncrementWrrUpdates() {
+    data_.this_cpu().wrr_updates.fetch_add(1, std::memory_order_relaxed);
+  }
   void IncrementCallInitialSize(int value) {
     data_.this_cpu().call_initial_size.Increment(value);
   }
@@ -264,6 +296,12 @@ class GlobalStatsCollector {
   void IncrementHttp2MetadataSize(int value) {
     data_.this_cpu().http2_metadata_size.Increment(value);
   }
+  void IncrementWrrSubchannelListSize(int value) {
+    data_.this_cpu().wrr_subchannel_list_size.Increment(value);
+  }
+  void IncrementWrrSubchannelReadySize(int value) {
+    data_.this_cpu().wrr_subchannel_ready_size.Increment(value);
+  }
 
  private:
   struct Data {
@@ -285,6 +323,7 @@ class GlobalStatsCollector {
     std::atomic<uint64_t> cq_pluck_creates{0};
     std::atomic<uint64_t> cq_next_creates{0};
     std::atomic<uint64_t> cq_callback_creates{0};
+    std::atomic<uint64_t> wrr_updates{0};
     HistogramCollector_65536_26 call_initial_size;
     HistogramCollector_16777216_20 tcp_write_size;
     HistogramCollector_80_10 tcp_write_iov_size;
@@ -293,8 +332,10 @@ class GlobalStatsCollector {
     HistogramCollector_80_10 tcp_read_offer_iov_size;
     HistogramCollector_16777216_20 http2_send_message_size;
     HistogramCollector_65536_26 http2_metadata_size;
+    HistogramCollector_10000_20 wrr_subchannel_list_size;
+    HistogramCollector_10000_20 wrr_subchannel_ready_size;
   };
-  PerCpu<Data> data_;
+  PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)};
 };
 }  // namespace grpc_core
 

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

@@ -20,15 +20,15 @@
 
 #include "src/core/lib/debug/trace.h"
 
-#include <string.h>
-
 #include <string>
 #include <type_traits>
+#include <utility>
 
+#include "absl/strings/match.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -39,31 +39,31 @@ namespace grpc_core {
 
 TraceFlag* TraceFlagList::root_tracer_ = nullptr;
 
-bool TraceFlagList::Set(const char* name, bool enabled) {
+bool TraceFlagList::Set(absl::string_view name, bool enabled) {
   TraceFlag* t;
-  if (0 == strcmp(name, "all")) {
+  if (name == "all") {
     for (t = root_tracer_; t; t = t->next_tracer_) {
       t->set_enabled(enabled);
     }
-  } else if (0 == strcmp(name, "list_tracers")) {
+  } else if (name == "list_tracers") {
     LogAllTracers();
-  } else if (0 == strcmp(name, "refcount")) {
+  } else if (name == "refcount") {
     for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (strstr(t->name_, "refcount") != nullptr) {
+      if (absl::StrContains(t->name_, "refcount")) {
         t->set_enabled(enabled);
       }
     }
   } else {
     bool found = false;
     for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (0 == strcmp(name, t->name_)) {
+      if (name == t->name_) {
         t->set_enabled(enabled);
         found = true;
       }
     }
     // check for unknowns, but ignore "", to allow to GRPC_TRACE=
-    if (!found && 0 != strcmp(name, "")) {
-      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
+    if (!found && !name.empty()) {
+      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", std::string(name).c_str());
       return false;  // early return
     }
   }
@@ -77,12 +77,17 @@ void TraceFlagList::Add(TraceFlag* flag) {
 
 void TraceFlagList::LogAllTracers() {
   gpr_log(GPR_DEBUG, "available tracers:");
-  TraceFlag* t;
-  for (t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
     gpr_log(GPR_DEBUG, "\t%s", t->name_);
   }
 }
 
+void TraceFlagList::SaveTo(std::map<std::string, bool>& values) {
+  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
+    values[t->name_] = t->enabled();
+  }
+}
+
 // Flags register themselves on the list during construction
 TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   static_assert(std::is_trivially_destructible<TraceFlag>::value,
@@ -91,60 +96,30 @@ TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   TraceFlagList::Add(this);
 }
 
-}  // namespace grpc_core
-
-static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
-  size_t n = *ns;
-  size_t np = n + 1;
-  char* s;
-  size_t len;
-  GPR_ASSERT(end >= beg);
-  len = static_cast<size_t>(end - beg);
-  s = static_cast<char*>(gpr_malloc(len + 1));
-  memcpy(s, beg, len);
-  s[len] = 0;
-  *ss = static_cast<char**>(gpr_realloc(*ss, sizeof(char**) * np));
-  (*ss)[n] = s;
-  *ns = np;
-}
+SavedTraceFlags::SavedTraceFlags() { TraceFlagList::SaveTo(values_); }
 
-static void split(const char* s, char*** ss, size_t* ns) {
-  const char* c = strchr(s, ',');
-  if (c == nullptr) {
-    add(s, s + strlen(s), ss, ns);
-  } else {
-    add(s, c, ss, ns);
-    split(c + 1, ss, ns);
+void SavedTraceFlags::Restore() {
+  for (const auto& flag : values_) {
+    TraceFlagList::Set(flag.first, flag.second);
   }
 }
 
-static void parse(const char* s) {
-  char** strings = nullptr;
-  size_t nstrings = 0;
-  size_t i;
-  split(s, &strings, &nstrings);
-
-  for (i = 0; i < nstrings; i++) {
-    if (strings[i][0] == '-') {
-      grpc_core::TraceFlagList::Set(strings[i] + 1, false);
+namespace {
+void ParseTracers(absl::string_view tracers) {
+  for (auto s : absl::StrSplit(tracers, ',', absl::SkipWhitespace())) {
+    if (s[0] == '-') {
+      TraceFlagList::Set(s.substr(1), false);
     } else {
-      grpc_core::TraceFlagList::Set(strings[i], true);
+      TraceFlagList::Set(s, true);
     }
   }
-
-  for (i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
 }
+}  // namespace
 
-void grpc_tracer_init(const char* env_var_name) {
-  (void)env_var_name;  // suppress unused variable error
-  grpc_tracer_init();
-}
+}  // namespace grpc_core
 
 void grpc_tracer_init() {
-  parse(std::string(grpc_core::ConfigVars::Get().Trace()).c_str());
+  grpc_core::ParseTracers(grpc_core::ConfigVars::Get().Trace());
 }
 
 int grpc_tracer_set_enabled(const char* name, int enabled) {

data/src/core/lib/debug/trace.h

@@ -22,10 +22,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <map>
+#include <string>
 
-// TODO(veblush): Remove this deprecated function once codes depending on this
-// function are updated in the internal repo.
-void grpc_tracer_init(const char* env_var_name);
+#include "absl/strings/string_view.h"
 
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
@@ -35,8 +35,9 @@ namespace grpc_core {
 class TraceFlag;
 class TraceFlagList {
  public:
-  static bool Set(const char* name, bool enabled);
+  static bool Set(absl::string_view name, bool enabled);
   static void Add(TraceFlag* flag);
+  static void SaveTo(std::map<std::string, bool>& values);
 
  private:
   static void LogAllTracers();
@@ -101,6 +102,15 @@ class DebugOnlyTraceFlag {
 };
 #endif
 
+class SavedTraceFlags {
+ public:
+  SavedTraceFlags();
+  void Restore();
+
+ private:
+  std::map<std::string, bool> values_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_H