Directory: | cvmfs/ |
---|---|
File: | cvmfs/statistics.cc |
Date: | 2025-09-28 02:35:26 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 158 | 160 | 98.8% |
Branches: | 88 | 131 | 67.2% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /** | ||
2 | * This file is part of the CernVM File System. | ||
3 | */ | ||
4 | |||
5 | #include "statistics.h" | ||
6 | |||
7 | #include <algorithm> | ||
8 | #include <cassert> | ||
9 | |||
10 | #include "json_document_write.h" | ||
11 | #include "util/concurrency.h" | ||
12 | #include "util/platform.h" | ||
13 | #include "util/smalloc.h" | ||
14 | #include "util/string.h" | ||
15 | |||
16 | using namespace std; // NOLINT | ||
17 | |||
18 | #ifdef CVMFS_NAMESPACE_GUARD | ||
19 | namespace CVMFS_NAMESPACE_GUARD { | ||
20 | #endif | ||
21 | |||
22 | namespace perf { | ||
23 | |||
24 | 33 | std::string Counter::ToString() { return StringifyInt(Get()); } | |
25 | 34 | std::string Counter::Print() { return StringifyInt(Get()); } | |
26 | 34 | std::string Counter::PrintK() { return StringifyInt(Get() / 1000); } | |
27 | 34 | std::string Counter::PrintKi() { return StringifyInt(Get() / 1024); } | |
28 | 34 | std::string Counter::PrintM() { return StringifyInt(Get() / (1000 * 1000)); } | |
29 | 34 | std::string Counter::PrintMi() { return StringifyInt(Get() / (1024 * 1024)); } | |
30 | 68 | std::string Counter::PrintRatio(Counter divider) { | |
31 | 68 | const double enumerator_value = Get(); | |
32 | 68 | const double divider_value = divider.Get(); | |
33 | 68 | return StringifyDouble(enumerator_value / divider_value); | |
34 | } | ||
35 | |||
36 | |||
37 | //----------------------------------------------------------------------------- | ||
38 | |||
39 | |||
40 | /** | ||
41 | * Creates a new Statistics binder which maintains the same Counters as the | ||
42 | * existing one. Changes to those counters are visible in both Statistics | ||
43 | * objects. The child can then independently add more counters. CounterInfo | ||
44 | * objects are reference counted and deleted when all the statistics objects | ||
45 | * dealing with it are destroyed. | ||
46 | */ | ||
47 | 248 | Statistics *Statistics::Fork() { | |
48 |
1/2✓ Branch 1 taken 248 times.
✗ Branch 2 not taken.
|
248 | Statistics *child = new Statistics(); |
49 | |||
50 | 248 | const MutexLockGuard lock_guard(lock_); | |
51 | 496 | for (map<string, CounterInfo *>::iterator i = counters_.begin(), | |
52 | 248 | iEnd = counters_.end(); | |
53 |
2/2✓ Branch 1 taken 8594 times.
✓ Branch 2 taken 248 times.
|
8842 | i != iEnd; |
54 | 8594 | ++i) { | |
55 | 8594 | atomic_inc32(&i->second->refcnt); | |
56 | } | ||
57 |
1/2✓ Branch 1 taken 248 times.
✗ Branch 2 not taken.
|
248 | child->counters_ = counters_; |
58 | |||
59 | 248 | return child; | |
60 | 248 | } | |
61 | |||
62 | |||
63 | 979 | Counter *Statistics::Lookup(const std::string &name) const { | |
64 | 979 | const MutexLockGuard lock_guard(lock_); | |
65 |
1/2✓ Branch 1 taken 979 times.
✗ Branch 2 not taken.
|
979 | const map<string, CounterInfo *>::const_iterator i = counters_.find(name); |
66 |
2/2✓ Branch 2 taken 456 times.
✓ Branch 3 taken 523 times.
|
979 | if (i != counters_.end()) |
67 | 456 | return &i->second->counter; | |
68 | 523 | return NULL; | |
69 | 979 | } | |
70 | |||
71 | |||
72 | 33 | string Statistics::LookupDesc(const std::string &name) { | |
73 | 33 | const MutexLockGuard lock_guard(lock_); | |
74 |
1/2✓ Branch 1 taken 33 times.
✗ Branch 2 not taken.
|
33 | const map<string, CounterInfo *>::const_iterator i = counters_.find(name); |
75 |
1/2✓ Branch 3 taken 33 times.
✗ Branch 4 not taken.
|
33 | if (i != counters_.end()) |
76 |
1/2✓ Branch 2 taken 33 times.
✗ Branch 3 not taken.
|
33 | return i->second->desc; |
77 | ✗ | return ""; | |
78 | 33 | } | |
79 | |||
80 | 33 | string Statistics::PrintList(const PrintOptions print_options) { | |
81 | 33 | string result; | |
82 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 33 times.
|
33 | if (print_options == kPrintHeader) |
83 | ✗ | result += "Name|Value|Description\n"; | |
84 | |||
85 | 33 | const MutexLockGuard lock_guard(lock_); | |
86 | 33 | for (map<string, CounterInfo *>::const_iterator i = counters_.begin(), | |
87 | 33 | iEnd = counters_.end(); | |
88 |
2/2✓ Branch 1 taken 33 times.
✓ Branch 2 taken 33 times.
|
66 | i != iEnd; |
89 | 33 | ++i) { | |
90 |
4/8✓ Branch 1 taken 33 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 33 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 33 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 33 times.
✗ Branch 12 not taken.
|
66 | result += i->first + "|" + i->second->counter.ToString() + "|" |
91 |
3/6✓ Branch 3 taken 33 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 33 times.
✗ Branch 7 not taken.
✓ Branch 9 taken 33 times.
✗ Branch 10 not taken.
|
66 | + i->second->desc + "\n"; |
92 | } | ||
93 | 66 | return result; | |
94 | 33 | } | |
95 | |||
96 | /** | ||
97 | * Converts statistics counters into JSON string in following format | ||
98 | * { | ||
99 | * "name_major1": { | ||
100 | * "counter1": val1, | ||
101 | * "counter2": val2 | ||
102 | * }, | ||
103 | * "name_major2": { | ||
104 | * "counter3": val3 | ||
105 | * } | ||
106 | * } | ||
107 | */ | ||
108 | 93 | string Statistics::PrintJSON() { | |
109 | 93 | const MutexLockGuard lock_guard(lock_); | |
110 | |||
111 | 93 | JsonStringGenerator json_statistics; | |
112 | |||
113 | // Make use of std::map key ordering and add counters namespace by namespace | ||
114 | 93 | JsonStringGenerator json_statistics_namespace; | |
115 |
1/2✓ Branch 2 taken 93 times.
✗ Branch 3 not taken.
|
93 | std::string last_namespace = ""; |
116 | 93 | for (map<string, CounterInfo *>::const_iterator i = counters_.begin(), | |
117 | 93 | iEnd = counters_.end(); | |
118 |
2/2✓ Branch 1 taken 102 times.
✓ Branch 2 taken 93 times.
|
195 | i != iEnd; |
119 | 102 | ++i) { | |
120 |
1/2✓ Branch 2 taken 102 times.
✗ Branch 3 not taken.
|
102 | std::vector<std::string> tokens = SplitString(i->first, '.'); |
121 | |||
122 |
2/2✓ Branch 2 taken 68 times.
✓ Branch 3 taken 34 times.
|
102 | if (tokens[0] != last_namespace) { |
123 |
3/4✓ Branch 1 taken 68 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 34 times.
✓ Branch 4 taken 34 times.
|
68 | if (last_namespace != "") { |
124 |
1/2✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
|
34 | json_statistics.AddJsonObject( |
125 |
1/2✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
|
68 | last_namespace, json_statistics_namespace.GenerateString()); |
126 | } | ||
127 | 68 | json_statistics_namespace.Clear(); | |
128 | } | ||
129 | |||
130 |
1/2✓ Branch 4 taken 102 times.
✗ Branch 5 not taken.
|
102 | json_statistics_namespace.Add(tokens[1], i->second->counter.Get()); |
131 | |||
132 |
1/2✓ Branch 2 taken 102 times.
✗ Branch 3 not taken.
|
102 | last_namespace = tokens[0]; |
133 | 102 | } | |
134 |
3/4✓ Branch 1 taken 93 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 34 times.
✓ Branch 4 taken 59 times.
|
93 | if (last_namespace != "") { |
135 |
1/2✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
|
34 | json_statistics.AddJsonObject(last_namespace, |
136 |
1/2✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.
|
68 | json_statistics_namespace.GenerateString()); |
137 | } | ||
138 | |||
139 |
1/2✓ Branch 1 taken 93 times.
✗ Branch 2 not taken.
|
186 | return json_statistics.GenerateString(); |
140 | 93 | } | |
141 | |||
142 | /** | ||
143 | * Snapshot current state of the counters. | ||
144 | * Elements will either be updated or inserted into the map. | ||
145 | * | ||
146 | * Note: This function does NOT clear previous elements part of the map. | ||
147 | * | ||
148 | * Returns map of the updated counters and the timestamp of the snapshot. | ||
149 | */ | ||
150 | 312 | void Statistics::SnapshotCounters(std::map<std::string, int64_t> *counters, | |
151 | uint64_t *timestamp_ns) { | ||
152 | 312 | const MutexLockGuard lock_guard(lock_); | |
153 | 312 | *timestamp_ns = platform_realtime_ns(); | |
154 | 312 | for (map<string, CounterInfo *>::const_iterator i = counters_.begin(), | |
155 | 312 | iEnd = counters_.end(); | |
156 |
2/2✓ Branch 1 taken 936 times.
✓ Branch 2 taken 312 times.
|
1248 | i != iEnd; |
157 | 936 | ++i) { | |
158 | // modify or insert | ||
159 |
1/2✓ Branch 4 taken 936 times.
✗ Branch 5 not taken.
|
936 | (*counters)[i->first] = (*i->second).counter.Get(); |
160 | } | ||
161 | 312 | } | |
162 | |||
163 | 127931 | Counter *Statistics::Register(const string &name, const string &desc) { | |
164 | 127931 | const MutexLockGuard lock_guard(lock_); | |
165 |
2/5✓ Branch 2 taken 127931 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 127931 times.
|
127931 | assert(counters_.find(name) == counters_.end()); |
166 |
2/4✓ Branch 1 taken 127931 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 127931 times.
✗ Branch 5 not taken.
|
127931 | CounterInfo *counter_info = new CounterInfo(desc); |
167 |
1/2✓ Branch 1 taken 127931 times.
✗ Branch 2 not taken.
|
127931 | counters_[name] = counter_info; |
168 | 127931 | return &counter_info->counter; | |
169 | 127931 | } | |
170 | |||
171 | |||
172 | 5392 | Statistics::Statistics() { | |
173 | 5392 | lock_ = reinterpret_cast<pthread_mutex_t *>(smalloc(sizeof(pthread_mutex_t))); | |
174 | 5392 | const int retval = pthread_mutex_init(lock_, NULL); | |
175 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5392 times.
|
5392 | assert(retval == 0); |
176 | 5392 | } | |
177 | |||
178 | |||
179 | 5382 | Statistics::~Statistics() { | |
180 | 10764 | for (map<string, CounterInfo *>::iterator i = counters_.begin(), | |
181 | 5382 | iEnd = counters_.end(); | |
182 |
2/2✓ Branch 1 taken 136324 times.
✓ Branch 2 taken 5382 times.
|
141706 | i != iEnd; |
183 | 136324 | ++i) { | |
184 | 136324 | const int32_t old_value = atomic_xadd32(&i->second->refcnt, -1); | |
185 |
2/2✓ Branch 0 taken 127730 times.
✓ Branch 1 taken 8594 times.
|
136324 | if (old_value == 1) |
186 |
1/2✓ Branch 1 taken 127730 times.
✗ Branch 2 not taken.
|
127730 | delete i->second; |
187 | } | ||
188 | 5382 | pthread_mutex_destroy(lock_); | |
189 | 5382 | free(lock_); | |
190 | 5382 | } | |
191 | |||
192 | |||
193 | //------------------------------------------------------------------------------ | ||
194 | |||
195 | |||
196 | /** | ||
197 | * If necessary, capacity_s is extended to be a multiple of resolution_s | ||
198 | */ | ||
199 | 6522 | Recorder::Recorder(uint32_t resolution_s, uint32_t capacity_s) | |
200 | 6522 | : last_timestamp_(0), capacity_s_(capacity_s), resolution_s_(resolution_s) { | |
201 |
2/4✓ Branch 0 taken 6522 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6522 times.
✗ Branch 3 not taken.
|
6522 | assert((resolution_s > 0) && (capacity_s > resolution_s)); |
202 | 6522 | const bool has_remainder = (capacity_s_ % resolution_s_) != 0; | |
203 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 6454 times.
|
6522 | if (has_remainder) { |
204 | 68 | capacity_s_ += resolution_s_ - (capacity_s_ % resolution_s_); | |
205 | } | ||
206 | 6522 | no_bins_ = capacity_s_ / resolution_s_; | |
207 |
1/2✓ Branch 1 taken 6522 times.
✗ Branch 2 not taken.
|
6522 | bins_.reserve(no_bins_); |
208 |
2/2✓ Branch 0 taken 509964 times.
✓ Branch 1 taken 6522 times.
|
516486 | for (unsigned i = 0; i < no_bins_; ++i) |
209 |
1/2✓ Branch 1 taken 509964 times.
✗ Branch 2 not taken.
|
509964 | bins_.push_back(0); |
210 | 6522 | } | |
211 | |||
212 | |||
213 | 68 | void Recorder::Tick() { TickAt(platform_monotonic_time()); } | |
214 | |||
215 | |||
216 | 4066 | void Recorder::TickAt(uint64_t timestamp) { | |
217 | 4066 | const uint64_t bin_abs = timestamp / resolution_s_; | |
218 | 4066 | const uint64_t last_bin_abs = last_timestamp_ / resolution_s_; | |
219 | |||
220 | // timestamp in the past: don't update last_timestamp_ | ||
221 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 3998 times.
|
4066 | if (bin_abs < last_bin_abs) { |
222 | // Do we still remember this event? | ||
223 |
2/2✓ Branch 0 taken 34 times.
✓ Branch 1 taken 34 times.
|
68 | if ((last_bin_abs - bin_abs) < no_bins_) |
224 | 34 | bins_[bin_abs % no_bins_]++; | |
225 | 68 | return; | |
226 | } | ||
227 | |||
228 |
2/2✓ Branch 0 taken 882 times.
✓ Branch 1 taken 3116 times.
|
3998 | if (last_bin_abs == bin_abs) { |
229 | 882 | bins_[bin_abs % no_bins_]++; | |
230 | } else { | ||
231 | // When clearing bins between last_timestamp_ and now, avoid cycling the | ||
232 | // ring buffer multiple times. | ||
233 | 6232 | const unsigned max_bins_clear = std::min(bin_abs, | |
234 | 3116 | last_bin_abs + no_bins_ + 1); | |
235 |
2/2✓ Branch 0 taken 49050 times.
✓ Branch 1 taken 3116 times.
|
52166 | for (uint64_t i = last_bin_abs + 1; i < max_bins_clear; ++i) |
236 | 49050 | bins_[i % no_bins_] = 0; | |
237 | 3116 | bins_[bin_abs % no_bins_] = 1; | |
238 | } | ||
239 | |||
240 | 3998 | last_timestamp_ = timestamp; | |
241 | } | ||
242 | |||
243 | |||
244 | 674 | uint64_t Recorder::GetNoTicks(uint32_t retrospect_s) const { | |
245 | 674 | const uint64_t now = platform_monotonic_time(); | |
246 |
2/2✓ Branch 0 taken 340 times.
✓ Branch 1 taken 334 times.
|
674 | if (retrospect_s > now) |
247 | 340 | retrospect_s = now; | |
248 | |||
249 | 674 | const uint64_t last_bin_abs = last_timestamp_ / resolution_s_; | |
250 | 674 | const uint64_t past_bin_abs = (now - retrospect_s) / resolution_s_; | |
251 | 1348 | const int64_t min_bin_abs = std::max( | |
252 | past_bin_abs, | ||
253 |
2/2✓ Branch 0 taken 432 times.
✓ Branch 1 taken 242 times.
|
674 | (last_bin_abs < no_bins_) ? 0 : (last_bin_abs - (no_bins_ - 1))); |
254 | 674 | uint64_t result = 0; | |
255 |
2/2✓ Branch 0 taken 4524 times.
✓ Branch 1 taken 674 times.
|
5198 | for (int64_t i = last_bin_abs; i >= min_bin_abs; --i) { |
256 | 4524 | result += bins_[i % no_bins_]; | |
257 | } | ||
258 | |||
259 | 674 | return result; | |
260 | } | ||
261 | |||
262 | |||
263 | //------------------------------------------------------------------------------ | ||
264 | |||
265 | |||
266 | 6216 | void MultiRecorder::AddRecorder(uint32_t resolution_s, uint32_t capacity_s) { | |
267 |
1/2✓ Branch 2 taken 6216 times.
✗ Branch 3 not taken.
|
6216 | recorders_.push_back(Recorder(resolution_s, capacity_s)); |
268 | 6216 | } | |
269 | |||
270 | |||
271 | 232 | uint64_t MultiRecorder::GetNoTicks(uint32_t retrospect_s) const { | |
272 | 232 | const unsigned N = recorders_.size(); | |
273 |
2/2✓ Branch 0 taken 266 times.
✓ Branch 1 taken 34 times.
|
300 | for (unsigned i = 0; i < N; ++i) { |
274 |
6/6✓ Branch 2 taken 136 times.
✓ Branch 3 taken 130 times.
✓ Branch 4 taken 68 times.
✓ Branch 5 taken 68 times.
✓ Branch 6 taken 198 times.
✓ Branch 7 taken 68 times.
|
266 | if ((recorders_[i].capacity_s() >= retrospect_s) || (i == (N - 1))) { |
275 | 198 | return recorders_[i].GetNoTicks(retrospect_s); | |
276 | } | ||
277 | } | ||
278 | 34 | return 0; | |
279 | } | ||
280 | |||
281 | |||
282 | 260 | void MultiRecorder::Tick() { | |
283 | 260 | const uint64_t now = platform_monotonic_time(); | |
284 |
2/2✓ Branch 1 taken 836 times.
✓ Branch 2 taken 260 times.
|
1096 | for (unsigned i = 0; i < recorders_.size(); ++i) |
285 | 836 | recorders_[i].TickAt(now); | |
286 | 260 | } | |
287 | |||
288 | |||
289 | 680 | void MultiRecorder::TickAt(uint64_t timestamp) { | |
290 |
2/2✓ Branch 1 taken 1360 times.
✓ Branch 2 taken 680 times.
|
2040 | for (unsigned i = 0; i < recorders_.size(); ++i) |
291 | 1360 | recorders_[i].TickAt(timestamp); | |
292 | 680 | } | |
293 | |||
294 | } // namespace perf | ||
295 | |||
296 | |||
297 | #ifdef CVMFS_NAMESPACE_GUARD | ||
298 | } // namespace CVMFS_NAMESPACE_GUARD | ||
299 | #endif | ||
300 |