SERVER-16773: better tcmalloc cleanup

Author: erh

src/mongo/db/concurrency/lock_state.cpp

@@ -728,7 +728,6 @@ namespace {
 
             // If infinite timeout was requested, just keep waiting
             if (timeoutMs == UINT_MAX) {
-                markThreadIdle();
                 continue;
             }
 
@@ -739,9 +738,6 @@ namespace {
             if (waitTimeMs == 0) {
                 break;
             }
-
-            // We have waited for a while and may likely be waiting even longer, mark us as idle
-            markThreadIdle();
         }
 
         // Cleanup the state, since this is an unused lock now

src/mongo/util/net/message_server_port.cpp

@@ -204,8 +204,7 @@ namespace {
             portWithHandler->psock->setLogLevel(logger::LogSeverity::Debug(1));
 
             Message m;
-            int64_t lastIdle = Listener::getElapsedTimeMillis();
-            int64_t avgMillisBetweenIdle = 0;
+            int64_t counter = 0;
             try {
                 LastError * le = new LastError();
                 lastError.reset( le ); // lastError now has ownership
@@ -231,20 +230,10 @@ namespace {
                     networkCounter.hit(portWithHandler->psock->getBytesIn(),
                                        portWithHandler->psock->getBytesOut());
 
-                    //  Connections that don't run at a high rate should mark an idle point
-                    //  between operations to allow cleanup of the thread-local malloc cache.
-                    //  Just before a receive is a reasonable point, as we may overlap with
-                    //  the processing of a command response. Avoid doing this in very active
-                    //  threads as they are actively using their memory and not experiencing
-                    //  resource starvation. Use the course clock with averaging for efficiency.
-
-                    const int64_t now = Listener::getElapsedTimeMillis();
-                    const int64_t millisSinceIdle = now - lastIdle;
-                    avgMillisBetweenIdle = (7 * avgMillisBetweenIdle + millisSinceIdle) / 8;
-                    if (avgMillisBetweenIdle >= 10) {
+                    // Occasionally we want to see if we're using too much memory.
+                    if ((counter++ & 0xf) == 0) {
                         markThreadIdle();
                     }
-                    lastIdle = now;
                 }
             }
             catch ( AssertionException& e ) {

src/mongo/util/tcmalloc_server_status_section.cpp

@@ -25,13 +25,16 @@
  *    then also delete it in the license file.
  */
 
+#define MONGO_LOG_DEFAULT_COMPONENT ::mongo::logger::LogComponent::kDefault
+
 #include "mongo/platform/basic.h"
 
 #include <third_party/gperftools-2.2/src/gperftools/malloc_extension.h>
 
 #include "mongo/base/init.h"
 #include "mongo/db/commands/server_status.h"
 #include "mongo/util/concurrency/synchronization.h"
+#include "mongo/util/log.h"
 #include "mongo/util/net/listen.h"
 
 namespace mongo {
@@ -43,16 +46,35 @@ namespace {
     // a long time.
     const int kManyClients = 40;
 
+    boost::mutex tcmallocCleanupLock;
+
     /**
      *  Callback to allow TCMalloc to release freed memory to the central list at
      *  favorable times. Ideally would do some milder cleanup or scavenge...
      */
     void threadStateChange() {
-        if (Listener::globalTicketHolder.used() > kManyClients) {
-            //  Mark thread busy while we're idle, so that overhead is incurred now.
-            MallocExtension::instance()->MarkThreadIdle();
-            MallocExtension::instance()->MarkThreadBusy();
+        if (Listener::globalTicketHolder.used() <= kManyClients) {
+            return;
         }
+
+        size_t threadCacheSizeBytes = MallocExtension::instance()->GetThreadCacheSize();
+
+        static const size_t kMaxThreadCacheSizeBytes = 0x10000;
+        if (threadCacheSizeBytes < kMaxThreadCacheSizeBytes) {
+            // This number was chosen a bit magically.
+            // At 1000 threads and the current (64mb) thread local cache size, we're "full".
+            // So we may want this number to scale with the number of current clients.
+            return;
+        }
+
+        LOG(1) << "thread over memory limit, cleaning up, current: "
+               << (threadCacheSizeBytes/1024) << "k";
+
+        // We synchronize as the tcmalloc central list uses a spinlock, and we can cause a really
+        // terrible runaway if we're not careful.
+        boost::mutex::scoped_lock lk(tcmallocCleanupLock);
+        MallocExtension::instance()->MarkThreadIdle();
+        MallocExtension::instance()->MarkThreadBusy();
     }
 
     // Register threadStateChange callback

src/third_party/gperftools-2.2/src/gperftools/malloc_extension.h

@@ -240,6 +240,10 @@ class PERFTOOLS_DLL_DECL MallocExtension {
   // Most malloc implementations ignore this routine.
   virtual void MarkThreadBusy();
 
+  // Gets the size of this thread's cache in bytes.
+  // MONGODB ADDITION
+  virtual size_t GetThreadCacheSize();
+
   // Gets the system allocator used by the malloc extension instance. Returns
   // NULL for malloc implementations that do not support pluggable system
   // allocators.

src/third_party/gperftools-2.2/src/malloc_extension.cc

@@ -151,6 +151,10 @@ void MallocExtension::MarkThreadBusy() {
   // Default implementation does nothing
 }
 
+size_t MallocExtension::GetThreadCacheSize() {
+  return 0;
+}
+
 SysAllocator* MallocExtension::GetSystemAllocator() {
   return NULL;
 }

src/third_party/gperftools-2.2/src/tcmalloc.cc

@@ -731,6 +731,13 @@ class TCMallocImplementation : public MallocExtension {
 
   virtual void MarkThreadBusy();  // Implemented below
 
+  virtual size_t GetThreadCacheSize() {
+    ThreadCache* tc = ThreadCache::GetCacheIfPresent();
+    if (!tc)
+      return 0;
+    return tc->Size();
+  }
+
   virtual SysAllocator* GetSystemAllocator() {
     SpinLockHolder h(Static::pageheap_lock());
     return sys_alloc;