[NOT TO COMMIT!] r109: Diff of the current tcmalloc from the original google-perftools r109.

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 85 matching lines @@
 
 // Structure for discovering alignment
 union MemoryAligner {
   void*  p;
   double d;
   size_t s;
 } CACHELINE_ALIGNED;
 
 static SpinLock spinlock(SpinLock::LINKER_INITIALIZED);
 
-#if defined(HAVE_MMAP) || defined(MADV_DONTNEED)
-// Page size is initialized on demand (only needed for mmap-based allocators)
+#ifdef HAVE_GETPAGESIZE
 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."
@@ skipping 35 matching lines @@
   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<ptrdiff_t>(size + alignment) < 0) return NULL;
+  if (static_cast<std::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 137 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
   if (FLAGS_malloc_devmem_start) {
     // It's not safe to use MADV_DONTNEED if we've been mapping
     // /dev/mem for heap memory
     return;
   }
   if (pagesize == 0) pagesize = getpagesize();
   const size_t pagemask = pagesize - 1;
 
@@ skipping 15 matching lines @@
     // 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 &&
            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.
+}