grpc 1.62.0 → 1.63.2

data/src/core/lib/config/config_vars.h

@@ -38,6 +38,7 @@ class GPR_DLL ConfigVars {
     absl::optional<bool> enable_fork_support;
     absl::optional<bool> abort_on_leaks;
     absl::optional<bool> not_use_system_ssl_roots;
+    absl::optional<bool> absl_logging;
     absl::optional<std::string> dns_resolver;
     absl::optional<std::string> verbosity;
     absl::optional<std::string> stacktrace_minloglevel;
@@ -102,6 +103,8 @@ class GPR_DLL ConfigVars {
   bool NotUseSystemSslRoots() const { return not_use_system_ssl_roots_; }
   // A colon separated list of cipher suites to use with OpenSSL
   absl::string_view SslCipherSuites() const { return ssl_cipher_suites_; }
+  // Use absl logging from within gpr_log.
+  bool AbslLogging() const { return absl_logging_; }
 
  private:
   explicit ConfigVars(const Overrides& overrides);
@@ -111,6 +114,7 @@ class GPR_DLL ConfigVars {
   bool enable_fork_support_;
   bool abort_on_leaks_;
   bool not_use_system_ssl_roots_;
+  bool absl_logging_;
   std::string dns_resolver_;
   std::string verbosity_;
   std::string stacktrace_minloglevel_;

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

@@ -53,6 +53,19 @@ Histogram_65536_26 operator-(const Histogram_65536_26& left,
   }
   return result;
 }
+void HistogramCollector_100_20::Collect(Histogram_100_20* result) const {
+  for (int i = 0; i < 20; i++) {
+    result->buckets_[i] += buckets_[i].load(std::memory_order_relaxed);
+  }
+}
+Histogram_100_20 operator-(const Histogram_100_20& left,
+                           const Histogram_100_20& right) {
+  Histogram_100_20 result;
+  for (int i = 0; i < 20; i++) {
+    result.buckets_[i] = left.buckets_[i] - right.buckets_[i];
+  }
+  return result;
+}
 void HistogramCollector_16777216_20::Collect(
     Histogram_16777216_20* result) const {
   for (int i = 0; i < 20; i++) {
@@ -116,6 +129,17 @@ const absl::string_view
         "wrr_updates",
         "work_serializer_items_enqueued",
         "work_serializer_items_dequeued",
+        "econnaborted_count",
+        "econnreset_count",
+        "epipe_count",
+        "etimedout_count",
+        "econnrefused_count",
+        "enetunreach_count",
+        "enomsg_count",
+        "enotconn_count",
+        "enobufs_count",
+        "uncommon_io_error_count",
+        "msg_errqueue_error_count",
 };
 const absl::string_view GlobalStats::counter_doc[static_cast<int>(
     Counter::COUNT)] = {
@@ -146,6 +170,17 @@ const absl::string_view GlobalStats::counter_doc[static_cast<int>(
     "Number of wrr updates that have been received",
     "Number of items enqueued onto work serializers",
     "Number of items dequeued from work serializers",
+    "Number of ECONNABORTED errors",
+    "Number of ECONNRESET errors",
+    "Number of EPIPE errors",
+    "Number of ETIMEDOUT errors",
+    "Number of ECONNREFUSED errors",
+    "Number of ENETUNREACH errors",
+    "Number of ENOMSG errors",
+    "Number of ENOTCONN errors",
+    "Number of ENOBUFS errors",
+    "Number of uncommon io errors",
+    "Number of uncommon errors returned by MSG_ERRQUEUE",
 };
 const absl::string_view
     GlobalStats::histogram_name[static_cast<int>(Histogram::COUNT)] = {
@@ -163,6 +198,20 @@ const absl::string_view
         "work_serializer_work_time_ms",
         "work_serializer_work_time_per_item_ms",
         "work_serializer_items_per_run",
+        "chaotic_good_sendmsgs_per_write_control",
+        "chaotic_good_recvmsgs_per_read_control",
+        "chaotic_good_sendmsgs_per_write_data",
+        "chaotic_good_recvmsgs_per_read_data",
+        "chaotic_good_thread_hops_per_write_control",
+        "chaotic_good_thread_hops_per_read_control",
+        "chaotic_good_thread_hops_per_write_data",
+        "chaotic_good_thread_hops_per_read_data",
+        "chaotic_good_tcp_read_size_data",
+        "chaotic_good_tcp_read_size_control",
+        "chaotic_good_tcp_read_offer_data",
+        "chaotic_good_tcp_read_offer_control",
+        "chaotic_good_tcp_write_size_data",
+        "chaotic_good_tcp_write_size_control",
 };
 const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     Histogram::COUNT)] = {
@@ -181,6 +230,20 @@ const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     "work",
     "How long do individual items take to process in work serializers",
     "How many callbacks are executed when a work serializer runs",
+    "Number of sendmsgs per control channel endpoint write",
+    "Number of recvmsgs per control channel endpoint read",
+    "Number of sendmsgs per data channel endpoint write",
+    "Number of recvmsgs per data channel endpoint read",
+    "Number of thread hops per control channel endpoint write",
+    "Number of thread hops per control channel endpoint read",
+    "Number of thread hops per data channel endpoint write",
+    "Number of thread hops per data channel endpoint read",
+    "Number of bytes received by each syscall_read in the data channel",
+    "Number of bytes received by each syscall_read in the control channel",
+    "Number of bytes offered to each syscall_read in the data channel",
+    "Number of bytes offered to each syscall_read in the control channel",
+    "Number of bytes offered to each syscall_write in the data channel",
+    "Number of bytes offered to each syscall_write in the control channel",
 };
 namespace {
 const int kStatsTable0[21] = {0,    1,    2,    4,     8,     15,    27,
@@ -196,21 +259,25 @@ const int kStatsTable2[27] = {0,    1,     2,     4,     7,     11,   17,
 const uint8_t kStatsTable3[29] = {3,  3,  4,  5,  6,  6,  7,  8,  9,  10,
                                   11, 11, 12, 13, 14, 15, 16, 16, 17, 18,
                                   19, 20, 21, 21, 22, 23, 24, 25, 26};
-const int kStatsTable4[21] = {
+const int kStatsTable4[21] = {0,  1,  2,  3,  4,  5,  7,  9,  11, 14, 17,
+                              21, 25, 30, 36, 43, 51, 61, 72, 85, 100};
+const uint8_t kStatsTable5[16] = {6,  6,  7,  8,  9,  9,  10, 11,
+                                  12, 13, 14, 15, 16, 17, 18, 19};
+const int kStatsTable6[21] = {
     0,     1,      3,      8,       19,      45,      106,
     250,   588,    1383,   3252,    7646,    17976,   42262,
     99359, 233593, 549177, 1291113, 3035402, 7136218, 16777216};
-const uint8_t kStatsTable5[23] = {2,  3,  3,  4,  5,  6,  7,  8,
+const uint8_t kStatsTable7[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 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};
-const int kStatsTable8[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 kStatsTable9[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 kStatsTable8[11] = {0, 1, 2, 4, 7, 11, 17, 26, 38, 56, 80};
+const uint8_t kStatsTable9[9] = {3, 3, 4, 5, 6, 6, 7, 8, 9};
+const int kStatsTable10[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 kStatsTable11[23] = {3,  3,  4,  5,  5,  6,  7,  8,
+                                   9,  9,  10, 11, 12, 12, 13, 14,
+                                   15, 15, 16, 17, 18, 18, 19};
 }  // namespace
 int Histogram_100000_20::BucketFor(int value) {
   if (value < 3) {
@@ -250,6 +317,29 @@ int Histogram_65536_26::BucketFor(int value) {
     }
   }
 }
+int Histogram_100_20::BucketFor(int value) {
+  if (value < 6) {
+    if (value < 0) {
+      return 0;
+    } else {
+      return value;
+    }
+  } else {
+    if (value < 81) {
+      DblUint val;
+      val.dbl = value;
+      const int bucket =
+          kStatsTable5[((val.uint - 4618441417868443648ull) >> 50)];
+      return bucket - (value < kStatsTable4[bucket]);
+    } else {
+      if (value < 85) {
+        return 18;
+      } else {
+        return 19;
+      }
+    }
+  }
+}
 int Histogram_16777216_20::BucketFor(int value) {
   if (value < 2) {
     if (value < 0) {
@@ -262,8 +352,8 @@ int Histogram_16777216_20::BucketFor(int value) {
       DblUint val;
       val.dbl = value;
       const int bucket =
-          kStatsTable5[((val.uint - 4611686018427387904ull) >> 52)];
-      return bucket - (value < kStatsTable4[bucket]);
+          kStatsTable7[((val.uint - 4611686018427387904ull) >> 52)];
+      return bucket - (value < kStatsTable6[bucket]);
     } else {
       return 19;
     }
@@ -281,8 +371,8 @@ int Histogram_80_10::BucketFor(int value) {
       DblUint val;
       val.dbl = value;
       const int bucket =
-          kStatsTable7[((val.uint - 4613937818241073152ull) >> 51)];
-      return bucket - (value < kStatsTable6[bucket]);
+          kStatsTable9[((val.uint - 4613937818241073152ull) >> 51)];
+      return bucket - (value < kStatsTable8[bucket]);
     } else {
       if (value < 56) {
         return 8;
@@ -304,8 +394,8 @@ int Histogram_10000_20::BucketFor(int value) {
       DblUint val;
       val.dbl = value;
       const int bucket =
-          kStatsTable9[((val.uint - 4613937818241073152ull) >> 51)];
-      return bucket - (value < kStatsTable8[bucket]);
+          kStatsTable11[((val.uint - 4613937818241073152ull) >> 51)];
+      return bucket - (value < kStatsTable10[bucket]);
     } else {
       if (value < 6414) {
         return 18;
@@ -336,7 +426,18 @@ GlobalStats::GlobalStats()
       cq_callback_creates{0},
       wrr_updates{0},
       work_serializer_items_enqueued{0},
-      work_serializer_items_dequeued{0} {}
+      work_serializer_items_dequeued{0},
+      econnaborted_count{0},
+      econnreset_count{0},
+      epipe_count{0},
+      etimedout_count{0},
+      econnrefused_count{0},
+      enetunreach_count{0},
+      enomsg_count{0},
+      enotconn_count{0},
+      enobufs_count{0},
+      uncommon_io_error_count{0},
+      msg_errqueue_error_count{0} {}
 HistogramView GlobalStats::histogram(Histogram which) const {
   switch (which) {
     default:
@@ -345,31 +446,31 @@ HistogramView GlobalStats::histogram(Histogram which) const {
       return HistogramView{&Histogram_65536_26::BucketFor, kStatsTable2, 26,
                            call_initial_size.buckets()};
     case Histogram::kTcpWriteSize:
-      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable4, 20,
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
                            tcp_write_size.buckets()};
     case Histogram::kTcpWriteIovSize:
-      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable6, 10,
+      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable8, 10,
                            tcp_write_iov_size.buckets()};
     case Histogram::kTcpReadSize:
-      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable4, 20,
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
                            tcp_read_size.buckets()};
     case Histogram::kTcpReadOffer:
-      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable4, 20,
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
                            tcp_read_offer.buckets()};
     case Histogram::kTcpReadOfferIovSize:
-      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable6, 10,
+      return HistogramView{&Histogram_80_10::BucketFor, kStatsTable8, 10,
                            tcp_read_offer_iov_size.buckets()};
     case Histogram::kHttp2SendMessageSize:
-      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable4, 20,
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
                            http2_send_message_size.buckets()};
     case Histogram::kHttp2MetadataSize:
       return HistogramView{&Histogram_65536_26::BucketFor, kStatsTable2, 26,
                            http2_metadata_size.buckets()};
     case Histogram::kWrrSubchannelListSize:
-      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable8, 20,
+      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable10, 20,
                            wrr_subchannel_list_size.buckets()};
     case Histogram::kWrrSubchannelReadySize:
-      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable8, 20,
+      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable10, 20,
                            wrr_subchannel_ready_size.buckets()};
     case Histogram::kWorkSerializerRunTimeMs:
       return HistogramView{&Histogram_100000_20::BucketFor, kStatsTable0, 20,
@@ -381,8 +482,51 @@ HistogramView GlobalStats::histogram(Histogram which) const {
       return HistogramView{&Histogram_100000_20::BucketFor, kStatsTable0, 20,
                            work_serializer_work_time_per_item_ms.buckets()};
     case Histogram::kWorkSerializerItemsPerRun:
-      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable8, 20,
+      return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable10, 20,
                            work_serializer_items_per_run.buckets()};
+    case Histogram::kChaoticGoodSendmsgsPerWriteControl:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_sendmsgs_per_write_control.buckets()};
+    case Histogram::kChaoticGoodRecvmsgsPerReadControl:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_recvmsgs_per_read_control.buckets()};
+    case Histogram::kChaoticGoodSendmsgsPerWriteData:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_sendmsgs_per_write_data.buckets()};
+    case Histogram::kChaoticGoodRecvmsgsPerReadData:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_recvmsgs_per_read_data.buckets()};
+    case Histogram::kChaoticGoodThreadHopsPerWriteControl:
+      return HistogramView{
+          &Histogram_100_20::BucketFor, kStatsTable4, 20,
+          chaotic_good_thread_hops_per_write_control.buckets()};
+    case Histogram::kChaoticGoodThreadHopsPerReadControl:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_thread_hops_per_read_control.buckets()};
+    case Histogram::kChaoticGoodThreadHopsPerWriteData:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_thread_hops_per_write_data.buckets()};
+    case Histogram::kChaoticGoodThreadHopsPerReadData:
+      return HistogramView{&Histogram_100_20::BucketFor, kStatsTable4, 20,
+                           chaotic_good_thread_hops_per_read_data.buckets()};
+    case Histogram::kChaoticGoodTcpReadSizeData:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           chaotic_good_tcp_read_size_data.buckets()};
+    case Histogram::kChaoticGoodTcpReadSizeControl:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           chaotic_good_tcp_read_size_control.buckets()};
+    case Histogram::kChaoticGoodTcpReadOfferData:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           chaotic_good_tcp_read_offer_data.buckets()};
+    case Histogram::kChaoticGoodTcpReadOfferControl:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           chaotic_good_tcp_read_offer_control.buckets()};
+    case Histogram::kChaoticGoodTcpWriteSizeData:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           chaotic_good_tcp_write_size_data.buckets()};
+    case Histogram::kChaoticGoodTcpWriteSizeControl:
+      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+                           chaotic_good_tcp_write_size_control.buckets()};
   }
 }
 std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
@@ -427,6 +571,25 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
         data.work_serializer_items_enqueued.load(std::memory_order_relaxed);
     result->work_serializer_items_dequeued +=
         data.work_serializer_items_dequeued.load(std::memory_order_relaxed);
+    result->econnaborted_count +=
+        data.econnaborted_count.load(std::memory_order_relaxed);
+    result->econnreset_count +=
+        data.econnreset_count.load(std::memory_order_relaxed);
+    result->epipe_count += data.epipe_count.load(std::memory_order_relaxed);
+    result->etimedout_count +=
+        data.etimedout_count.load(std::memory_order_relaxed);
+    result->econnrefused_count +=
+        data.econnrefused_count.load(std::memory_order_relaxed);
+    result->enetunreach_count +=
+        data.enetunreach_count.load(std::memory_order_relaxed);
+    result->enomsg_count += data.enomsg_count.load(std::memory_order_relaxed);
+    result->enotconn_count +=
+        data.enotconn_count.load(std::memory_order_relaxed);
+    result->enobufs_count += data.enobufs_count.load(std::memory_order_relaxed);
+    result->uncommon_io_error_count +=
+        data.uncommon_io_error_count.load(std::memory_order_relaxed);
+    result->msg_errqueue_error_count +=
+        data.msg_errqueue_error_count.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);
@@ -445,6 +608,34 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
         &result->work_serializer_work_time_per_item_ms);
     data.work_serializer_items_per_run.Collect(
         &result->work_serializer_items_per_run);
+    data.chaotic_good_sendmsgs_per_write_control.Collect(
+        &result->chaotic_good_sendmsgs_per_write_control);
+    data.chaotic_good_recvmsgs_per_read_control.Collect(
+        &result->chaotic_good_recvmsgs_per_read_control);
+    data.chaotic_good_sendmsgs_per_write_data.Collect(
+        &result->chaotic_good_sendmsgs_per_write_data);
+    data.chaotic_good_recvmsgs_per_read_data.Collect(
+        &result->chaotic_good_recvmsgs_per_read_data);
+    data.chaotic_good_thread_hops_per_write_control.Collect(
+        &result->chaotic_good_thread_hops_per_write_control);
+    data.chaotic_good_thread_hops_per_read_control.Collect(
+        &result->chaotic_good_thread_hops_per_read_control);
+    data.chaotic_good_thread_hops_per_write_data.Collect(
+        &result->chaotic_good_thread_hops_per_write_data);
+    data.chaotic_good_thread_hops_per_read_data.Collect(
+        &result->chaotic_good_thread_hops_per_read_data);
+    data.chaotic_good_tcp_read_size_data.Collect(
+        &result->chaotic_good_tcp_read_size_data);
+    data.chaotic_good_tcp_read_size_control.Collect(
+        &result->chaotic_good_tcp_read_size_control);
+    data.chaotic_good_tcp_read_offer_data.Collect(
+        &result->chaotic_good_tcp_read_offer_data);
+    data.chaotic_good_tcp_read_offer_control.Collect(
+        &result->chaotic_good_tcp_read_offer_control);
+    data.chaotic_good_tcp_write_size_data.Collect(
+        &result->chaotic_good_tcp_write_size_data);
+    data.chaotic_good_tcp_write_size_control.Collect(
+        &result->chaotic_good_tcp_write_size_control);
   }
   return result;
 }
@@ -481,6 +672,19 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
       work_serializer_items_enqueued - other.work_serializer_items_enqueued;
   result->work_serializer_items_dequeued =
       work_serializer_items_dequeued - other.work_serializer_items_dequeued;
+  result->econnaborted_count = econnaborted_count - other.econnaborted_count;
+  result->econnreset_count = econnreset_count - other.econnreset_count;
+  result->epipe_count = epipe_count - other.epipe_count;
+  result->etimedout_count = etimedout_count - other.etimedout_count;
+  result->econnrefused_count = econnrefused_count - other.econnrefused_count;
+  result->enetunreach_count = enetunreach_count - other.enetunreach_count;
+  result->enomsg_count = enomsg_count - other.enomsg_count;
+  result->enotconn_count = enotconn_count - other.enotconn_count;
+  result->enobufs_count = enobufs_count - other.enobufs_count;
+  result->uncommon_io_error_count =
+      uncommon_io_error_count - other.uncommon_io_error_count;
+  result->msg_errqueue_error_count =
+      msg_errqueue_error_count - other.msg_errqueue_error_count;
   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;
@@ -504,6 +708,45 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
       other.work_serializer_work_time_per_item_ms;
   result->work_serializer_items_per_run =
       work_serializer_items_per_run - other.work_serializer_items_per_run;
+  result->chaotic_good_sendmsgs_per_write_control =
+      chaotic_good_sendmsgs_per_write_control -
+      other.chaotic_good_sendmsgs_per_write_control;
+  result->chaotic_good_recvmsgs_per_read_control =
+      chaotic_good_recvmsgs_per_read_control -
+      other.chaotic_good_recvmsgs_per_read_control;
+  result->chaotic_good_sendmsgs_per_write_data =
+      chaotic_good_sendmsgs_per_write_data -
+      other.chaotic_good_sendmsgs_per_write_data;
+  result->chaotic_good_recvmsgs_per_read_data =
+      chaotic_good_recvmsgs_per_read_data -
+      other.chaotic_good_recvmsgs_per_read_data;
+  result->chaotic_good_thread_hops_per_write_control =
+      chaotic_good_thread_hops_per_write_control -
+      other.chaotic_good_thread_hops_per_write_control;
+  result->chaotic_good_thread_hops_per_read_control =
+      chaotic_good_thread_hops_per_read_control -
+      other.chaotic_good_thread_hops_per_read_control;
+  result->chaotic_good_thread_hops_per_write_data =
+      chaotic_good_thread_hops_per_write_data -
+      other.chaotic_good_thread_hops_per_write_data;
+  result->chaotic_good_thread_hops_per_read_data =
+      chaotic_good_thread_hops_per_read_data -
+      other.chaotic_good_thread_hops_per_read_data;
+  result->chaotic_good_tcp_read_size_data =
+      chaotic_good_tcp_read_size_data - other.chaotic_good_tcp_read_size_data;
+  result->chaotic_good_tcp_read_size_control =
+      chaotic_good_tcp_read_size_control -
+      other.chaotic_good_tcp_read_size_control;
+  result->chaotic_good_tcp_read_offer_data =
+      chaotic_good_tcp_read_offer_data - other.chaotic_good_tcp_read_offer_data;
+  result->chaotic_good_tcp_read_offer_control =
+      chaotic_good_tcp_read_offer_control -
+      other.chaotic_good_tcp_read_offer_control;
+  result->chaotic_good_tcp_write_size_data =
+      chaotic_good_tcp_write_size_data - other.chaotic_good_tcp_write_size_data;
+  result->chaotic_good_tcp_write_size_control =
+      chaotic_good_tcp_write_size_control -
+      other.chaotic_good_tcp_write_size_control;
   return result;
 }
 }  // namespace grpc_core