From 98e78fa1b132a59f8d9a9f8c1c9f92b4446713fa Mon Sep 17 00:00:00 2001 From: Amos Jeffries Date: Sun, 30 May 2010 07:08:03 -0600 Subject: [PATCH] Author: Alex Rousskov Bug 2789: Optimize unlimited memory pools, and correctly handle limits > 2GB. --- include/MemPool.h | 11 ++++------- lib/MemPool.cc | 12 +++++++----- src/cf.data.pre | 2 +- src/mem.cc | 10 +++++++--- 4 files changed, 19 insertions(+), 16 deletions(-) diff --git a/include/MemPool.h b/include/MemPool.h index e652803f73..0702e49e12 100644 --- 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 415af1029f..271e6db07e 100644 --- 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 d06b499327..d975a84df5 100644 --- 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 56d3abcac9..b09e77fa1e 100644 --- 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"; -- 2.47.3