Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/thread_cache.cc

 // Copyright (c) 2008, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
 // Author: Ken Ashcraft <opensource@google.com>
 
 #include <config.h>
 #include "thread_cache.h"
+#include <errno.h>
 #include <string.h>                     // for memcpy
 #include <algorithm>                    // for max, min
 #include "base/commandlineflags.h"      // for SpinLockHolder
 #include "base/spinlock.h"              // for SpinLockHolder
 #include "central_freelist.h"           // for CentralFreeListPadded
 #include "maybe_threads.h"
 
 using std::min;
 using std::max;
 
 DEFINE_int64(tcmalloc_max_total_thread_cache_bytes,
              EnvToInt64("TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES",
                         kDefaultOverallThreadCacheSize),
              "Bound on the total amount of bytes allocated to "
-             "thread caches.  This bound is not strict, so it is possible "
-             "for the cache to go over this bound in certain circumstances. ");
+             "thread caches. This bound is not strict, so it is possible "
+             "for the cache to go over this bound in certain circumstances. "
+             "Maximum value of this flag is capped to 1 GB.");
 
 namespace tcmalloc {
 
 static bool phinited = false;
 
 volatile size_t ThreadCache::per_thread_cache_size_ = kMaxThreadCacheSize;
 size_t ThreadCache::overall_thread_cache_size_ = kDefaultOverallThreadCacheSize;
 ssize_t ThreadCache::unclaimed_cache_space_ = kDefaultOverallThreadCacheSize;
 PageHeapAllocator<ThreadCache> threadcache_allocator;
 ThreadCache* ThreadCache::thread_heaps_ = NULL;
 int ThreadCache::thread_heap_count_ = 0;
 ThreadCache* ThreadCache::next_memory_steal_ = NULL;
 #ifdef HAVE_TLS
 __thread ThreadCache* ThreadCache::threadlocal_heap_
 # ifdef HAVE___ATTRIBUTE__
    __attribute__ ((tls_model ("initial-exec")))
 # endif
    ;
 #endif
 bool ThreadCache::tsd_inited_ = false;
 pthread_key_t ThreadCache::heap_key_;
 
 #if defined(HAVE_TLS)
 bool kernel_supports_tls = false;      // be conservative
-# if !HAVE_DECL_UNAME   // if too old for uname, probably too old for TLS
+# if defined(_WIN32)    // windows has supported TLS since winnt, I think.
+    void CheckIfKernelSupportsTLS() {
+      kernel_supports_tls = true;
+    }
+# elif !HAVE_DECL_UNAME    // if too old for uname, probably too old for TLS
     void CheckIfKernelSupportsTLS() {
       kernel_supports_tls = false;
     }
 # else
 #   include <sys/utsname.h>    // DECL_UNAME checked for <sys/utsname.h> too
     void CheckIfKernelSupportsTLS() {
       struct utsname buf;
-      if (uname(&buf) != 0) {   // should be impossible
-        MESSAGE("uname failed assuming no TLS support (errno=%d)\n", errno);
+      if (uname(&buf) < 0) {   // should be impossible
+        Log(kLog, __FILE__, __LINE__,
+            "uname failed assuming no TLS support (errno)", errno);
         kernel_supports_tls = false;
       } else if (strcasecmp(buf.sysname, "linux") == 0) {
         // The linux case: the first kernel to support TLS was 2.6.0
         if (buf.release[0] < '2' && buf.release[1] == '.')    // 0.x or 1.x
           kernel_supports_tls = false;
         else if (buf.release[0] == '2' && buf.release[1] == '.' &&
                  buf.release[2] >= '0' && buf.release[2] < '6' &&
                  buf.release[3] == '.')                       // 2.0 - 2.5
           kernel_supports_tls = false;
         else
           kernel_supports_tls = true;
+      } else if (strcasecmp(buf.sysname, "CYGWIN_NT-6.1-WOW64") == 0) {
+        // In my testing, this version of cygwin, at least, would hang
+        // when using TLS.
+        kernel_supports_tls = false;
       } else {        // some other kernel, we'll be optimisitic
         kernel_supports_tls = true;
       }
       // TODO(csilvers): VLOG(1) the tls status once we support RAW_VLOG
     }
 #  endif  // HAVE_DECL_UNAME
 #endif    // HAVE_TLS
 
 void ThreadCache::Init(pthread_t tid) {
   size_ = 0;
@@ skipping 146 matching lines @@
       const int batch_size = Static::sizemap()->num_objects_to_move(cl);
       if (list->max_length() > batch_size) {
         list->set_max_length(
             max<int>(list->max_length() - batch_size, batch_size));
       }
     }
     list->clear_lowwatermark();
   }
 
   IncreaseCacheLimit();
-
-//   int64 finish = CycleClock::Now();
-//   CycleTimer ct;
-//   MESSAGE("GC: %.0f ns\n", ct.CyclesToUsec(finish-start)*1000.0);
 }
 
 void ThreadCache::IncreaseCacheLimit() {
   SpinLockHolder h(Static::pageheap_lock());
   IncreaseCacheLimitLocked();
 }
 
 void ThreadCache::IncreaseCacheLimitLocked() {
   if (unclaimed_cache_space_ > 0) {
     // Possibly make unclaimed_cache_space_ negative.
@@ skipping 39 matching lines @@
     Static::InitStaticVars();
     threadcache_allocator.Init();
     phinited = 1;
   }
 }
 
 void ThreadCache::InitTSD() {
   ASSERT(!tsd_inited_);
   perftools_pthread_key_create(&heap_key_, DestroyThreadCache);
   tsd_inited_ = true;
+
+#ifdef PTHREADS_CRASHES_IF_RUN_TOO_EARLY
+  // We may have used a fake pthread_t for the main thread.  Fix it.
+  pthread_t zero;
+  memset(&zero, 0, sizeof(zero));
+  SpinLockHolder h(Static::pageheap_lock());
+  for (ThreadCache* h = thread_heaps_; h != NULL; h = h->next_) {
+    if (h->tid_ == zero) {
+      h->tid_ = pthread_self();
+    }
+  }
+#endif
 }
 
 ThreadCache* ThreadCache::CreateCacheIfNecessary() {
   // Initialize per-thread data if necessary
   ThreadCache* heap = NULL;
   {
     SpinLockHolder h(Static::pageheap_lock());
-    // On very old libc's, this call may crash if it happens too
-    // early.  No libc using NPTL should be affected.  If there
-    // is a crash here, we could use code (on linux, at least)
-    // to detect NPTL vs LinuxThreads:
-    //   http://www.redhat.com/archives/phil-list/2003-April/msg00038.html
-    // If we detect not-NPTL, we could execute the old code from
-    //   http://google-perftools.googlecode.com/svn/tags/google-perftools-1.7/src/thread_cache.cc
-    // that avoids calling pthread_self too early.  The problem with
-    // that code is it caused a race condition when tcmalloc is linked
-    // in statically and other libraries spawn threads before main.
+    // On some old glibc's, and on freebsd's libc (as of freebsd 8.1),
+    // calling pthread routines (even pthread_self) too early could
+    // cause a segfault.  Since we can call pthreads quite early, we
+    // have to protect against that in such situations by making a
+    // 'fake' pthread.  This is not ideal since it doesn't work well
+    // when linking tcmalloc statically with apps that create threads
+    // before main, so we only do it if we have to.
+#ifdef PTHREADS_CRASHES_IF_RUN_TOO_EARLY
+    pthread_t me;
+    if (!tsd_inited_) {
+      memset(&me, 0, sizeof(me));
+    } else {
+      me = pthread_self();
+    }
+#else
     const pthread_t me = pthread_self();
+#endif
 
     // This may be a recursive malloc call from pthread_setspecific()
     // In that case, the heap for this thread has already been created
     // and added to the linked list.  So we search for that first.
     for (ThreadCache* h = thread_heaps_; h != NULL; h = h->next_) {
       if (h->tid_ == me) {
         heap = h;
         break;
       }
     }
@@ skipping 102 matching lines @@
   for (ThreadCache* h = thread_heaps_; h != NULL; h = h->next_) {
     // Increasing the total cache size should not circumvent the
     // slow-start growth of max_size_.
     if (ratio < 1.0) {
         h->max_size_ = static_cast<size_t>(h->max_size_ * ratio);
     }
     claimed += h->max_size_;
   }
   unclaimed_cache_space_ = overall_thread_cache_size_ - claimed;
   per_thread_cache_size_ = space;
-  //  TCMalloc_MESSAGE(__FILE__, __LINE__, "Threads %d => cache size %8d\n", n, int(space));
-}
-
-void ThreadCache::Print(TCMalloc_Printer* out) const {
-  for (int cl = 0; cl < kNumClasses; ++cl) {
-    out->printf("      %5" PRIuS " : %4" PRIuS " len; %4d lo; %4"PRIuS
-                " max; %4"PRIuS" overages;\n",
-                Static::sizemap()->ByteSizeForClass(cl),
-                list_[cl].length(),
-                list_[cl].lowwatermark(),
-                list_[cl].max_length(),
-                list_[cl].length_overages());
-  }
-}
-
-void ThreadCache::PrintThreads(TCMalloc_Printer* out) {
-  size_t actual_limit = 0;
-  for (ThreadCache* h = thread_heaps_; h != NULL; h = h->next_) {
-    h->Print(out);
-    actual_limit += h->max_size_;
-  }
-  out->printf("ThreadCache overall: %"PRIuS ", unclaimed: %"PRIuS
-              ", actual: %"PRIuS"\n",
-              overall_thread_cache_size_, unclaimed_cache_space_, actual_limit);
 }
 
 void ThreadCache::GetThreadStats(uint64_t* total_bytes, uint64_t* class_count) {
   for (ThreadCache* h = thread_heaps_; h != NULL; h = h->next_) {
     *total_bytes += h->Size();
     if (class_count) {
       for (int cl = 0; cl < kNumClasses; ++cl) {
         class_count[cl] += h->freelist_length(cl);
       }
     }
   }
 }
 
 void ThreadCache::set_overall_thread_cache_size(size_t new_size) {
   // Clip the value to a reasonable range
   if (new_size < kMinThreadCacheSize) new_size = kMinThreadCacheSize;
   if (new_size > (1<<30)) new_size = (1<<30);     // Limit to 1GB
   overall_thread_cache_size_ = new_size;
 
   RecomputePerThreadCacheSize();
 }
 
 }  // namespace tcmalloc