rec: Prevent false sharing for the recursor's metrics

pdns/rec_channel_rec.cc

@@ -74,7 +74,7 @@ bool PrefixDashNumberCompare::operator()(const std::string& a, const std::string
 }
 
 static map<string, const uint32_t*> d_get32bitpointers;
-static map<string, const std::atomic<uint64_t>*> d_getatomics;
+static map<string, const pdns::stat_t*> d_getatomics;
 static map<string, std::function<uint64_t()>>  d_get64bitmembers;
 static map<string, std::function<StatsMap()>> d_getmultimembers;
 
@@ -112,7 +112,7 @@ static void addGetStat(const string& name, const uint32_t* place)
   d_get32bitpointers[name] = place;
 }
 
-static void addGetStat(const string& name, const std::atomic<uint64_t>* place)
+static void addGetStat(const string& name, const pdns::stat_t* place)
 {
   d_getatomics[name] = place;
 }
@@ -1164,7 +1164,7 @@ static StatsMap toCPUStatsMap(const string& name)
   return entries;
 }
 
-static StatsMap toRPZStatsMap(const string& name, LockGuarded<std::unordered_map<std::string, std::atomic<uint64_t>>>& map)
+static StatsMap toRPZStatsMap(const string& name, LockGuarded<std::unordered_map<std::string, pdns::stat_t>>& map)
 {
   const string pbasename = getPrometheusName(name);
   StatsMap entries;

pdns/recursor_cache.hh

@@ -38,6 +38,7 @@
 #include <boost/version.hpp>
 #include "iputils.hh"
 #include "lock.hh"
+#include "stat_t.hh"
 #include "validate.hh"
 #undef max
 
@@ -67,7 +68,7 @@ public:
   bool doAgeCache(time_t now, const DNSName& name, QType qtype, uint32_t newTTL);
   bool updateValidationStatus(time_t now, const DNSName &qname, QType qt, const ComboAddress& who, const OptTag& routingTag, bool requireAuth, vState newState, boost::optional<time_t> capTTD);
 
-  std::atomic<uint64_t> cacheHits{0}, cacheMisses{0};
+  pdns::stat_t cacheHits{0}, cacheMisses{0};
 
 private:
 
@@ -224,7 +225,7 @@ private:
       }
     };
 
-    std::atomic<uint64_t> d_entriesCount{0};
+    pdns::stat_t d_entriesCount{0};
 
     LockGuardedTryHolder<LockedContent> lock()
     {

pdns/recursordist/aggressive_nsec.hh

@@ -32,6 +32,7 @@
 #include "dnsname.hh"
 #include "dnsrecords.hh"
 #include "lock.hh"
+#include "stat_t.hh"
 
 class AggressiveNSECCache
 {
@@ -137,11 +138,11 @@ private:
   void updateEntriesCount(SuffixMatchTree<std::shared_ptr<LockGuarded<ZoneEntry>>>& zones);
 
   SharedLockGuarded<SuffixMatchTree<std::shared_ptr<LockGuarded<ZoneEntry>>>> d_zones;
-  std::atomic<uint64_t> d_nsecHits{0};
-  std::atomic<uint64_t> d_nsec3Hits{0};
-  std::atomic<uint64_t> d_nsecWildcardHits{0};
-  std::atomic<uint64_t> d_nsec3WildcardHits{0};
-  std::atomic<uint64_t> d_entriesCount{0};
+  pdns::stat_t d_nsecHits{0};
+  pdns::stat_t d_nsec3Hits{0};
+  pdns::stat_t d_nsecWildcardHits{0};
+  pdns::stat_t d_nsec3WildcardHits{0};
+  pdns::stat_t d_entriesCount{0};
   uint64_t d_maxEntries{0};
 };
 

pdns/recursordist/negcache.hh

@@ -29,6 +29,7 @@
 #include "dnsname.hh"
 #include "dns.hh"
 #include "lock.hh"
+#include "stat_t.hh"
 #include "validate.hh"
 
 using namespace ::boost::multi_index;
@@ -113,7 +114,7 @@ private:
       uint64_t d_acquired_count{0};
       void invalidate() {}
     };
-    std::atomic<uint64_t> d_entriesCount{0};
+    pdns::stat_t d_entriesCount{0};
 
     LockGuardedTryHolder<MapCombo::LockedContent> lock()
     {

pdns/syncres.cc

@@ -65,22 +65,22 @@ unsigned int SyncRes::s_serverdownthrottletime;
 unsigned int SyncRes::s_nonresolvingnsmaxfails;
 unsigned int SyncRes::s_nonresolvingnsthrottletime;
 unsigned int SyncRes::s_ecscachelimitttl;
-std::atomic<uint64_t> SyncRes::s_authzonequeries;
-std::atomic<uint64_t> SyncRes::s_queries;
-std::atomic<uint64_t> SyncRes::s_outgoingtimeouts;
-std::atomic<uint64_t> SyncRes::s_outgoing4timeouts;
-std::atomic<uint64_t> SyncRes::s_outgoing6timeouts;
-std::atomic<uint64_t> SyncRes::s_outqueries;
-std::atomic<uint64_t> SyncRes::s_tcpoutqueries;
-std::atomic<uint64_t> SyncRes::s_dotoutqueries;
-std::atomic<uint64_t> SyncRes::s_throttledqueries;
-std::atomic<uint64_t> SyncRes::s_dontqueries;
-std::atomic<uint64_t> SyncRes::s_qnameminfallbacksuccess;
-std::atomic<uint64_t> SyncRes::s_unreachables;
-std::atomic<uint64_t> SyncRes::s_ecsqueries;
-std::atomic<uint64_t> SyncRes::s_ecsresponses;
-std::map<uint8_t, std::atomic<uint64_t>> SyncRes::s_ecsResponsesBySubnetSize4;
-std::map<uint8_t, std::atomic<uint64_t>> SyncRes::s_ecsResponsesBySubnetSize6;
+pdns::stat_t SyncRes::s_authzonequeries;
+pdns::stat_t SyncRes::s_queries;
+pdns::stat_t SyncRes::s_outgoingtimeouts;
+pdns::stat_t SyncRes::s_outgoing4timeouts;
+pdns::stat_t SyncRes::s_outgoing6timeouts;
+pdns::stat_t SyncRes::s_outqueries;
+pdns::stat_t SyncRes::s_tcpoutqueries;
+pdns::stat_t SyncRes::s_dotoutqueries;
+pdns::stat_t SyncRes::s_throttledqueries;
+pdns::stat_t SyncRes::s_dontqueries;
+pdns::stat_t SyncRes::s_qnameminfallbacksuccess;
+pdns::stat_t SyncRes::s_unreachables;
+pdns::stat_t SyncRes::s_ecsqueries;
+pdns::stat_t SyncRes::s_ecsresponses;
+std::map<uint8_t, pdns::stat_t> SyncRes::s_ecsResponsesBySubnetSize4;
+std::map<uint8_t, pdns::stat_t> SyncRes::s_ecsResponsesBySubnetSize6;
 
 uint8_t SyncRes::s_ecsipv4limit;
 uint8_t SyncRes::s_ecsipv6limit;

pdns/syncres.hh

@@ -52,6 +52,7 @@
 #include "proxy-protocol.hh"
 #include "sholder.hh"
 #include "histogram.hh"
+#include "stat_t.hh"
 #include "tcpiohandler.hh"
 
 #ifdef HAVE_CONFIG_H
@@ -734,22 +735,22 @@ public:
 
   static thread_local ThreadLocalStorage t_sstorage;
 
-  static std::atomic<uint64_t> s_queries;
-  static std::atomic<uint64_t> s_outgoingtimeouts;
-  static std::atomic<uint64_t> s_outgoing4timeouts;
-  static std::atomic<uint64_t> s_outgoing6timeouts;
-  static std::atomic<uint64_t> s_throttledqueries;
-  static std::atomic<uint64_t> s_dontqueries;
-  static std::atomic<uint64_t> s_qnameminfallbacksuccess;
-  static std::atomic<uint64_t> s_authzonequeries;
-  static std::atomic<uint64_t> s_outqueries;
-  static std::atomic<uint64_t> s_tcpoutqueries;
-  static std::atomic<uint64_t> s_dotoutqueries;
-  static std::atomic<uint64_t> s_unreachables;
-  static std::atomic<uint64_t> s_ecsqueries;
-  static std::atomic<uint64_t> s_ecsresponses;
-  static std::map<uint8_t, std::atomic<uint64_t>> s_ecsResponsesBySubnetSize4;
-  static std::map<uint8_t, std::atomic<uint64_t>> s_ecsResponsesBySubnetSize6;
+  static pdns::stat_t s_queries;
+  static pdns::stat_t s_outgoingtimeouts;
+  static pdns::stat_t s_outgoing4timeouts;
+  static pdns::stat_t s_outgoing6timeouts;
+  static pdns::stat_t s_throttledqueries;
+  static pdns::stat_t s_dontqueries;
+  static pdns::stat_t s_qnameminfallbacksuccess;
+  static pdns::stat_t s_authzonequeries;
+  static pdns::stat_t s_outqueries;
+  static pdns::stat_t s_tcpoutqueries;
+  static pdns::stat_t s_dotoutqueries;
+  static pdns::stat_t s_unreachables;
+  static pdns::stat_t s_ecsqueries;
+  static pdns::stat_t s_ecsresponses;
+  static std::map<uint8_t, pdns::stat_t> s_ecsResponsesBySubnetSize4;
+  static std::map<uint8_t, pdns::stat_t> s_ecsResponsesBySubnetSize6;
 
   static string s_serverID;
   static unsigned int s_minimumTTL;
@@ -1023,9 +1024,9 @@ MT_t* getMT();
 
 struct RecursorStats
 {
-  std::atomic<uint64_t> servFails;
-  std::atomic<uint64_t> nxDomains;
-  std::atomic<uint64_t> noErrors;
+  pdns::stat_t servFails;
+  pdns::stat_t nxDomains;
+  pdns::stat_t noErrors;
   pdns::AtomicHistogram answers;
   pdns::AtomicHistogram auth4Answers;
   pdns::AtomicHistogram auth6Answers;
@@ -1035,48 +1036,48 @@ struct RecursorStats
   pdns::AtomicHistogram cumulativeAuth6Answers;
   std::atomic<double> avgLatencyUsec;
   std::atomic<double> avgLatencyOursUsec;
-  std::atomic<uint64_t> qcounter;     // not increased for unauth packets
-  std::atomic<uint64_t> ipv6qcounter;
-  std::atomic<uint64_t> tcpqcounter;
-  std::atomic<uint64_t> unauthorizedUDP;  // when this is increased, qcounter isn't
-  std::atomic<uint64_t> unauthorizedTCP;  // when this is increased, qcounter isn't
-  std::atomic<uint64_t> policyDrops;
-  std::atomic<uint64_t> tcpClientOverflow;
-  std::atomic<uint64_t> clientParseError;
-  std::atomic<uint64_t> serverParseError;
-  std::atomic<uint64_t> tooOldDrops;
-  std::atomic<uint64_t> truncatedDrops;
-  std::atomic<uint64_t> queryPipeFullDrops;
-  std::atomic<uint64_t> unexpectedCount;
-  std::atomic<uint64_t> caseMismatchCount;
-  std::atomic<uint64_t> spoofCount;
-  std::atomic<uint64_t> resourceLimits;
-  std::atomic<uint64_t> overCapacityDrops;
-  std::atomic<uint64_t> ipv6queries;
-  std::atomic<uint64_t> chainResends;
-  std::atomic<uint64_t> nsSetInvalidations;
-  std::atomic<uint64_t> ednsPingMatches;
-  std::atomic<uint64_t> ednsPingMismatches;
-  std::atomic<uint64_t> noPingOutQueries, noEdnsOutQueries;
-  std::atomic<uint64_t> packetCacheHits;
-  std::atomic<uint64_t> noPacketError;
-  std::atomic<uint64_t> ignoredCount;
-  std::atomic<uint64_t> emptyQueriesCount;
+  pdns::stat_t qcounter;     // not increased for unauth packets
+  pdns::stat_t ipv6qcounter;
+  pdns::stat_t tcpqcounter;
+  pdns::stat_t unauthorizedUDP;  // when this is increased, qcounter isn't
+  pdns::stat_t unauthorizedTCP;  // when this is increased, qcounter isn't
+  pdns::stat_t policyDrops;
+  pdns::stat_t tcpClientOverflow;
+  pdns::stat_t clientParseError;
+  pdns::stat_t serverParseError;
+  pdns::stat_t tooOldDrops;
+  pdns::stat_t truncatedDrops;
+  pdns::stat_t queryPipeFullDrops;
+  pdns::stat_t unexpectedCount;
+  pdns::stat_t caseMismatchCount;
+  pdns::stat_t spoofCount;
+  pdns::stat_t resourceLimits;
+  pdns::stat_t overCapacityDrops;
+  pdns::stat_t ipv6queries;
+  pdns::stat_t chainResends;
+  pdns::stat_t nsSetInvalidations;
+  pdns::stat_t ednsPingMatches;
+  pdns::stat_t ednsPingMismatches;
+  pdns::stat_t noPingOutQueries, noEdnsOutQueries;
+  pdns::stat_t packetCacheHits;
+  pdns::stat_t noPacketError;
+  pdns::stat_t ignoredCount;
+  pdns::stat_t emptyQueriesCount;
   time_t startupTime;
-  std::atomic<uint64_t> dnssecQueries;
-  std::atomic<uint64_t> dnssecAuthenticDataQueries;
-  std::atomic<uint64_t> dnssecCheckDisabledQueries;
-  std::atomic<uint64_t> variableResponses;
-  std::atomic<uint64_t> maxMThreadStackUsage;
-  std::atomic<uint64_t> dnssecValidations; // should be the sum of all dnssecResult* stats
-  std::map<vState, std::atomic<uint64_t> > dnssecResults;
-  std::map<vState, std::atomic<uint64_t> > xdnssecResults;
-  std::map<DNSFilterEngine::PolicyKind, std::atomic<uint64_t> > policyResults;
-  LockGuarded<std::unordered_map<std::string, std::atomic<uint64_t>>> policyHits;
-  std::atomic<uint64_t> rebalancedQueries{0};
-  std::atomic<uint64_t> proxyProtocolInvalidCount{0};
-  std::atomic<uint64_t> nodLookupsDroppedOversize{0};
-  std::atomic<uint64_t> dns64prefixanswers{0};
+  pdns::stat_t dnssecQueries;
+  pdns::stat_t dnssecAuthenticDataQueries;
+  pdns::stat_t dnssecCheckDisabledQueries;
+  pdns::stat_t variableResponses;
+  pdns::stat_t maxMThreadStackUsage;
+  pdns::stat_t dnssecValidations; // should be the sum of all dnssecResult* stats
+  std::map<vState, pdns::stat_t > dnssecResults;
+  std::map<vState, pdns::stat_t > xdnssecResults;
+  std::map<DNSFilterEngine::PolicyKind, pdns::stat_t > policyResults;
+  LockGuarded<std::unordered_map<std::string, pdns::stat_t>> policyHits;
+  pdns::stat_t rebalancedQueries{0};
+  pdns::stat_t proxyProtocolInvalidCount{0};
+  pdns::stat_t nodLookupsDroppedOversize{0};
+  pdns::stat_t dns64prefixanswers{0};
 
   RecursorStats() :
     answers("answers", { 1000, 10000, 100000, 1000000 }),