[NOT TO COMMIT!] Replace third_party/tcmalloc/chromium with tcmalloc r136 (the latest).

third_party/tcmalloc/chromium/src/system-alloc.cc

 // Copyright (c) 2005, 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 43 matching lines @@
 #include "base/spinlock.h"              // for SpinLockHolder, SpinLock, etc
 #include "common.h"
 #include "internal_logging.h"
 
 // On systems (like freebsd) that don't define MAP_ANONYMOUS, use the old
 // form of the name instead.
 #ifndef MAP_ANONYMOUS
 # define MAP_ANONYMOUS MAP_ANON
 #endif
 
+// MADV_FREE is specifically designed for use by malloc(), but only
+// FreeBSD supports it; in linux we fall back to the somewhat inferior
+// MADV_DONTNEED.
+#if !defined(MADV_FREE) && defined(MADV_DONTNEED)
+# define MADV_FREE  MADV_DONTNEED
+#endif
+
 // Solaris has a bug where it doesn't declare madvise() for C++.
 //    http://www.opensolaris.org/jive/thread.jspa?threadID=21035&tstart=0
 #if defined(__sun) && defined(__SVR4)
 # include <sys/types.h>    // for caddr_t
   extern "C" { extern int madvise(caddr_t, size_t, int); }
 #endif
 
 // Set kDebugMode mode so that we can have use C++ conditionals
 // instead of preprocessor conditionals.
 #ifdef NDEBUG
 static const bool kDebugMode = false;
 #else
 static const bool kDebugMode = true;
 #endif
 
+// TODO(sanjay): Move the code below into the tcmalloc namespace
+using tcmalloc::kLog;
+using tcmalloc::Log;
+
 // Anonymous namespace to avoid name conflicts on "CheckAddressBits".
 namespace {
 
 // Check that no bit is set at position ADDRESS_BITS or higher.
 template <int ADDRESS_BITS> bool CheckAddressBits(uintptr_t ptr) {
   return (ptr >> ADDRESS_BITS) == 0;
 }
 
 // Specialize for the bit width of a pointer to avoid undefined shift.
 template <> bool CheckAddressBits<8 * sizeof(void*)>(uintptr_t ptr) {
   return true;
 }
 
 }  // Anonymous namespace to avoid name conflicts on "CheckAddressBits".
 
 COMPILE_ASSERT(kAddressBits <= 8 * sizeof(void*),
                address_bits_larger_than_pointer_size);
 
 // Structure for discovering alignment
 union MemoryAligner {
   void*  p;
   double d;
   size_t s;
 } CACHELINE_ALIGNED;
 
 static SpinLock spinlock(SpinLock::LINKER_INITIALIZED);
 
-#ifdef HAVE_GETPAGESIZE
+#if defined(HAVE_MMAP) || defined(MADV_FREE)
+// Page size is initialized on demand (only needed for mmap-based allocators)
 static size_t pagesize = 0;
 #endif
 
 // The current system allocator
 SysAllocator* sys_alloc = NULL;
 
 // Configuration parameters.
 DEFINE_int32(malloc_devmem_start,
              EnvToInt("TCMALLOC_DEVMEM_START", 0),
              "Physical memory starting location in MB for /dev/mem allocation."
              "  Setting this to 0 disables /dev/mem allocation");
 DEFINE_int32(malloc_devmem_limit,
              EnvToInt("TCMALLOC_DEVMEM_LIMIT", 0),
              "Physical memory limit location in MB for /dev/mem allocation."
              "  Setting this to 0 means no limit.");
 DEFINE_bool(malloc_skip_sbrk,
             EnvToBool("TCMALLOC_SKIP_SBRK", false),
             "Whether sbrk can be used to obtain memory.");
 DEFINE_bool(malloc_skip_mmap,
             EnvToBool("TCMALLOC_SKIP_MMAP", false),
             "Whether mmap can be used to obtain memory.");
 
 // static allocators
 class SbrkSysAllocator : public SysAllocator {
 public:
   SbrkSysAllocator() : SysAllocator() {
   }
   void* Alloc(size_t size, size_t *actual_size, size_t alignment);
-  void FlagsInitialized() {}
 };
 static char sbrk_space[sizeof(SbrkSysAllocator)];
 
 class MmapSysAllocator : public SysAllocator {
 public:
   MmapSysAllocator() : SysAllocator() {
   }
   void* Alloc(size_t size, size_t *actual_size, size_t alignment);
-  void FlagsInitialized() {}
 };
 static char mmap_space[sizeof(MmapSysAllocator)];
 
 class DevMemSysAllocator : public SysAllocator {
 public:
   DevMemSysAllocator() : SysAllocator() {
   }
   void* Alloc(size_t size, size_t *actual_size, size_t alignment);
-  void FlagsInitialized() {}
 };
 
 class DefaultSysAllocator : public SysAllocator {
  public:
   DefaultSysAllocator() : SysAllocator() {
     for (int i = 0; i < kMaxAllocators; i++) {
       failed_[i] = true;
       allocs_[i] = NULL;
       names_[i] = NULL;
     }
   }
   void SetChildAllocator(SysAllocator* alloc, unsigned int index,
                          const char* name) {
     if (index < kMaxAllocators && alloc != NULL) {
       allocs_[index] = alloc;
       failed_[index] = false;
       names_[index] = name;
     }
   }
   void* Alloc(size_t size, size_t *actual_size, size_t alignment);
-  void FlagsInitialized() {}
 
  private:
   static const int kMaxAllocators = 2;
   bool failed_[kMaxAllocators];
   SysAllocator* allocs_[kMaxAllocators];
   const char* names_[kMaxAllocators];
 };
 static char default_space[sizeof(DefaultSysAllocator)];
 static const char sbrk_name[] = "SbrkSysAllocator";
 static const char mmap_name[] = "MmapSysAllocator";
 
 
 void* SbrkSysAllocator::Alloc(size_t size, size_t *actual_size,
                               size_t alignment) {
 #ifndef HAVE_SBRK
+  failed_ = true;
   return NULL;
 #else
   // Check if we should use sbrk allocation.
   // FLAGS_malloc_skip_sbrk starts out as false (its uninitialized
   // state) and eventually gets initialized to the specified value.  Note
   // that this code runs for a while before the flags are initialized.
   // That means that even if this flag is set to true, some (initial)
   // memory will be allocated with sbrk before the flag takes effect.
   if (FLAGS_malloc_skip_sbrk) {
     return NULL;
   }
 
   // sbrk will release memory if passed a negative number, so we do
   // a strict check here
-  if (static_cast<std::ptrdiff_t>(size + alignment) < 0) return NULL;
+  if (static_cast<ptrdiff_t>(size + alignment) < 0) return NULL;
 
   // This doesn't overflow because TCMalloc_SystemAlloc has already
   // tested for overflow at the alignment boundary.
   size = ((size + alignment - 1) / alignment) * alignment;
 
   // "actual_size" indicates that the bytes from the returned pointer
   // p up to and including (p + actual_size - 1) have been allocated.
   if (actual_size) {
     *actual_size = size;
   }
@@ skipping 36 matching lines @@
   if ((ptr & (alignment-1)) != 0) {
     ptr += alignment - (ptr & (alignment-1));
   }
   return reinterpret_cast<void*>(ptr);
 #endif  // HAVE_SBRK
 }
 
 void* MmapSysAllocator::Alloc(size_t size, size_t *actual_size,
                               size_t alignment) {
 #ifndef HAVE_MMAP
+  failed_ = true;
   return NULL;
 #else
   // Check if we should use mmap allocation.
   // FLAGS_malloc_skip_mmap starts out as false (its uninitialized
   // state) and eventually gets initialized to the specified value.  Note
   // that this code runs for a while before the flags are initialized.
   // Chances are we never get here before the flags are initialized since
   // sbrk is used until the heap is exhausted (before mmap is used).
   if (FLAGS_malloc_skip_mmap) {
     return NULL;
@@ skipping 48 matching lines @@
   }
 
   ptr += adjust;
   return reinterpret_cast<void*>(ptr);
 #endif  // HAVE_MMAP
 }
 
 void* DevMemSysAllocator::Alloc(size_t size, size_t *actual_size,
                                 size_t alignment) {
 #ifndef HAVE_MMAP
+  failed_ = true;
   return NULL;
 #else
   static bool initialized = false;
   static off_t physmem_base;  // next physical memory address to allocate
   static off_t physmem_limit; // maximum physical address allowed
   static int physmem_fd;      // file descriptor for /dev/mem
 
   // Check if we should use /dev/mem allocation.  Note that it may take
   // a while to get this flag initialized, so meanwhile we fall back to
   // the next allocator.  (It looks like 7MB gets allocated before
@@ skipping 74 matching lines @@
 }
 
 void* DefaultSysAllocator::Alloc(size_t size, size_t *actual_size,
                                  size_t alignment) {
   for (int i = 0; i < kMaxAllocators; i++) {
     if (!failed_[i] && allocs_[i] != NULL) {
       void* result = allocs_[i]->Alloc(size, actual_size, alignment);
       if (result != NULL) {
         return result;
       }
-      TCMalloc_MESSAGE(__FILE__, __LINE__, "%s failed.\n", names_[i]);
       failed_[i] = true;
     }
   }
   // After both failed, reset "failed_" to false so that a single failed
   // allocation won't make the allocator never work again.
   for (int i = 0; i < kMaxAllocators; i++) {
     failed_[i] = false;
   }
   return NULL;
 }
@@ skipping 42 matching lines @@
       CheckAddressBits<kAddressBits>(
           reinterpret_cast<uintptr_t>(result) + *actual_size - 1);
     } else {
       CheckAddressBits<kAddressBits>(
           reinterpret_cast<uintptr_t>(result) + size - 1);
     }
   }
   return result;
 }
 
-size_t TCMalloc_SystemAddGuard(void* start, size_t size) {
-#ifdef HAVE_GETPAGESIZE
-  if (pagesize == 0)
-    pagesize = getpagesize();
-
-  if (size < pagesize || (reinterpret_cast<size_t>(start) % pagesize) != 0)
-    return 0;
-
-  if (!mprotect(start, pagesize, PROT_NONE))
-    return pagesize;
-#endif
-
-  return 0;
-}
-
 void TCMalloc_SystemRelease(void* start, size_t length) {
-#ifdef MADV_DONTNEED
+#ifdef MADV_FREE
   if (FLAGS_malloc_devmem_start) {
-    // It's not safe to use MADV_DONTNEED if we've been mapping
-    // /dev/mem for heap memory
+    // It's not safe to use MADV_FREE/MADV_DONTNEED if we've been
+    // mapping /dev/mem for heap memory.
     return;
   }
   if (pagesize == 0) pagesize = getpagesize();
   const size_t pagemask = pagesize - 1;
 
   size_t new_start = reinterpret_cast<size_t>(start);
   size_t end = new_start + length;
   size_t new_end = end;
 
   // Round up the starting address and round down the ending address
   // to be page aligned:
   new_start = (new_start + pagesize - 1) & ~pagemask;
   new_end = new_end & ~pagemask;
 
   ASSERT((new_start & pagemask) == 0);
   ASSERT((new_end & pagemask) == 0);
   ASSERT(new_start >= reinterpret_cast<size_t>(start));
   ASSERT(new_end <= end);
 
   if (new_end > new_start) {
     // Note -- ignoring most return codes, because if this fails it
     // doesn't matter...
     while (madvise(reinterpret_cast<char*>(new_start), new_end - new_start,
-                   MADV_DONTNEED) == -1 &&
+                   MADV_FREE) == -1 &&
            errno == EAGAIN) {
       // NOP
     }
   }
 #endif
 }
-
-void TCMalloc_SystemCommit(void* start, size_t length) {
-  // Nothing to do here.  TCMalloc_SystemRelease does not alter pages
-  // such that they need to be re-committed before they can be used by the
-  // application.
-}