Author: Alex Rousskov <rousskov@measurement-factory.com>

Bug 2789: Optimize unlimited memory pools, and correctly handle limits > 2GB.

diff --git a/include/MemPool.h b/include/MemPool.h
index e652803f73577cc14c011bf76f3fd6b69b3f4d68..0702e49e1219832322ea0148f9e2be1afcd31406 100644 (file)
--- a/include/MemPool.h
+++ b/include/MemPool.h
@@ -45,8 +45,6 @@
 /// \ingroup MemPoolsAPI
 #define MB ((size_t)1024*1024)
 /// \ingroup MemPoolsAPI
-#define mem_unlimited_size 2 * 1024 * MB
-/// \ingroup MemPoolsAPI
 #define toMB(size) ( ((double) size) / MB )
 /// \ingroup MemPoolsAPI
 #define toKB(size) ( (size + 1024 - 1) / 1024 )
@@ -137,9 +135,8 @@ public:
      * totally free chunks are immediately considered for release. Otherwise
      * only chunks that have not been referenced for a long time are checked.
      */
-    void setIdleLimit(size_t new_idle_limit);
-
-    size_t idleLimit() const;
+    void setIdleLimit(ssize_t new_idle_limit);
+    ssize_t idleLimit() const;
 
     /**
      \par
@@ -171,7 +168,7 @@ public:
 
     void setDefaultPoolChunking(bool const &);
     MemImplementingAllocator *pools;
-    int mem_idle_limit;
+    ssize_t mem_idle_limit;
     int poolCount;
     bool defaultIsChunked;
 private:
@@ -396,7 +393,7 @@ struct _MemPoolGlobalStats {
     int tot_items_idle;
 
     int tot_overhead;
-    int mem_idle_limit;
+    ssize_t mem_idle_limit;
 };
 
 /// \ingroup MemPoolsAPI

diff --git a/lib/MemPool.cc b/lib/MemPool.cc
index 415af1029fa08b4666d8914956f44a3e3174d536..271e6db07ecf3cc44da6fd742e4c91c7a1aad02e 100644 (file)
--- a/lib/MemPool.cc
+++ b/lib/MemPool.cc
@@ -103,12 +103,12 @@ memPoolIterateNext(MemPoolIterator * iter)
 }
 
 void
-MemPools::setIdleLimit(size_t new_idle_limit)
+MemPools::setIdleLimit(ssize_t new_idle_limit)
 {
     mem_idle_limit = new_idle_limit;
 }
 
-size_t
+ssize_t
 MemPools::idleLimit() const
 {
     return mem_idle_limit;
@@ -263,14 +263,16 @@ MemImplementingAllocator::free(void *obj)
 void
 MemPools::clean(time_t maxage)
 {
-    MemImplementingAllocator *pool;
-    MemPoolIterator *iter;
+    flushMeters();
+    if (mem_idle_limit < 0) // no limit to enforce
+        return;
 
     int shift = 1;
-    flushMeters();
     if (TheMeter.idle.level > mem_idle_limit)
         maxage = shift = 0;
 
+    MemImplementingAllocator *pool;
+    MemPoolIterator *iter;
     iter = memPoolIterate();
     while ((pool = memPoolIterateNext(iter)))
         if (pool->idleTrigger(shift))

diff --git a/src/cf.data.pre b/src/cf.data.pre
index d06b499327488252f1677f7f88e55c71f3ff2b3e..d975a84df5e1b75b92e2c6e1b7b32fafc4a4751a 100644 (file)
--- a/src/cf.data.pre
+++ b/src/cf.data.pre
@@ -6337,7 +6337,7 @@ DOC_START
        memory_pools_limit to a reasonably high value even if your
        configuration will use less memory.
 
-       If set to zero, Squid will keep all memory it can. That is, there
+       If set to none, Squid will keep all memory it can. That is, there
        will be no limit on the total amount of memory used for safe-keeping.
 
        To disable memory allocation optimization, do not set

diff --git a/src/mem.cc b/src/mem.cc
index 56d3abcac9f66d6f0fbcbe05fdd523525fb2e5a0..b09e77fa1efe6a79628665c658fe18182d088a36 100644 (file)
--- a/src/mem.cc
+++ b/src/mem.cc
@@ -353,8 +353,11 @@ memConfigure(void)
         new_pool_limit = 0;
     else if (Config.MemPools.limit > 0)
         new_pool_limit = Config.MemPools.limit;
-    else
-        new_pool_limit = mem_unlimited_size;
+    else {
+       if (Config.MemPools.limit == 0)
+           debugs(13, 1, "memory_pools_limit 0 has been chagned to memory_pools_limit none. Please update your config");
+        new_pool_limit = -1;
+    }
 
 #if 0
     /** \par
@@ -762,7 +765,8 @@ Mem::Report(std::ostream &stream)
     stream << "Current overhead: " << mp_total.tot_overhead << " bytes (" <<
     std::setprecision(3) << xpercent(mp_total.tot_overhead, mp_total.TheMeter->inuse.level) << "%)\n";
     /* limits */
-    stream << "Idle pool limit: " << std::setprecision(2) << toMB(mp_total.mem_idle_limit) << " MB\n";
+    if (mp_total.mem_idle_limit >= 0)
+        stream << "Idle pool limit: " << std::setprecision(2) << toMB(mp_total.mem_idle_limit) << " MB\n";
     /* limits */
     stream << "Total Pools created: " << mp_total.tot_pools_alloc << "\n";
     stream << "Pools ever used:     " << mp_total.tot_pools_alloc - not_used << " (shown above)\n";