8417539695

Committed 25 Mar 2024 09:01AM UTC coverage: 59.219% (+0.01%) from 59.208%

Build # 8417539695

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13914 from rgacogne/ddist-fix-xsk-error

dnsdist: Fix XSK-enabled check when reconnecting a backend

Run Details

32506 of 87994 branches covered (36.94%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

18 existing lines in 6 files now uncovered.

113619 of 158758 relevant lines covered (71.57%)

3314203.42 hits per line

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

95.74

/pdns/recursordist/test-rec-tcounters_cc.cc

#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
#endif

#define BOOST_TEST_NO_MAIN

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <boost/test/unit_test.hpp>

#include <unistd.h>
#include <thread>
#include "dns_random.hh"
#include "rec-tcounters.hh"

static rec::GlobalCounters global;
static thread_local rec::TCounters tlocal(global);

BOOST_AUTO_TEST_SUITE(test_rec_tcounters_cc)

BOOST_AUTO_TEST_CASE(destruct)
{
  global.reset();

  const size_t count = 100000;
  std::thread thread1([] {
    for (size_t i = 0; i < count; i++) {
      ++tlocal.at(rec::Counter::servFails);
    }
  });
  std::thread thread2([] {
    for (size_t i = 0; i < count; i++) {
      ++tlocal.at(rec::Counter::nxDomains);
    }
  });
  thread1.join();
  thread2.join();
  BOOST_CHECK_EQUAL(global.sum(rec::Counter::servFails), count);
  BOOST_CHECK_EQUAL(global.sum(rec::Counter::nxDomains), count);
}

BOOST_AUTO_TEST_CASE(update_fast)
{
  global.reset();

  std::atomic<uint64_t> done{};

  const size_t count = 10000000;
  std::thread thread1([&done] {
    for (size_t i = 0; i < count; i++) {
      ++tlocal.at(rec::Counter::servFails);
      ++tlocal.at(rec::Counter::nxDomains);
      tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(1.1);
      if (dns_random(10000) == 0) {
        tlocal.updateSnap();
      }
    }
    done++;
  });
  std::thread thread2([&done] {
    for (size_t i = 0; i < count / 2; i++) {
      ++tlocal.at(rec::Counter::servFails);
      ++tlocal.at(rec::Counter::nxDomains);
      tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(2.2);
      if (dns_random(10000) == 0) {
        tlocal.updateSnap();
      }
    }
    done++;
  });
  std::thread thread3([&done] {
    while (done < 2) {
      auto counts = global.aggregatedSnap();
      BOOST_CHECK_EQUAL(counts.uint64Count[0], counts.uint64Count[1]);
      auto avg = counts.at(rec::DoubleWAvgCounter::avgLatencyUsec).avg;
      BOOST_CHECK(avg == 0.0 || (avg >= 1.1 && avg <= 2.2));
    }
  });
  thread1.join();
  thread2.join();
  thread3.join();
  BOOST_CHECK_EQUAL(global.sum(rec::Counter::servFails), count + count / 2);
  BOOST_CHECK_EQUAL(global.sum(rec::Counter::nxDomains), count + count / 2);
  auto avg = global.avg(rec::DoubleWAvgCounter::avgLatencyUsec);
  BOOST_CHECK(avg >= 1.1 && avg <= 2.2);
}

BOOST_AUTO_TEST_CASE(update_with_sleep)
{

  global.reset();

  std::atomic<int> done{};

  const size_t count = 100;
  std::thread thread1([&done] {
    for (size_t i = 0; i < count; i++) {
      ++tlocal.at(rec::Counter::servFails);
      ++tlocal.at(rec::Counter::nxDomains);
      tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(1.1);
      if (dns_random(10000) == 0) {
        tlocal.updateSnap();
      }
      struct timespec interval
      {
        0, dns_random(20 * 1000 * 1000)
      };
      nanosleep(&interval, nullptr);
    }
    done++;
  });
  std::thread thread2([&done] {
    for (size_t i = 0; i < count / 2; i++) {
      ++tlocal.at(rec::Counter::servFails);
      ++tlocal.at(rec::Counter::nxDomains);
      tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(2.2);
      if (dns_random(10000) == 0) {
        tlocal.updateSnap();
      }
      struct timespec interval
      {
        0, dns_random(40 * 1000 * 1000)
      };
      nanosleep(&interval, nullptr);
    }
    done++;
  });
  std::thread thread3([&done] {
    while (done < 2) {
      auto counts = global.aggregatedSnap();
      BOOST_CHECK_EQUAL(counts.uint64Count[0], counts.uint64Count[1]);
      auto avg = counts.at(rec::DoubleWAvgCounter::avgLatencyUsec).avg;
      // std::cerr << avg << std::endl;
      BOOST_CHECK(avg == 0.0 || (avg >= 1.1 && avg <= 2.2));
      struct timespec interval
      {
        0, dns_random(80 * 1000 * 1000)
      };
      nanosleep(&interval, nullptr);
    }
  });
  thread1.join();
  thread2.join();
  thread3.join();
  BOOST_CHECK_EQUAL(global.sum(rec::Counter::servFails), count + count / 2);
  BOOST_CHECK_EQUAL(global.sum(rec::Counter::nxDomains), count + count / 2);
  auto avg = global.avg(rec::DoubleWAvgCounter::avgLatencyUsec);
  BOOST_CHECK(avg >= 1.1 && avg <= 2.2);
}

BOOST_AUTO_TEST_SUITE_END()

1	#ifndef BOOST_TEST_DYN_LINK
2	#define BOOST_TEST_DYN_LINK
3	#endif
4
5	#define BOOST_TEST_NO_MAIN
6
7	#ifdef HAVE_CONFIG_H
8	#include "config.h"
9	#endif
10
11	#include <boost/test/unit_test.hpp>
12
13	#include <unistd.h>
14	#include <thread>
15	#include "dns_random.hh"
16	#include "rec-tcounters.hh"
17
18	static rec::GlobalCounters global;
19	static thread_local rec::TCounters tlocal(global);
20
21	BOOST_AUTO_TEST_SUITE(test_rec_tcounters_cc)
22
23	BOOST_AUTO_TEST_CASE(destruct)
24	{	2✔
25	global.reset();	2✔
26
27	const size_t count = 100000;	2✔
28	std::thread thread1([] {	2✔
29	for (size_t i = 0; i < count; i++) {	200,002✔
30	++tlocal.at(rec::Counter::servFails);	200,000✔
31	}	200,000✔
32	});	2✔
33	std::thread thread2([] {	2✔
34	for (size_t i = 0; i < count; i++) {	200,002✔
35	++tlocal.at(rec::Counter::nxDomains);	200,000✔
36	}	200,000✔
37	});	2✔
38	thread1.join();	2✔
39	thread2.join();	2✔
40	BOOST_CHECK_EQUAL(global.sum(rec::Counter::servFails), count);	2✔
41	BOOST_CHECK_EQUAL(global.sum(rec::Counter::nxDomains), count);	2✔
42	}	2✔
43
44	BOOST_AUTO_TEST_CASE(update_fast)
45	{	2✔
46	global.reset();	2✔
47
48	std::atomic<uint64_t> done{};	2✔
49
50	const size_t count = 10000000;	2✔
51	std::thread thread1([&done] {	2✔
52	for (size_t i = 0; i < count; i++) {	20,000,002✔
53	++tlocal.at(rec::Counter::servFails);	20,000,000✔
54	++tlocal.at(rec::Counter::nxDomains);	20,000,000✔
55	tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(1.1);	20,000,000✔
56	if (dns_random(10000) == 0) {	20,000,000✔
57	tlocal.updateSnap();	1,993✔
58	}	1,993✔
59	}	20,000,000✔
60	done++;	2✔
61	});	2✔
62	std::thread thread2([&done] {	2✔
63	for (size_t i = 0; i < count / 2; i++) {	10,000,002✔
64	++tlocal.at(rec::Counter::servFails);	10,000,000✔
65	++tlocal.at(rec::Counter::nxDomains);	10,000,000✔
66	tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(2.2);	10,000,000✔
67	if (dns_random(10000) == 0) {	10,000,000✔
68	tlocal.updateSnap();	985✔
69	}	985✔
70	}	10,000,000✔
71	done++;	2✔
72	});	2✔
73	std::thread thread3([&done] {	2✔
74	while (done < 2) {	37,577✔
75	auto counts = global.aggregatedSnap();	37,575✔
76	BOOST_CHECK_EQUAL(counts.uint64Count[0], counts.uint64Count[1]);	37,575✔
77	auto avg = counts.at(rec::DoubleWAvgCounter::avgLatencyUsec).avg;	37,575✔
78	BOOST_CHECK(avg == 0.0 \|\| (avg >= 1.1 && avg <= 2.2));	37,575✔
79	}	37,575✔
80	});	2✔
81	thread1.join();	2✔
82	thread2.join();	2✔
83	thread3.join();	2✔
84	BOOST_CHECK_EQUAL(global.sum(rec::Counter::servFails), count + count / 2);	2✔
85	BOOST_CHECK_EQUAL(global.sum(rec::Counter::nxDomains), count + count / 2);	2✔
86	auto avg = global.avg(rec::DoubleWAvgCounter::avgLatencyUsec);	2✔
87	BOOST_CHECK(avg >= 1.1 && avg <= 2.2);	2✔
88	}	2✔
89
90	BOOST_AUTO_TEST_CASE(update_with_sleep)
91	{	2✔
92
93	global.reset();	2✔
94
95	std::atomic<int> done{};	2✔
96
97	const size_t count = 100;	2✔
98	std::thread thread1([&done] {	2✔
99	for (size_t i = 0; i < count; i++) {	202✔
100	++tlocal.at(rec::Counter::servFails);	200✔
101	++tlocal.at(rec::Counter::nxDomains);	200✔
102	tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(1.1);	200✔
103	if (dns_random(10000) == 0) {	200!
UNCOV 104	tlocal.updateSnap();	×
UNCOV 105	}	×
106	struct timespec interval	200✔
107	{	200✔
108	0, dns_random(20 * 1000 * 1000)	200✔
109	};	200✔
110	nanosleep(&interval, nullptr);	200✔
111	}	200✔
112	done++;	2✔
113	});	2✔
114	std::thread thread2([&done] {	2✔
115	for (size_t i = 0; i < count / 2; i++) {	102✔
116	++tlocal.at(rec::Counter::servFails);	100✔
117	++tlocal.at(rec::Counter::nxDomains);	100✔
118	tlocal.at(rec::DoubleWAvgCounter::avgLatencyUsec).add(2.2);	100✔
119	if (dns_random(10000) == 0) {	100!
120	tlocal.updateSnap();	×
121	}	×
122	struct timespec interval	100✔
123	{	100✔
124	0, dns_random(40 * 1000 * 1000)	100✔
125	};	100✔
126	nanosleep(&interval, nullptr);	100✔
127	}	100✔
128	done++;	2✔
129	});	2✔
130	std::thread thread3([&done] {	2✔
131	while (done < 2) {	52✔
132	auto counts = global.aggregatedSnap();	50✔
133	BOOST_CHECK_EQUAL(counts.uint64Count[0], counts.uint64Count[1]);	50✔
134	auto avg = counts.at(rec::DoubleWAvgCounter::avgLatencyUsec).avg;	50✔
135	// std::cerr << avg << std::endl;
136	BOOST_CHECK(avg == 0.0 \|\| (avg >= 1.1 && avg <= 2.2));	50✔
137	struct timespec interval	50✔
138	{	50✔
139	0, dns_random(80 * 1000 * 1000)	50✔
140	};	50✔
141	nanosleep(&interval, nullptr);	50✔
142	}	50✔
143	});	2✔
144	thread1.join();	2✔
145	thread2.join();	2✔
146	thread3.join();	2✔
147	BOOST_CHECK_EQUAL(global.sum(rec::Counter::servFails), count + count / 2);	2✔
148	BOOST_CHECK_EQUAL(global.sum(rec::Counter::nxDomains), count + count / 2);	2✔
149	auto avg = global.avg(rec::DoubleWAvgCounter::avgLatencyUsec);	2✔
150	BOOST_CHECK(avg >= 1.1 && avg <= 2.2);	2✔
151	}	2✔
152
153	BOOST_AUTO_TEST_SUITE_END()

PowerDNS / pdns / 8417539695

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