1 // Copyright 2017 gRPC authors. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 // Automatically generated by tools/codegen/core/gen_stats_data.py 16 17 #ifndef GRPC_SRC_CORE_LIB_DEBUG_STATS_DATA_H 18 #define GRPC_SRC_CORE_LIB_DEBUG_STATS_DATA_H 19 20 #include <grpc/support/port_platform.h> 21 22 #include <stdint.h> 23 24 #include <atomic> 25 #include <memory> 26 27 #include "absl/strings/string_view.h" 28 29 #include "src/core/lib/debug/histogram_view.h" 30 #include "src/core/lib/gprpp/per_cpu.h" 31 32 namespace grpc_core { 33 class HistogramCollector_100000_20; 34 class Histogram_100000_20 { 35 public: 36 static int BucketFor(int value); buckets()37 const uint64_t* buckets() const { return buckets_; } 38 friend Histogram_100000_20 operator-(const Histogram_100000_20& left, 39 const Histogram_100000_20& right); 40 41 private: 42 friend class HistogramCollector_100000_20; 43 uint64_t buckets_[20]{}; 44 }; 45 class HistogramCollector_100000_20 { 46 public: Increment(int value)47 void Increment(int value) { 48 buckets_[Histogram_100000_20::BucketFor(value)].fetch_add( 49 1, std::memory_order_relaxed); 50 } 51 void Collect(Histogram_100000_20* result) const; 52 53 private: 54 std::atomic<uint64_t> buckets_[20]{}; 55 }; 56 class HistogramCollector_65536_26; 57 class Histogram_65536_26 { 58 public: 59 static int BucketFor(int value); buckets()60 const uint64_t* buckets() const { return buckets_; } 61 friend Histogram_65536_26 operator-(const Histogram_65536_26& left, 62 const Histogram_65536_26& right); 63 64 private: 65 friend class HistogramCollector_65536_26; 66 uint64_t buckets_[26]{}; 67 }; 68 class HistogramCollector_65536_26 { 69 public: Increment(int value)70 void Increment(int value) { 71 buckets_[Histogram_65536_26::BucketFor(value)].fetch_add( 72 1, std::memory_order_relaxed); 73 } 74 void Collect(Histogram_65536_26* result) const; 75 76 private: 77 std::atomic<uint64_t> buckets_[26]{}; 78 }; 79 class HistogramCollector_100_20; 80 class Histogram_100_20 { 81 public: 82 static int BucketFor(int value); buckets()83 const uint64_t* buckets() const { return buckets_; } 84 friend Histogram_100_20 operator-(const Histogram_100_20& left, 85 const Histogram_100_20& right); 86 87 private: 88 friend class HistogramCollector_100_20; 89 uint64_t buckets_[20]{}; 90 }; 91 class HistogramCollector_100_20 { 92 public: Increment(int value)93 void Increment(int value) { 94 buckets_[Histogram_100_20::BucketFor(value)].fetch_add( 95 1, std::memory_order_relaxed); 96 } 97 void Collect(Histogram_100_20* result) const; 98 99 private: 100 std::atomic<uint64_t> buckets_[20]{}; 101 }; 102 class HistogramCollector_16777216_20; 103 class Histogram_16777216_20 { 104 public: 105 static int BucketFor(int value); buckets()106 const uint64_t* buckets() const { return buckets_; } 107 friend Histogram_16777216_20 operator-(const Histogram_16777216_20& left, 108 const Histogram_16777216_20& right); 109 110 private: 111 friend class HistogramCollector_16777216_20; 112 uint64_t buckets_[20]{}; 113 }; 114 class HistogramCollector_16777216_20 { 115 public: Increment(int value)116 void Increment(int value) { 117 buckets_[Histogram_16777216_20::BucketFor(value)].fetch_add( 118 1, std::memory_order_relaxed); 119 } 120 void Collect(Histogram_16777216_20* result) const; 121 122 private: 123 std::atomic<uint64_t> buckets_[20]{}; 124 }; 125 class HistogramCollector_80_10; 126 class Histogram_80_10 { 127 public: 128 static int BucketFor(int value); buckets()129 const uint64_t* buckets() const { return buckets_; } 130 friend Histogram_80_10 operator-(const Histogram_80_10& left, 131 const Histogram_80_10& right); 132 133 private: 134 friend class HistogramCollector_80_10; 135 uint64_t buckets_[10]{}; 136 }; 137 class HistogramCollector_80_10 { 138 public: Increment(int value)139 void Increment(int value) { 140 buckets_[Histogram_80_10::BucketFor(value)].fetch_add( 141 1, std::memory_order_relaxed); 142 } 143 void Collect(Histogram_80_10* result) const; 144 145 private: 146 std::atomic<uint64_t> buckets_[10]{}; 147 }; 148 class HistogramCollector_10000_20; 149 class Histogram_10000_20 { 150 public: 151 static int BucketFor(int value); buckets()152 const uint64_t* buckets() const { return buckets_; } 153 friend Histogram_10000_20 operator-(const Histogram_10000_20& left, 154 const Histogram_10000_20& right); 155 156 private: 157 friend class HistogramCollector_10000_20; 158 uint64_t buckets_[20]{}; 159 }; 160 class HistogramCollector_10000_20 { 161 public: Increment(int value)162 void Increment(int value) { 163 buckets_[Histogram_10000_20::BucketFor(value)].fetch_add( 164 1, std::memory_order_relaxed); 165 } 166 void Collect(Histogram_10000_20* result) const; 167 168 private: 169 std::atomic<uint64_t> buckets_[20]{}; 170 }; 171 struct GlobalStats { 172 enum class Counter { 173 kClientCallsCreated, 174 kServerCallsCreated, 175 kClientChannelsCreated, 176 kClientSubchannelsCreated, 177 kServerChannelsCreated, 178 kInsecureConnectionsCreated, 179 kSyscallWrite, 180 kSyscallRead, 181 kTcpReadAlloc8k, 182 kTcpReadAlloc64k, 183 kHttp2SettingsWrites, 184 kHttp2PingsSent, 185 kHttp2WritesBegun, 186 kHttp2TransportStalls, 187 kHttp2StreamStalls, 188 kCqPluckCreates, 189 kCqNextCreates, 190 kCqCallbackCreates, 191 kWrrUpdates, 192 kWorkSerializerItemsEnqueued, 193 kWorkSerializerItemsDequeued, 194 kEconnabortedCount, 195 kEconnresetCount, 196 kEpipeCount, 197 kEtimedoutCount, 198 kEconnrefusedCount, 199 kEnetunreachCount, 200 kEnomsgCount, 201 kEnotconnCount, 202 kEnobufsCount, 203 kUncommonIoErrorCount, 204 kMsgErrqueueErrorCount, 205 COUNT 206 }; 207 enum class Histogram { 208 kCallInitialSize, 209 kTcpWriteSize, 210 kTcpWriteIovSize, 211 kTcpReadSize, 212 kTcpReadOffer, 213 kTcpReadOfferIovSize, 214 kHttp2SendMessageSize, 215 kHttp2MetadataSize, 216 kWrrSubchannelListSize, 217 kWrrSubchannelReadySize, 218 kWorkSerializerRunTimeMs, 219 kWorkSerializerWorkTimeMs, 220 kWorkSerializerWorkTimePerItemMs, 221 kWorkSerializerItemsPerRun, 222 kChaoticGoodSendmsgsPerWriteControl, 223 kChaoticGoodRecvmsgsPerReadControl, 224 kChaoticGoodSendmsgsPerWriteData, 225 kChaoticGoodRecvmsgsPerReadData, 226 kChaoticGoodThreadHopsPerWriteControl, 227 kChaoticGoodThreadHopsPerReadControl, 228 kChaoticGoodThreadHopsPerWriteData, 229 kChaoticGoodThreadHopsPerReadData, 230 kChaoticGoodTcpReadSizeData, 231 kChaoticGoodTcpReadSizeControl, 232 kChaoticGoodTcpReadOfferData, 233 kChaoticGoodTcpReadOfferControl, 234 kChaoticGoodTcpWriteSizeData, 235 kChaoticGoodTcpWriteSizeControl, 236 COUNT 237 }; 238 GlobalStats(); 239 static const absl::string_view counter_name[static_cast<int>(Counter::COUNT)]; 240 static const absl::string_view 241 histogram_name[static_cast<int>(Histogram::COUNT)]; 242 static const absl::string_view counter_doc[static_cast<int>(Counter::COUNT)]; 243 static const absl::string_view 244 histogram_doc[static_cast<int>(Histogram::COUNT)]; 245 union { 246 struct { 247 uint64_t client_calls_created; 248 uint64_t server_calls_created; 249 uint64_t client_channels_created; 250 uint64_t client_subchannels_created; 251 uint64_t server_channels_created; 252 uint64_t insecure_connections_created; 253 uint64_t syscall_write; 254 uint64_t syscall_read; 255 uint64_t tcp_read_alloc_8k; 256 uint64_t tcp_read_alloc_64k; 257 uint64_t http2_settings_writes; 258 uint64_t http2_pings_sent; 259 uint64_t http2_writes_begun; 260 uint64_t http2_transport_stalls; 261 uint64_t http2_stream_stalls; 262 uint64_t cq_pluck_creates; 263 uint64_t cq_next_creates; 264 uint64_t cq_callback_creates; 265 uint64_t wrr_updates; 266 uint64_t work_serializer_items_enqueued; 267 uint64_t work_serializer_items_dequeued; 268 uint64_t econnaborted_count; 269 uint64_t econnreset_count; 270 uint64_t epipe_count; 271 uint64_t etimedout_count; 272 uint64_t econnrefused_count; 273 uint64_t enetunreach_count; 274 uint64_t enomsg_count; 275 uint64_t enotconn_count; 276 uint64_t enobufs_count; 277 uint64_t uncommon_io_error_count; 278 uint64_t msg_errqueue_error_count; 279 }; 280 uint64_t counters[static_cast<int>(Counter::COUNT)]; 281 }; 282 Histogram_65536_26 call_initial_size; 283 Histogram_16777216_20 tcp_write_size; 284 Histogram_80_10 tcp_write_iov_size; 285 Histogram_16777216_20 tcp_read_size; 286 Histogram_16777216_20 tcp_read_offer; 287 Histogram_80_10 tcp_read_offer_iov_size; 288 Histogram_16777216_20 http2_send_message_size; 289 Histogram_65536_26 http2_metadata_size; 290 Histogram_10000_20 wrr_subchannel_list_size; 291 Histogram_10000_20 wrr_subchannel_ready_size; 292 Histogram_100000_20 work_serializer_run_time_ms; 293 Histogram_100000_20 work_serializer_work_time_ms; 294 Histogram_100000_20 work_serializer_work_time_per_item_ms; 295 Histogram_10000_20 work_serializer_items_per_run; 296 Histogram_100_20 chaotic_good_sendmsgs_per_write_control; 297 Histogram_100_20 chaotic_good_recvmsgs_per_read_control; 298 Histogram_100_20 chaotic_good_sendmsgs_per_write_data; 299 Histogram_100_20 chaotic_good_recvmsgs_per_read_data; 300 Histogram_100_20 chaotic_good_thread_hops_per_write_control; 301 Histogram_100_20 chaotic_good_thread_hops_per_read_control; 302 Histogram_100_20 chaotic_good_thread_hops_per_write_data; 303 Histogram_100_20 chaotic_good_thread_hops_per_read_data; 304 Histogram_16777216_20 chaotic_good_tcp_read_size_data; 305 Histogram_16777216_20 chaotic_good_tcp_read_size_control; 306 Histogram_16777216_20 chaotic_good_tcp_read_offer_data; 307 Histogram_16777216_20 chaotic_good_tcp_read_offer_control; 308 Histogram_16777216_20 chaotic_good_tcp_write_size_data; 309 Histogram_16777216_20 chaotic_good_tcp_write_size_control; 310 HistogramView histogram(Histogram which) const; 311 std::unique_ptr<GlobalStats> Diff(const GlobalStats& other) const; 312 }; 313 class GlobalStatsCollector { 314 public: 315 std::unique_ptr<GlobalStats> Collect() const; IncrementClientCallsCreated()316 void IncrementClientCallsCreated() { 317 data_.this_cpu().client_calls_created.fetch_add(1, 318 std::memory_order_relaxed); 319 } IncrementServerCallsCreated()320 void IncrementServerCallsCreated() { 321 data_.this_cpu().server_calls_created.fetch_add(1, 322 std::memory_order_relaxed); 323 } IncrementClientChannelsCreated()324 void IncrementClientChannelsCreated() { 325 data_.this_cpu().client_channels_created.fetch_add( 326 1, std::memory_order_relaxed); 327 } IncrementClientSubchannelsCreated()328 void IncrementClientSubchannelsCreated() { 329 data_.this_cpu().client_subchannels_created.fetch_add( 330 1, std::memory_order_relaxed); 331 } IncrementServerChannelsCreated()332 void IncrementServerChannelsCreated() { 333 data_.this_cpu().server_channels_created.fetch_add( 334 1, std::memory_order_relaxed); 335 } IncrementInsecureConnectionsCreated()336 void IncrementInsecureConnectionsCreated() { 337 data_.this_cpu().insecure_connections_created.fetch_add( 338 1, std::memory_order_relaxed); 339 } IncrementSyscallWrite()340 void IncrementSyscallWrite() { 341 data_.this_cpu().syscall_write.fetch_add(1, std::memory_order_relaxed); 342 } IncrementSyscallRead()343 void IncrementSyscallRead() { 344 data_.this_cpu().syscall_read.fetch_add(1, std::memory_order_relaxed); 345 } IncrementTcpReadAlloc8k()346 void IncrementTcpReadAlloc8k() { 347 data_.this_cpu().tcp_read_alloc_8k.fetch_add(1, std::memory_order_relaxed); 348 } IncrementTcpReadAlloc64k()349 void IncrementTcpReadAlloc64k() { 350 data_.this_cpu().tcp_read_alloc_64k.fetch_add(1, std::memory_order_relaxed); 351 } IncrementHttp2SettingsWrites()352 void IncrementHttp2SettingsWrites() { 353 data_.this_cpu().http2_settings_writes.fetch_add(1, 354 std::memory_order_relaxed); 355 } IncrementHttp2PingsSent()356 void IncrementHttp2PingsSent() { 357 data_.this_cpu().http2_pings_sent.fetch_add(1, std::memory_order_relaxed); 358 } IncrementHttp2WritesBegun()359 void IncrementHttp2WritesBegun() { 360 data_.this_cpu().http2_writes_begun.fetch_add(1, std::memory_order_relaxed); 361 } IncrementHttp2TransportStalls()362 void IncrementHttp2TransportStalls() { 363 data_.this_cpu().http2_transport_stalls.fetch_add( 364 1, std::memory_order_relaxed); 365 } IncrementHttp2StreamStalls()366 void IncrementHttp2StreamStalls() { 367 data_.this_cpu().http2_stream_stalls.fetch_add(1, 368 std::memory_order_relaxed); 369 } IncrementCqPluckCreates()370 void IncrementCqPluckCreates() { 371 data_.this_cpu().cq_pluck_creates.fetch_add(1, std::memory_order_relaxed); 372 } IncrementCqNextCreates()373 void IncrementCqNextCreates() { 374 data_.this_cpu().cq_next_creates.fetch_add(1, std::memory_order_relaxed); 375 } IncrementCqCallbackCreates()376 void IncrementCqCallbackCreates() { 377 data_.this_cpu().cq_callback_creates.fetch_add(1, 378 std::memory_order_relaxed); 379 } IncrementWrrUpdates()380 void IncrementWrrUpdates() { 381 data_.this_cpu().wrr_updates.fetch_add(1, std::memory_order_relaxed); 382 } IncrementWorkSerializerItemsEnqueued()383 void IncrementWorkSerializerItemsEnqueued() { 384 data_.this_cpu().work_serializer_items_enqueued.fetch_add( 385 1, std::memory_order_relaxed); 386 } IncrementWorkSerializerItemsDequeued()387 void IncrementWorkSerializerItemsDequeued() { 388 data_.this_cpu().work_serializer_items_dequeued.fetch_add( 389 1, std::memory_order_relaxed); 390 } IncrementEconnabortedCount()391 void IncrementEconnabortedCount() { 392 data_.this_cpu().econnaborted_count.fetch_add(1, std::memory_order_relaxed); 393 } IncrementEconnresetCount()394 void IncrementEconnresetCount() { 395 data_.this_cpu().econnreset_count.fetch_add(1, std::memory_order_relaxed); 396 } IncrementEpipeCount()397 void IncrementEpipeCount() { 398 data_.this_cpu().epipe_count.fetch_add(1, std::memory_order_relaxed); 399 } IncrementEtimedoutCount()400 void IncrementEtimedoutCount() { 401 data_.this_cpu().etimedout_count.fetch_add(1, std::memory_order_relaxed); 402 } IncrementEconnrefusedCount()403 void IncrementEconnrefusedCount() { 404 data_.this_cpu().econnrefused_count.fetch_add(1, std::memory_order_relaxed); 405 } IncrementEnetunreachCount()406 void IncrementEnetunreachCount() { 407 data_.this_cpu().enetunreach_count.fetch_add(1, std::memory_order_relaxed); 408 } IncrementEnomsgCount()409 void IncrementEnomsgCount() { 410 data_.this_cpu().enomsg_count.fetch_add(1, std::memory_order_relaxed); 411 } IncrementEnotconnCount()412 void IncrementEnotconnCount() { 413 data_.this_cpu().enotconn_count.fetch_add(1, std::memory_order_relaxed); 414 } IncrementEnobufsCount()415 void IncrementEnobufsCount() { 416 data_.this_cpu().enobufs_count.fetch_add(1, std::memory_order_relaxed); 417 } IncrementUncommonIoErrorCount()418 void IncrementUncommonIoErrorCount() { 419 data_.this_cpu().uncommon_io_error_count.fetch_add( 420 1, std::memory_order_relaxed); 421 } IncrementMsgErrqueueErrorCount()422 void IncrementMsgErrqueueErrorCount() { 423 data_.this_cpu().msg_errqueue_error_count.fetch_add( 424 1, std::memory_order_relaxed); 425 } IncrementCallInitialSize(int value)426 void IncrementCallInitialSize(int value) { 427 data_.this_cpu().call_initial_size.Increment(value); 428 } IncrementTcpWriteSize(int value)429 void IncrementTcpWriteSize(int value) { 430 data_.this_cpu().tcp_write_size.Increment(value); 431 } IncrementTcpWriteIovSize(int value)432 void IncrementTcpWriteIovSize(int value) { 433 data_.this_cpu().tcp_write_iov_size.Increment(value); 434 } IncrementTcpReadSize(int value)435 void IncrementTcpReadSize(int value) { 436 data_.this_cpu().tcp_read_size.Increment(value); 437 } IncrementTcpReadOffer(int value)438 void IncrementTcpReadOffer(int value) { 439 data_.this_cpu().tcp_read_offer.Increment(value); 440 } IncrementTcpReadOfferIovSize(int value)441 void IncrementTcpReadOfferIovSize(int value) { 442 data_.this_cpu().tcp_read_offer_iov_size.Increment(value); 443 } IncrementHttp2SendMessageSize(int value)444 void IncrementHttp2SendMessageSize(int value) { 445 data_.this_cpu().http2_send_message_size.Increment(value); 446 } IncrementHttp2MetadataSize(int value)447 void IncrementHttp2MetadataSize(int value) { 448 data_.this_cpu().http2_metadata_size.Increment(value); 449 } IncrementWrrSubchannelListSize(int value)450 void IncrementWrrSubchannelListSize(int value) { 451 data_.this_cpu().wrr_subchannel_list_size.Increment(value); 452 } IncrementWrrSubchannelReadySize(int value)453 void IncrementWrrSubchannelReadySize(int value) { 454 data_.this_cpu().wrr_subchannel_ready_size.Increment(value); 455 } IncrementWorkSerializerRunTimeMs(int value)456 void IncrementWorkSerializerRunTimeMs(int value) { 457 data_.this_cpu().work_serializer_run_time_ms.Increment(value); 458 } IncrementWorkSerializerWorkTimeMs(int value)459 void IncrementWorkSerializerWorkTimeMs(int value) { 460 data_.this_cpu().work_serializer_work_time_ms.Increment(value); 461 } IncrementWorkSerializerWorkTimePerItemMs(int value)462 void IncrementWorkSerializerWorkTimePerItemMs(int value) { 463 data_.this_cpu().work_serializer_work_time_per_item_ms.Increment(value); 464 } IncrementWorkSerializerItemsPerRun(int value)465 void IncrementWorkSerializerItemsPerRun(int value) { 466 data_.this_cpu().work_serializer_items_per_run.Increment(value); 467 } IncrementChaoticGoodSendmsgsPerWriteControl(int value)468 void IncrementChaoticGoodSendmsgsPerWriteControl(int value) { 469 data_.this_cpu().chaotic_good_sendmsgs_per_write_control.Increment(value); 470 } IncrementChaoticGoodRecvmsgsPerReadControl(int value)471 void IncrementChaoticGoodRecvmsgsPerReadControl(int value) { 472 data_.this_cpu().chaotic_good_recvmsgs_per_read_control.Increment(value); 473 } IncrementChaoticGoodSendmsgsPerWriteData(int value)474 void IncrementChaoticGoodSendmsgsPerWriteData(int value) { 475 data_.this_cpu().chaotic_good_sendmsgs_per_write_data.Increment(value); 476 } IncrementChaoticGoodRecvmsgsPerReadData(int value)477 void IncrementChaoticGoodRecvmsgsPerReadData(int value) { 478 data_.this_cpu().chaotic_good_recvmsgs_per_read_data.Increment(value); 479 } IncrementChaoticGoodThreadHopsPerWriteControl(int value)480 void IncrementChaoticGoodThreadHopsPerWriteControl(int value) { 481 data_.this_cpu().chaotic_good_thread_hops_per_write_control.Increment( 482 value); 483 } IncrementChaoticGoodThreadHopsPerReadControl(int value)484 void IncrementChaoticGoodThreadHopsPerReadControl(int value) { 485 data_.this_cpu().chaotic_good_thread_hops_per_read_control.Increment(value); 486 } IncrementChaoticGoodThreadHopsPerWriteData(int value)487 void IncrementChaoticGoodThreadHopsPerWriteData(int value) { 488 data_.this_cpu().chaotic_good_thread_hops_per_write_data.Increment(value); 489 } IncrementChaoticGoodThreadHopsPerReadData(int value)490 void IncrementChaoticGoodThreadHopsPerReadData(int value) { 491 data_.this_cpu().chaotic_good_thread_hops_per_read_data.Increment(value); 492 } IncrementChaoticGoodTcpReadSizeData(int value)493 void IncrementChaoticGoodTcpReadSizeData(int value) { 494 data_.this_cpu().chaotic_good_tcp_read_size_data.Increment(value); 495 } IncrementChaoticGoodTcpReadSizeControl(int value)496 void IncrementChaoticGoodTcpReadSizeControl(int value) { 497 data_.this_cpu().chaotic_good_tcp_read_size_control.Increment(value); 498 } IncrementChaoticGoodTcpReadOfferData(int value)499 void IncrementChaoticGoodTcpReadOfferData(int value) { 500 data_.this_cpu().chaotic_good_tcp_read_offer_data.Increment(value); 501 } IncrementChaoticGoodTcpReadOfferControl(int value)502 void IncrementChaoticGoodTcpReadOfferControl(int value) { 503 data_.this_cpu().chaotic_good_tcp_read_offer_control.Increment(value); 504 } IncrementChaoticGoodTcpWriteSizeData(int value)505 void IncrementChaoticGoodTcpWriteSizeData(int value) { 506 data_.this_cpu().chaotic_good_tcp_write_size_data.Increment(value); 507 } IncrementChaoticGoodTcpWriteSizeControl(int value)508 void IncrementChaoticGoodTcpWriteSizeControl(int value) { 509 data_.this_cpu().chaotic_good_tcp_write_size_control.Increment(value); 510 } 511 512 private: 513 struct Data { 514 std::atomic<uint64_t> client_calls_created{0}; 515 std::atomic<uint64_t> server_calls_created{0}; 516 std::atomic<uint64_t> client_channels_created{0}; 517 std::atomic<uint64_t> client_subchannels_created{0}; 518 std::atomic<uint64_t> server_channels_created{0}; 519 std::atomic<uint64_t> insecure_connections_created{0}; 520 std::atomic<uint64_t> syscall_write{0}; 521 std::atomic<uint64_t> syscall_read{0}; 522 std::atomic<uint64_t> tcp_read_alloc_8k{0}; 523 std::atomic<uint64_t> tcp_read_alloc_64k{0}; 524 std::atomic<uint64_t> http2_settings_writes{0}; 525 std::atomic<uint64_t> http2_pings_sent{0}; 526 std::atomic<uint64_t> http2_writes_begun{0}; 527 std::atomic<uint64_t> http2_transport_stalls{0}; 528 std::atomic<uint64_t> http2_stream_stalls{0}; 529 std::atomic<uint64_t> cq_pluck_creates{0}; 530 std::atomic<uint64_t> cq_next_creates{0}; 531 std::atomic<uint64_t> cq_callback_creates{0}; 532 std::atomic<uint64_t> wrr_updates{0}; 533 std::atomic<uint64_t> work_serializer_items_enqueued{0}; 534 std::atomic<uint64_t> work_serializer_items_dequeued{0}; 535 std::atomic<uint64_t> econnaborted_count{0}; 536 std::atomic<uint64_t> econnreset_count{0}; 537 std::atomic<uint64_t> epipe_count{0}; 538 std::atomic<uint64_t> etimedout_count{0}; 539 std::atomic<uint64_t> econnrefused_count{0}; 540 std::atomic<uint64_t> enetunreach_count{0}; 541 std::atomic<uint64_t> enomsg_count{0}; 542 std::atomic<uint64_t> enotconn_count{0}; 543 std::atomic<uint64_t> enobufs_count{0}; 544 std::atomic<uint64_t> uncommon_io_error_count{0}; 545 std::atomic<uint64_t> msg_errqueue_error_count{0}; 546 HistogramCollector_65536_26 call_initial_size; 547 HistogramCollector_16777216_20 tcp_write_size; 548 HistogramCollector_80_10 tcp_write_iov_size; 549 HistogramCollector_16777216_20 tcp_read_size; 550 HistogramCollector_16777216_20 tcp_read_offer; 551 HistogramCollector_80_10 tcp_read_offer_iov_size; 552 HistogramCollector_16777216_20 http2_send_message_size; 553 HistogramCollector_65536_26 http2_metadata_size; 554 HistogramCollector_10000_20 wrr_subchannel_list_size; 555 HistogramCollector_10000_20 wrr_subchannel_ready_size; 556 HistogramCollector_100000_20 work_serializer_run_time_ms; 557 HistogramCollector_100000_20 work_serializer_work_time_ms; 558 HistogramCollector_100000_20 work_serializer_work_time_per_item_ms; 559 HistogramCollector_10000_20 work_serializer_items_per_run; 560 HistogramCollector_100_20 chaotic_good_sendmsgs_per_write_control; 561 HistogramCollector_100_20 chaotic_good_recvmsgs_per_read_control; 562 HistogramCollector_100_20 chaotic_good_sendmsgs_per_write_data; 563 HistogramCollector_100_20 chaotic_good_recvmsgs_per_read_data; 564 HistogramCollector_100_20 chaotic_good_thread_hops_per_write_control; 565 HistogramCollector_100_20 chaotic_good_thread_hops_per_read_control; 566 HistogramCollector_100_20 chaotic_good_thread_hops_per_write_data; 567 HistogramCollector_100_20 chaotic_good_thread_hops_per_read_data; 568 HistogramCollector_16777216_20 chaotic_good_tcp_read_size_data; 569 HistogramCollector_16777216_20 chaotic_good_tcp_read_size_control; 570 HistogramCollector_16777216_20 chaotic_good_tcp_read_offer_data; 571 HistogramCollector_16777216_20 chaotic_good_tcp_read_offer_control; 572 HistogramCollector_16777216_20 chaotic_good_tcp_write_size_data; 573 HistogramCollector_16777216_20 chaotic_good_tcp_write_size_control; 574 }; 575 PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)}; 576 }; 577 } // namespace grpc_core 578 579 #endif // GRPC_SRC_CORE_LIB_DEBUG_STATS_DATA_H 580