6548559177

Committed 17 Oct 2023 02:19PM UTC coverage: 56.394% (-1.1%) from 57.471%

Build # 6548559177

Build Type

Pull #13385

github

Committed by

web-flow

Commit Message

Merge 300515dd4 into 8314f12e9

Pull Request Pull Request #13385: Assorted delinting, mark do while loops as ok

Run Details

30679 of 84880 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 27 new or added lines in 4 files covered. (3.7%)

1959 existing lines in 37 files now uncovered.

103061 of 152274 relevant lines covered (67.68%)

2642590.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.12

/pdns/tcounters.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#pragma once

#include <sys/time.h>
#include <array>
#include <set>
#include <unistd.h>

#include "lock.hh"

namespace pdns
{
// We keep three sets of related counters:
//
// 1. The current counters (thread local, updated individually by thread code very often)
// 2. The snapshot counters (thread local, updated by thread code in one single mutex protected copy)
// 3. The history counters (global) to keep track of the counters of deleted threads

// We have two main classes: one that holds the thread local counters
// (both current and snapshot ones) and one that aggregates the
// values for all threads and keeps the history counters.

// The thread local current counters are the ones updated by
// performance critical code.  Every once in a while, all values in the
// current counters are copied to the snapshot thread local copies in
// a thread safe way.

// The snapshot counters are aggregated by the GlobalCounters
// class, as these can be accessed safely from multiple threads.

// Make sure to call the thread local tlocal.updatesAtomics() once
// in a while. This will fill the snapshot values for that thread if some
// time has passed since the last snap update.

// To fetch aggregate values, call globals.sum(counter1) or
// globals.avg(counter2), or any aggreggation function.  If multiple
// counters need to be collected in a consistent way:
// auto data = globals.aggregatedSnap();
//
// Note that the aggregate values can mix somewhat older thread-local
// with newer thread-local info from another thread. So it is possible
// to see the following:
//
// If thread T1 increments "received" and then passes the packet to
// thread T2 that increments "processed", it may happen that the value
// of "processed" observed by sum() is higher than "received", as T1
// might not have called updateSnap() yet while T2 did.  To avoid this
// inconsistency, be careful to update related counters in a single
// thread only.

// For an example of the use of these templates, see rec-tcounters.hh

template <typename Counters>
class TLocalCounters;

template <typename Counters>
class GlobalCounters
{
public:
  // Register a thread local set of values
  void subscribe(TLocalCounters<Counters>* ptr)
  {
    auto lock = d_guarded.lock();
    lock->d_instances.emplace(ptr);
  }

  // Unregister, typically done when a thread exits
  void unsubscribe(TLocalCounters<Counters>* ptr, const Counters& data)
  {
    auto lock = d_guarded.lock();
    lock->d_instances.erase(ptr);
    lock->d_history.merge(data);
  }

  // Two ways of computing aggregated values for a specific counter: simple additions of all thread data, or taking weighted averages into account
  template <typename Enum>
  auto sum(Enum index);
  template <typename Enum>
  auto avg(Enum index);
  template <typename Enum>
  auto max(Enum index);

  // Aggregate all counter data for all threads
  Counters aggregatedSnap();

  // Reset history
  void reset()
  {
    auto lock = d_guarded.lock();
    lock->d_history = Counters();
  }

private:
  struct Guarded
  {
    // We have x instances, normally one per thread
    std::set<TLocalCounters<Counters>*> d_instances;
    // If an instance gets deleted because its thread is cleaned up, the values
    // are accumulated in d_history
    Counters d_history;
  };
  LockGuarded<Guarded> d_guarded;
};

template <typename Counters>
class TLocalCounters
{
public:
  static const suseconds_t defaultSnapUpdatePeriodus = 100000;
  TLocalCounters(GlobalCounters<Counters>& collector, timeval interval = timeval{0, defaultSnapUpdatePeriodus}) :
    d_collector(collector), d_interval(interval)
  {
    collector.subscribe(this);
  }

  ~TLocalCounters()
  {
    d_collector.unsubscribe(this, d_current);
  }

  TLocalCounters(const TLocalCounters&) = delete;
  TLocalCounters(TLocalCounters&&) = delete;
  TLocalCounters& operator=(const TLocalCounters&) = delete;
  TLocalCounters& operator=(TLocalCounters&&) = delete;

  template <typename Enum>
  auto& at(Enum index)
  {
    return d_current.at(index);
  }

  template <typename Enum>
  auto snapAt(Enum index)
  {
    return d_snapshot.lock()->at(index);
  }

  [[nodiscard]] Counters getSnap()
  {
    return *(d_snapshot.lock());
  }

  bool updateSnap(const timeval& tv_now, bool force = false)
  {
    timeval tv_diff{};

    if (!force) {
      timersub(&tv_now, &d_last, &tv_diff);
    }
    if (force || timercmp(&tv_diff, &d_interval, >=)) {
      // It's a copy
      *(d_snapshot.lock()) = d_current;
      d_last = tv_now;
      return true;
    }
    return false;
  }

  bool updateSnap(bool force = false)
  {
    timeval tv_now{};

    if (!force) {
      gettimeofday(&tv_now, nullptr);
    }
    return updateSnap(tv_now, force);
  }

private:
  GlobalCounters<Counters>& d_collector;
  Counters d_current;
  LockGuarded<Counters> d_snapshot;
  timeval d_last{0, 0};
  const timeval d_interval;
};

// Sum for a specific index
// In the future we might want to move the specifics of computing an aggregated value to the
// app specific Counters class
template <typename Counters>
template <typename Enum>
auto GlobalCounters<Counters>::sum(Enum index)
{
  auto lock = d_guarded.lock();
  auto sum = lock->d_history.at(index);
  for (const auto& instance : lock->d_instances) {
    sum += instance->snapAt(index);
  }
  return sum;
}

// Average for a specific index
// In the future we might want to move the specifics of computing an aggregated value to the
// app specific Counters class
template <typename Counters>
template <typename Enum>
auto GlobalCounters<Counters>::avg(Enum index)
{
  auto lock = d_guarded.lock();
  auto wavg = lock->d_history.at(index);
  auto sum = wavg.avg * wavg.weight;
  auto count = wavg.weight;
  for (const auto& instance : lock->d_instances) {
    auto val = instance->snapAt(index);
    count += val.weight;
    sum += val.avg * val.weight;
  }
  return count > 0 ? sum / count : 0;
}

// Max for a specific  index
// In the future we might want to move the specifics of computing an aggregated value to the
// app specific Counters class
template <typename Counters>
template <typename Enum>
auto GlobalCounters<Counters>::max(Enum index)
{
  auto lock = d_guarded.lock();
  uint64_t max = 0; // ignore history
  for (const auto& instance : lock->d_instances) {
    max = std::max(instance->snapAt(index), max);
  }
  return max;
}

// Get a consistent snap of *all* aggregated values
template <typename Counters>
Counters GlobalCounters<Counters>::aggregatedSnap()
{
  auto lock = d_guarded.lock();
  Counters ret = lock->d_history;
  for (const auto& instance : lock->d_instances) {
    auto snap = instance->getSnap();
    ret.merge(snap);
  }
  return ret;
}

}

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22
23	#pragma once
24
25	#include <sys/time.h>
26	#include <array>
27	#include <set>
28	#include <unistd.h>
29
30	#include "lock.hh"
31
32	namespace pdns
33	{
34	// We keep three sets of related counters:
35	//
36	// 1. The current counters (thread local, updated individually by thread code very often)
37	// 2. The snapshot counters (thread local, updated by thread code in one single mutex protected copy)
38	// 3. The history counters (global) to keep track of the counters of deleted threads
39
40	// We have two main classes: one that holds the thread local counters
41	// (both current and snapshot ones) and one that aggregates the
42	// values for all threads and keeps the history counters.
43
44	// The thread local current counters are the ones updated by
45	// performance critical code. Every once in a while, all values in the
46	// current counters are copied to the snapshot thread local copies in
47	// a thread safe way.
48
49	// The snapshot counters are aggregated by the GlobalCounters
50	// class, as these can be accessed safely from multiple threads.
51
52	// Make sure to call the thread local tlocal.updatesAtomics() once
53	// in a while. This will fill the snapshot values for that thread if some
54	// time has passed since the last snap update.
55
56	// To fetch aggregate values, call globals.sum(counter1) or
57	// globals.avg(counter2), or any aggreggation function. If multiple
58	// counters need to be collected in a consistent way:
59	// auto data = globals.aggregatedSnap();
60	//
61	// Note that the aggregate values can mix somewhat older thread-local
62	// with newer thread-local info from another thread. So it is possible
63	// to see the following:
64	//
65	// If thread T1 increments "received" and then passes the packet to
66	// thread T2 that increments "processed", it may happen that the value
67	// of "processed" observed by sum() is higher than "received", as T1
68	// might not have called updateSnap() yet while T2 did. To avoid this
69	// inconsistency, be careful to update related counters in a single
70	// thread only.
71
72	// For an example of the use of these templates, see rec-tcounters.hh
73
74	template <typename Counters>
75	class TLocalCounters;
76
77	template <typename Counters>
78	class GlobalCounters
79	{
80	public:
81	// Register a thread local set of values
82	void subscribe(TLocalCounters<Counters>* ptr)
83	{	7✔
84	auto lock = d_guarded.lock();	7✔
85	lock->d_instances.emplace(ptr);	7✔
86	}	7✔
87
88	// Unregister, typically done when a thread exits
89	void unsubscribe(TLocalCounters<Counters>* ptr, const Counters& data)
90	{	7✔
91	auto lock = d_guarded.lock();	7✔
92	lock->d_instances.erase(ptr);	7✔
93	lock->d_history.merge(data);	7✔
94	}	7✔
95
96	// Two ways of computing aggregated values for a specific counter: simple additions of all thread data, or taking weighted averages into account
97	template <typename Enum>
98	auto sum(Enum index);
99	template <typename Enum>
100	auto avg(Enum index);
101	template <typename Enum>
102	auto max(Enum index);
103
104	// Aggregate all counter data for all threads
105	Counters aggregatedSnap();
106
107	// Reset history
108	void reset()
109	{	3✔
110	auto lock = d_guarded.lock();	3✔
111	lock->d_history = Counters();	3✔
112	}	3✔
113
114	private:
115	struct Guarded
116	{
117	// We have x instances, normally one per thread
118	std::set<TLocalCounters<Counters>*> d_instances;
119	// If an instance gets deleted because its thread is cleaned up, the values
120	// are accumulated in d_history
121	Counters d_history;
122	};
123	LockGuarded<Guarded> d_guarded;
124	};
125
126	template <typename Counters>
127	class TLocalCounters
128	{
129	public:
130	static const suseconds_t defaultSnapUpdatePeriodus = 100000;
131	TLocalCounters(GlobalCounters<Counters>& collector, timeval interval = timeval{0, defaultSnapUpdatePeriodus}) :
132	d_collector(collector), d_interval(interval)
133	{	7✔
134	collector.subscribe(this);	7✔
135	}	7✔
136
137	~TLocalCounters()
138	{	7✔
139	d_collector.unsubscribe(this, d_current);	7✔
140	}	7✔
141
142	TLocalCounters(const TLocalCounters&) = delete;
143	TLocalCounters(TLocalCounters&&) = delete;
144	TLocalCounters& operator=(const TLocalCounters&) = delete;
145	TLocalCounters& operator=(TLocalCounters&&) = delete;
146
147	template <typename Enum>
148	auto& at(Enum index)
149	{	45,206,579✔
150	return d_current.at(index);	45,206,579✔
151	}	45,206,579✔
152
153	template <typename Enum>
154	auto snapAt(Enum index)
UNCOV 155	{	×
UNCOV 156	return d_snapshot.lock()->at(index);	×
UNCOV 157	}	×
158
159	[[nodiscard]] Counters getSnap()
160	{	33,902✔
161	return *(d_snapshot.lock());	33,902✔
162	}	33,902✔
163
164	bool updateSnap(const timeval& tv_now, bool force = false)
165	{	1,528✔
166	timeval tv_diff{};	1,528✔
167
168	if (!force) {	1,528!
169	timersub(&tv_now, &d_last, &tv_diff);	1,528✔
170	}	1,528✔
171	if (force \|\| timercmp(&tv_diff, &d_interval, >=)) {	1,528!
172	// It's a copy
173	*(d_snapshot.lock()) = d_current;	148✔
174	d_last = tv_now;	148✔
175	return true;	148✔
176	}	148✔
177	return false;	1,380✔
178	}	1,528✔
179
180	bool updateSnap(bool force = false)
181	{	1,528✔
182	timeval tv_now{};	1,528✔
183
184	if (!force) {	1,528!
185	gettimeofday(&tv_now, nullptr);	1,528✔
186	}	1,528✔
187	return updateSnap(tv_now, force);	1,528✔
188	}	1,528✔
189
190	private:
191	GlobalCounters<Counters>& d_collector;
192	Counters d_current;
193	LockGuarded<Counters> d_snapshot;
194	timeval d_last{0, 0};
195	const timeval d_interval;
196	};
197
198	// Sum for a specific index
199	// In the future we might want to move the specifics of computing an aggregated value to the
200	// app specific Counters class
201	template <typename Counters>
202	template <typename Enum>
203	auto GlobalCounters<Counters>::sum(Enum index)
204	{	6✔
205	auto lock = d_guarded.lock();	6✔
206	auto sum = lock->d_history.at(index);	6✔
207	for (const auto& instance : lock->d_instances) {	6!
UNCOV 208	sum += instance->snapAt(index);	×
UNCOV 209	}	×
210	return sum;	6✔
211	}	6✔
212
213	// Average for a specific index
214	// In the future we might want to move the specifics of computing an aggregated value to the
215	// app specific Counters class
216	template <typename Counters>
217	template <typename Enum>
218	auto GlobalCounters<Counters>::avg(Enum index)
219	{	2✔
220	auto lock = d_guarded.lock();	2✔
221	auto wavg = lock->d_history.at(index);	2✔
222	auto sum = wavg.avg * wavg.weight;	2✔
223	auto count = wavg.weight;	2✔
224	for (const auto& instance : lock->d_instances) {	2!
225	auto val = instance->snapAt(index);	×
226	count += val.weight;	×
227	sum += val.avg * val.weight;	×
228	}	×
229	return count > 0 ? sum / count : 0;	2!
230	}	2✔
231
232	// Max for a specific index
233	// In the future we might want to move the specifics of computing an aggregated value to the
234	// app specific Counters class
235	template <typename Counters>
236	template <typename Enum>
237	auto GlobalCounters<Counters>::max(Enum index)
238	{
239	auto lock = d_guarded.lock();
240	uint64_t max = 0; // ignore history
241	for (const auto& instance : lock->d_instances) {	×
242	max = std::max(instance->snapAt(index), max);
243	}
244	return max;
245	}
246
247	// Get a consistent snap of all aggregated values
248	template <typename Counters>
249	Counters GlobalCounters<Counters>::aggregatedSnap()
250	{	23,681✔
251	auto lock = d_guarded.lock();	23,681✔
252	Counters ret = lock->d_history;	23,681✔
253	for (const auto& instance : lock->d_instances) {	33,902✔
254	auto snap = instance->getSnap();	33,902✔
255	ret.merge(snap);	33,902✔
256	}	33,902✔
257	return ret;	23,681✔
258	}	23,681✔
259
260	}

PowerDNS / pdns / 6548559177

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous