document cache cleaning rate adjustment, plus switch to symbolic names for limits

diff --git a/pdns/packetcache.cc b/pdns/packetcache.cc
index 02f812a61b910ea6f061140054b9fea4c4d4596b..92b93d4d33ea769dae7bb51682e7459fb1fad521 100644 (file)
--- a/pdns/packetcache.cc
+++ b/pdns/packetcache.cc
@@ -439,6 +439,15 @@ void PacketCache::cleanup()
   DLOG(L<<"Done with cache clean, cacheSize: "<<*d_statnumentries<<", totErased"<<totErased<<endl);
 }
 
+/* the logic:
+   after d_nextclean operations, we clean. We also adjust the cleaninterval
+   a bit so we slowly move it to a value where we clean roughly every 30 seconds.
+
+   If d_nextclean has reached its maximum value, we also test if we were called
+   within 30 seconds, and if so, we skip cleaning. This means that under high load,
+   we will not clean more often than every 30 seconds anyhow.
+*/
+
 void PacketCache::cleanupIfNeeded()
 {
   if (d_ops++ == d_nextclean) {
@@ -446,7 +455,7 @@ void PacketCache::cleanupIfNeeded()
 
     DLOG(L<<"cleaninterval: "<<d_cleaninterval<<", timediff: "<<timediff<<endl);
 
-    if (d_cleaninterval == 300000 && timediff < 30) {
+    if (d_cleaninterval == s_maxcleaninterval && timediff < 30) {
       d_cleanskipped = true;
       d_nextclean += d_cleaninterval;
 
@@ -457,8 +466,8 @@ void PacketCache::cleanupIfNeeded()
 
     if(!d_cleanskipped) {
       d_cleaninterval=(int)(0.6*d_cleaninterval)+(0.4*d_cleaninterval*(30.0/timediff));
-      d_cleaninterval=std::max(d_cleaninterval, 1000);
-      d_cleaninterval=std::min(d_cleaninterval, 300000);
+      d_cleaninterval=std::max(d_cleaninterval, s_mincleaninterval);
+      d_cleaninterval=std::min(d_cleaninterval, s_maxcleaninterval);
 
       DLOG(L<<"new cleaninterval: "<<d_cleaninterval<<endl);
     } else {

diff --git a/pdns/packetcache.hh b/pdns/packetcache.hh
index 957ff8dbce91e316a965db3c03e089999a251dc5..a80e744861d888d7be340b1deafc3b9c51f817cb 100644 (file)
--- a/pdns/packetcache.hh
+++ b/pdns/packetcache.hh
@@ -149,7 +149,7 @@ private:
   AtomicCounter d_ops;
   time_t d_lastclean; // doesn't need to be atomic
   unsigned long d_nextclean;
-  int d_cleaninterval;
+  unsigned int d_cleaninterval;
   bool d_cleanskipped;
   AtomicCounter *d_statnumhit;
   AtomicCounter *d_statnummiss;
@@ -158,6 +158,8 @@ private:
   int d_ttl;
   int d_recursivettl;
   bool d_doRecursion;
+
+  static constexpr unsigned int s_mincleaninterval=1000, s_maxcleaninterval=300000;
 };