GCC Code Coverage Report

Directory: cvmfs/
File: cvmfs/statistics.cc
Date: 2026-08-30 02:40:36
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 44 std::string Counter::ToString() { return StringifyInt(Get()); }
25 45 std::string Counter::Print() { return StringifyInt(Get()); }
26 45 std::string Counter::PrintK() { return StringifyInt(Get() / 1000); }
27 45 std::string Counter::PrintKi() { return StringifyInt(Get() / 1024); }
28 45 std::string Counter::PrintM() { return StringifyInt(Get() / (1000 * 1000)); }
29 45 std::string Counter::PrintMi() { return StringifyInt(Get() / (1024 * 1024)); }
30 90 std::string Counter::PrintRatio(Counter divider) {
31 90 const double enumerator_value = Get();
32 90 const double divider_value = divider.Get();
33 90 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 1900 Statistics *Statistics::Fork() {
48
1/2
✓ Branch 1 taken 1900 times.
✗ Branch 2 not taken.
 1900 Statistics *child = new Statistics();
49
50 1900 const MutexLockGuard lock_guard(lock_);
51 3800 for (map<string, CounterInfo *>::iterator i = counters_.begin(),
52 1900 iEnd = counters_.end();
53
2/2
✓ Branch 1 taken 74245 times.
✓ Branch 2 taken 1900 times.
 76145 i != iEnd;
54 74245 ++i) {
55 74245 atomic_inc32(&i->second->refcnt);
56 }
57
1/2
✓ Branch 1 taken 1900 times.
✗ Branch 2 not taken.
 1900 child->counters_ = counters_;
58
59 1900 return child;
60 1900 }
61
62
63 2095 Counter *Statistics::Lookup(const std::string &name) const {
64 2095 const MutexLockGuard lock_guard(lock_);
65
1/2
✓ Branch 1 taken 2095 times.
✗ Branch 2 not taken.
 2095 const map<string, CounterInfo *>::const_iterator i = counters_.find(name);
66
2/2
✓ Branch 2 taken 791 times.
✓ Branch 3 taken 1304 times.
 2095 if (i != counters_.end())
67 791 return &i->second->counter;
68 1304 return NULL;
69 2095 }
70
71
72 44 string Statistics::LookupDesc(const std::string &name) {
73 44 const MutexLockGuard lock_guard(lock_);
74
1/2
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
 44 const map<string, CounterInfo *>::const_iterator i = counters_.find(name);
75
1/2
✓ Branch 3 taken 44 times.
✗ Branch 4 not taken.
 44 if (i != counters_.end())
76
1/2
✓ Branch 2 taken 44 times.
✗ Branch 3 not taken.
 44 return i->second->desc;
77 ✗ return "";
78 44 }
79
80 44 string Statistics::PrintList(const PrintOptions print_options) {
81 44 string result;
82
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
 44 if (print_options == kPrintHeader)
83 ✗ result += "Name|Value|Description\n";
84
85 44 const MutexLockGuard lock_guard(lock_);
86 44 for (map<string, CounterInfo *>::const_iterator i = counters_.begin(),
87 44 iEnd = counters_.end();
88
2/2
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 44 times.
 88 i != iEnd;
89 44 ++i) {
90
4/8
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 44 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 44 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 44 times.
✗ Branch 12 not taken.
 88 result += i->first + "|" + i->second->counter.ToString() + "|"
91
3/6
✓ Branch 3 taken 44 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 44 times.
✗ Branch 7 not taken.
✓ Branch 9 taken 44 times.
✗ Branch 10 not taken.
 88 + i->second->desc + "\n";
92 }
93 88 return result;
94 44 }
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 95 string Statistics::PrintJSON() {
109 95 const MutexLockGuard lock_guard(lock_);
110
111 95 JsonStringGenerator json_statistics;
112
113 // Make use of std::map key ordering and add counters namespace by namespace
114 95 JsonStringGenerator json_statistics_namespace;
115
1/2
✓ Branch 2 taken 95 times.
✗ Branch 3 not taken.
 95 std::string last_namespace = "";
116 95 for (map<string, CounterInfo *>::const_iterator i = counters_.begin(),
117 95 iEnd = counters_.end();
118
2/2
✓ Branch 1 taken 132 times.
✓ Branch 2 taken 95 times.
 227 i != iEnd;
119 132 ++i) {
120
1/2
✓ Branch 2 taken 132 times.
✗ Branch 3 not taken.
 132 std::vector<std::string> tokens = SplitString(i->first, '.');
121
122
2/2
✓ Branch 2 taken 88 times.
✓ Branch 3 taken 44 times.
 132 if (tokens[0] != last_namespace) {
123
3/4
✓ Branch 1 taken 88 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 44 times.
✓ Branch 4 taken 44 times.
 88 if (last_namespace != "") {
124
1/2
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
 44 json_statistics.AddJsonObject(
125
1/2
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
 88 last_namespace, json_statistics_namespace.GenerateString());
126 }
127 88 json_statistics_namespace.Clear();
128 }
129
130
1/2
✓ Branch 4 taken 132 times.
✗ Branch 5 not taken.
 132 json_statistics_namespace.Add(tokens[1], i->second->counter.Get());
131
132
1/2
✓ Branch 2 taken 132 times.
✗ Branch 3 not taken.
 132 last_namespace = tokens[0];
133 132 }
134
3/4
✓ Branch 1 taken 95 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 44 times.
✓ Branch 4 taken 51 times.
 95 if (last_namespace != "") {
135
1/2
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
 44 json_statistics.AddJsonObject(last_namespace,
136
1/2
✓ Branch 1 taken 44 times.
✗ Branch 2 not taken.
 88 json_statistics_namespace.GenerateString());
137 }
138
139
1/2
✓ Branch 1 taken 95 times.
✗ Branch 2 not taken.
 190 return json_statistics.GenerateString();
140 95 }
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 352 void Statistics::SnapshotCounters(std::map<std::string, int64_t> *counters,
151 uint64_t *timestamp_ns) {
152 352 const MutexLockGuard lock_guard(lock_);
153 352 *timestamp_ns = platform_realtime_ns();
154 352 for (map<string, CounterInfo *>::const_iterator i = counters_.begin(),
155 352 iEnd = counters_.end();
156
2/2
✓ Branch 1 taken 1056 times.
✓ Branch 2 taken 352 times.
 1408 i != iEnd;
157 1056 ++i) {
158 // modify or insert
159
1/2
✓ Branch 4 taken 1056 times.
✗ Branch 5 not taken.
 1056 (*counters)[i->first] = (*i->second).counter.Get();
160 }
161 352 }
162
163 353312 Counter *Statistics::Register(const string &name, const string &desc) {
164 353312 const MutexLockGuard lock_guard(lock_);
165
2/5
✓ Branch 2 taken 353312 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 353312 times.
 353312 assert(counters_.find(name) == counters_.end());
166
2/4
✓ Branch 1 taken 353312 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 353312 times.
✗ Branch 5 not taken.
 353312 CounterInfo *counter_info = new CounterInfo(desc);
167
1/2
✓ Branch 1 taken 353312 times.
✗ Branch 2 not taken.
 353312 counters_[name] = counter_info;
168 353312 return &counter_info->counter;
169 353312 }
170
171
172 12662 Statistics::Statistics() {
173 12662 lock_ = reinterpret_cast<pthread_mutex_t *>(smalloc(sizeof(pthread_mutex_t)));
174 12662 const int retval = pthread_mutex_init(lock_, NULL);
175
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12662 times.
 12662 assert(retval == 0);
176 12662 }
177
178
179 12652 Statistics::~Statistics() {
180 25304 for (map<string, CounterInfo *>::iterator i = counters_.begin(),
181 12652 iEnd = counters_.end();
182
2/2
✓ Branch 1 taken 427356 times.
✓ Branch 2 taken 12652 times.
 440008 i != iEnd;
183 427356 ++i) {
184 427356 const int32_t old_value = atomic_xadd32(&i->second->refcnt, -1);
185
2/2
✓ Branch 0 taken 353111 times.
✓ Branch 1 taken 74245 times.
 427356 if (old_value == 1)
186
1/2
✓ Branch 1 taken 353111 times.
✗ Branch 2 not taken.
 353111 delete i->second;
187 }
188 12652 pthread_mutex_destroy(lock_);
189 12652 free(lock_);
190 12652 }
191
192
193 //------------------------------------------------------------------------------
194
195
196 /**
197 * If necessary, capacity_s is extended to be a multiple of resolution_s
198 */
199 16550 Recorder::Recorder(uint32_t resolution_s, uint32_t capacity_s)
200 16550 : last_timestamp_(0), capacity_s_(capacity_s), resolution_s_(resolution_s) {
201
2/4
✓ Branch 0 taken 16550 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 16550 times.
✗ Branch 3 not taken.
 16550 assert((resolution_s > 0) && (capacity_s > resolution_s));
202 16550 const bool has_remainder = (capacity_s_ % resolution_s_) != 0;
203
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 16462 times.
 16550 if (has_remainder) {
204 88 capacity_s_ += resolution_s_ - (capacity_s_ % resolution_s_);
205 }
206 16550 no_bins_ = capacity_s_ / resolution_s_;
207
1/2
✓ Branch 1 taken 16550 times.
✗ Branch 2 not taken.
 16550 bins_.reserve(no_bins_);
208
2/2
✓ Branch 0 taken 1328864 times.
✓ Branch 1 taken 16550 times.
 1345414 for (unsigned i = 0; i < no_bins_; ++i)
209
1/2
✓ Branch 1 taken 1328864 times.
✗ Branch 2 not taken.
 1328864 bins_.push_back(0);
210 16550 }
211
212
213 88 void Recorder::Tick() { TickAt(platform_monotonic_time()); }
214
215
216 5526 void Recorder::TickAt(uint64_t timestamp) {
217 5526 const uint64_t bin_abs = timestamp / resolution_s_;
218 5526 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 88 times.
✓ Branch 1 taken 5438 times.
 5526 if (bin_abs < last_bin_abs) {
222 // Do we still remember this event?
223
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 44 times.
 88 if ((last_bin_abs - bin_abs) < no_bins_)
224 44 bins_[bin_abs % no_bins_]++;
225 88 return;
226 }
227
228
2/2
✓ Branch 0 taken 1238 times.
✓ Branch 1 taken 4200 times.
 5438 if (last_bin_abs == bin_abs) {
229 1238 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 8400 const unsigned max_bins_clear = std::min(bin_abs,
234 4200 last_bin_abs + no_bins_ + 1);
235
2/2
✓ Branch 0 taken 77241 times.
✓ Branch 1 taken 4200 times.
 81441 for (uint64_t i = last_bin_abs + 1; i < max_bins_clear; ++i)
236 77241 bins_[i % no_bins_] = 0;
237 4200 bins_[bin_abs % no_bins_] = 1;
238 }
239
240 5438 last_timestamp_ = timestamp;
241 }
242
243
244 903 uint64_t Recorder::GetNoTicks(uint32_t retrospect_s) const {
245 903 const uint64_t now = platform_monotonic_time();
246
2/2
✓ Branch 0 taken 442 times.
✓ Branch 1 taken 461 times.
 903 if (retrospect_s > now)
247 442 retrospect_s = now;
248
249 903 const uint64_t last_bin_abs = last_timestamp_ / resolution_s_;
250 903 const uint64_t past_bin_abs = (now - retrospect_s) / resolution_s_;
251 1806 const int64_t min_bin_abs = std::max(
252 past_bin_abs,
253
2/2
✓ Branch 0 taken 569 times.
✓ Branch 1 taken 334 times.
 903 (last_bin_abs < no_bins_) ? 0 : (last_bin_abs - (no_bins_ - 1)));
254 903 uint64_t result = 0;
255
2/2
✓ Branch 0 taken 6300 times.
✓ Branch 1 taken 903 times.
 7203 for (int64_t i = last_bin_abs; i >= min_bin_abs; --i) {
256 6300 result += bins_[i % no_bins_];
257 }
258
259 903 return result;
260 }
261
262
263 //------------------------------------------------------------------------------
264
265
266 16154 void MultiRecorder::AddRecorder(uint32_t resolution_s, uint32_t capacity_s) {
267
1/2
✓ Branch 2 taken 16154 times.
✗ Branch 3 not taken.
 16154 recorders_.push_back(Recorder(resolution_s, capacity_s));
268 16154 }
269
270
271 332 uint64_t MultiRecorder::GetNoTicks(uint32_t retrospect_s) const {
272 332 const unsigned N = recorders_.size();
273
2/2
✓ Branch 0 taken 377 times.
✓ Branch 1 taken 45 times.
 422 for (unsigned i = 0; i < N; ++i) {
274
6/6
✓ Branch 2 taken 180 times.
✓ Branch 3 taken 197 times.
✓ Branch 4 taken 90 times.
✓ Branch 5 taken 90 times.
✓ Branch 6 taken 287 times.
✓ Branch 7 taken 90 times.
 377 if ((recorders_[i].capacity_s() >= retrospect_s) || (i == (N - 1))) {
275 287 return recorders_[i].GetNoTicks(retrospect_s);
276 }
277 }
278 45 return 0;
279 }
280
281
282 394 void MultiRecorder::Tick() {
283 394 const uint64_t now = platform_monotonic_time();
284
2/2
✓ Branch 1 taken 1306 times.
✓ Branch 2 taken 394 times.
 1700 for (unsigned i = 0; i < recorders_.size(); ++i)
285 1306 recorders_[i].TickAt(now);
286 394 }
287
288
289 900 void MultiRecorder::TickAt(uint64_t timestamp) {
290
2/2
✓ Branch 1 taken 1800 times.
✓ Branch 2 taken 900 times.
 2700 for (unsigned i = 0; i < recorders_.size(); ++i)
291 1800 recorders_[i].TickAt(timestamp);
292 900 }
293
294 } // namespace perf
295
296
297 #ifdef CVMFS_NAMESPACE_GUARD
298 } // namespace CVMFS_NAMESPACE_GUARD
299 #endif
300