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_65536_26;
34 class Histogram_65536_26 {
35  public:
36   static int BucketFor(int value);
buckets()37   const uint64_t* buckets() const { return buckets_; }
38   friend Histogram_65536_26 operator-(const Histogram_65536_26& left,
39                                       const Histogram_65536_26& right);
40 
41  private:
42   friend class HistogramCollector_65536_26;
43   uint64_t buckets_[26]{};
44 };
45 class HistogramCollector_65536_26 {
46  public:
Increment(int value)47   void Increment(int value) {
48     buckets_[Histogram_65536_26::BucketFor(value)].fetch_add(
49         1, std::memory_order_relaxed);
50   }
51   void Collect(Histogram_65536_26* result) const;
52 
53  private:
54   std::atomic<uint64_t> buckets_[26]{};
55 };
56 class HistogramCollector_16777216_20;
57 class Histogram_16777216_20 {
58  public:
59   static int BucketFor(int value);
buckets()60   const uint64_t* buckets() const { return buckets_; }
61   friend Histogram_16777216_20 operator-(const Histogram_16777216_20& left,
62                                          const Histogram_16777216_20& right);
63 
64  private:
65   friend class HistogramCollector_16777216_20;
66   uint64_t buckets_[20]{};
67 };
68 class HistogramCollector_16777216_20 {
69  public:
Increment(int value)70   void Increment(int value) {
71     buckets_[Histogram_16777216_20::BucketFor(value)].fetch_add(
72         1, std::memory_order_relaxed);
73   }
74   void Collect(Histogram_16777216_20* result) const;
75 
76  private:
77   std::atomic<uint64_t> buckets_[20]{};
78 };
79 class HistogramCollector_80_10;
80 class Histogram_80_10 {
81  public:
82   static int BucketFor(int value);
buckets()83   const uint64_t* buckets() const { return buckets_; }
84   friend Histogram_80_10 operator-(const Histogram_80_10& left,
85                                    const Histogram_80_10& right);
86 
87  private:
88   friend class HistogramCollector_80_10;
89   uint64_t buckets_[10]{};
90 };
91 class HistogramCollector_80_10 {
92  public:
Increment(int value)93   void Increment(int value) {
94     buckets_[Histogram_80_10::BucketFor(value)].fetch_add(
95         1, std::memory_order_relaxed);
96   }
97   void Collect(Histogram_80_10* result) const;
98 
99  private:
100   std::atomic<uint64_t> buckets_[10]{};
101 };
102 struct GlobalStats {
103   enum class Counter {
104     kClientCallsCreated,
105     kServerCallsCreated,
106     kClientChannelsCreated,
107     kClientSubchannelsCreated,
108     kServerChannelsCreated,
109     kInsecureConnectionsCreated,
110     kSyscallWrite,
111     kSyscallRead,
112     kTcpReadAlloc8k,
113     kTcpReadAlloc64k,
114     kHttp2SettingsWrites,
115     kHttp2PingsSent,
116     kHttp2WritesBegun,
117     kHttp2TransportStalls,
118     kHttp2StreamStalls,
119     kCqPluckCreates,
120     kCqNextCreates,
121     kCqCallbackCreates,
122     COUNT
123   };
124   enum class Histogram {
125     kCallInitialSize,
126     kTcpWriteSize,
127     kTcpWriteIovSize,
128     kTcpReadSize,
129     kTcpReadOffer,
130     kTcpReadOfferIovSize,
131     kHttp2SendMessageSize,
132     kHttp2MetadataSize,
133     COUNT
134   };
135   GlobalStats();
136   static const absl::string_view counter_name[static_cast<int>(Counter::COUNT)];
137   static const absl::string_view
138       histogram_name[static_cast<int>(Histogram::COUNT)];
139   static const absl::string_view counter_doc[static_cast<int>(Counter::COUNT)];
140   static const absl::string_view
141       histogram_doc[static_cast<int>(Histogram::COUNT)];
142   union {
143     struct {
144       uint64_t client_calls_created;
145       uint64_t server_calls_created;
146       uint64_t client_channels_created;
147       uint64_t client_subchannels_created;
148       uint64_t server_channels_created;
149       uint64_t insecure_connections_created;
150       uint64_t syscall_write;
151       uint64_t syscall_read;
152       uint64_t tcp_read_alloc_8k;
153       uint64_t tcp_read_alloc_64k;
154       uint64_t http2_settings_writes;
155       uint64_t http2_pings_sent;
156       uint64_t http2_writes_begun;
157       uint64_t http2_transport_stalls;
158       uint64_t http2_stream_stalls;
159       uint64_t cq_pluck_creates;
160       uint64_t cq_next_creates;
161       uint64_t cq_callback_creates;
162     };
163     uint64_t counters[static_cast<int>(Counter::COUNT)];
164   };
165   Histogram_65536_26 call_initial_size;
166   Histogram_16777216_20 tcp_write_size;
167   Histogram_80_10 tcp_write_iov_size;
168   Histogram_16777216_20 tcp_read_size;
169   Histogram_16777216_20 tcp_read_offer;
170   Histogram_80_10 tcp_read_offer_iov_size;
171   Histogram_16777216_20 http2_send_message_size;
172   Histogram_65536_26 http2_metadata_size;
173   HistogramView histogram(Histogram which) const;
174   std::unique_ptr<GlobalStats> Diff(const GlobalStats& other) const;
175 };
176 class GlobalStatsCollector {
177  public:
178   std::unique_ptr<GlobalStats> Collect() const;
IncrementClientCallsCreated()179   void IncrementClientCallsCreated() {
180     data_.this_cpu().client_calls_created.fetch_add(1,
181                                                     std::memory_order_relaxed);
182   }
IncrementServerCallsCreated()183   void IncrementServerCallsCreated() {
184     data_.this_cpu().server_calls_created.fetch_add(1,
185                                                     std::memory_order_relaxed);
186   }
IncrementClientChannelsCreated()187   void IncrementClientChannelsCreated() {
188     data_.this_cpu().client_channels_created.fetch_add(
189         1, std::memory_order_relaxed);
190   }
IncrementClientSubchannelsCreated()191   void IncrementClientSubchannelsCreated() {
192     data_.this_cpu().client_subchannels_created.fetch_add(
193         1, std::memory_order_relaxed);
194   }
IncrementServerChannelsCreated()195   void IncrementServerChannelsCreated() {
196     data_.this_cpu().server_channels_created.fetch_add(
197         1, std::memory_order_relaxed);
198   }
IncrementInsecureConnectionsCreated()199   void IncrementInsecureConnectionsCreated() {
200     data_.this_cpu().insecure_connections_created.fetch_add(
201         1, std::memory_order_relaxed);
202   }
IncrementSyscallWrite()203   void IncrementSyscallWrite() {
204     data_.this_cpu().syscall_write.fetch_add(1, std::memory_order_relaxed);
205   }
IncrementSyscallRead()206   void IncrementSyscallRead() {
207     data_.this_cpu().syscall_read.fetch_add(1, std::memory_order_relaxed);
208   }
IncrementTcpReadAlloc8k()209   void IncrementTcpReadAlloc8k() {
210     data_.this_cpu().tcp_read_alloc_8k.fetch_add(1, std::memory_order_relaxed);
211   }
IncrementTcpReadAlloc64k()212   void IncrementTcpReadAlloc64k() {
213     data_.this_cpu().tcp_read_alloc_64k.fetch_add(1, std::memory_order_relaxed);
214   }
IncrementHttp2SettingsWrites()215   void IncrementHttp2SettingsWrites() {
216     data_.this_cpu().http2_settings_writes.fetch_add(1,
217                                                      std::memory_order_relaxed);
218   }
IncrementHttp2PingsSent()219   void IncrementHttp2PingsSent() {
220     data_.this_cpu().http2_pings_sent.fetch_add(1, std::memory_order_relaxed);
221   }
IncrementHttp2WritesBegun()222   void IncrementHttp2WritesBegun() {
223     data_.this_cpu().http2_writes_begun.fetch_add(1, std::memory_order_relaxed);
224   }
IncrementHttp2TransportStalls()225   void IncrementHttp2TransportStalls() {
226     data_.this_cpu().http2_transport_stalls.fetch_add(
227         1, std::memory_order_relaxed);
228   }
IncrementHttp2StreamStalls()229   void IncrementHttp2StreamStalls() {
230     data_.this_cpu().http2_stream_stalls.fetch_add(1,
231                                                    std::memory_order_relaxed);
232   }
IncrementCqPluckCreates()233   void IncrementCqPluckCreates() {
234     data_.this_cpu().cq_pluck_creates.fetch_add(1, std::memory_order_relaxed);
235   }
IncrementCqNextCreates()236   void IncrementCqNextCreates() {
237     data_.this_cpu().cq_next_creates.fetch_add(1, std::memory_order_relaxed);
238   }
IncrementCqCallbackCreates()239   void IncrementCqCallbackCreates() {
240     data_.this_cpu().cq_callback_creates.fetch_add(1,
241                                                    std::memory_order_relaxed);
242   }
IncrementCallInitialSize(int value)243   void IncrementCallInitialSize(int value) {
244     data_.this_cpu().call_initial_size.Increment(value);
245   }
IncrementTcpWriteSize(int value)246   void IncrementTcpWriteSize(int value) {
247     data_.this_cpu().tcp_write_size.Increment(value);
248   }
IncrementTcpWriteIovSize(int value)249   void IncrementTcpWriteIovSize(int value) {
250     data_.this_cpu().tcp_write_iov_size.Increment(value);
251   }
IncrementTcpReadSize(int value)252   void IncrementTcpReadSize(int value) {
253     data_.this_cpu().tcp_read_size.Increment(value);
254   }
IncrementTcpReadOffer(int value)255   void IncrementTcpReadOffer(int value) {
256     data_.this_cpu().tcp_read_offer.Increment(value);
257   }
IncrementTcpReadOfferIovSize(int value)258   void IncrementTcpReadOfferIovSize(int value) {
259     data_.this_cpu().tcp_read_offer_iov_size.Increment(value);
260   }
IncrementHttp2SendMessageSize(int value)261   void IncrementHttp2SendMessageSize(int value) {
262     data_.this_cpu().http2_send_message_size.Increment(value);
263   }
IncrementHttp2MetadataSize(int value)264   void IncrementHttp2MetadataSize(int value) {
265     data_.this_cpu().http2_metadata_size.Increment(value);
266   }
267 
268  private:
269   struct Data {
270     std::atomic<uint64_t> client_calls_created{0};
271     std::atomic<uint64_t> server_calls_created{0};
272     std::atomic<uint64_t> client_channels_created{0};
273     std::atomic<uint64_t> client_subchannels_created{0};
274     std::atomic<uint64_t> server_channels_created{0};
275     std::atomic<uint64_t> insecure_connections_created{0};
276     std::atomic<uint64_t> syscall_write{0};
277     std::atomic<uint64_t> syscall_read{0};
278     std::atomic<uint64_t> tcp_read_alloc_8k{0};
279     std::atomic<uint64_t> tcp_read_alloc_64k{0};
280     std::atomic<uint64_t> http2_settings_writes{0};
281     std::atomic<uint64_t> http2_pings_sent{0};
282     std::atomic<uint64_t> http2_writes_begun{0};
283     std::atomic<uint64_t> http2_transport_stalls{0};
284     std::atomic<uint64_t> http2_stream_stalls{0};
285     std::atomic<uint64_t> cq_pluck_creates{0};
286     std::atomic<uint64_t> cq_next_creates{0};
287     std::atomic<uint64_t> cq_callback_creates{0};
288     HistogramCollector_65536_26 call_initial_size;
289     HistogramCollector_16777216_20 tcp_write_size;
290     HistogramCollector_80_10 tcp_write_iov_size;
291     HistogramCollector_16777216_20 tcp_read_size;
292     HistogramCollector_16777216_20 tcp_read_offer;
293     HistogramCollector_80_10 tcp_read_offer_iov_size;
294     HistogramCollector_16777216_20 http2_send_message_size;
295     HistogramCollector_65536_26 http2_metadata_size;
296   };
297   PerCpu<Data> data_{PerCpuOptions().SetCpusPerShard(4).SetMaxShards(32)};
298 };
299 }  // namespace grpc_core
300 
301 #endif  // GRPC_SRC_CORE_LIB_DEBUG_STATS_DATA_H
302