Update the tcmalloc chromium branch to r144 (gperftools 2.0), and merge chromium-specific changes.

third_party/tcmalloc/chromium/src/common.h

 // 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 13 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // 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: Sanjay Ghemawat <opensource@google.com>
 //
 // Common definitions for tcmalloc code.
+
 #ifndef TCMALLOC_COMMON_H_
 #define TCMALLOC_COMMON_H_
 
 #include "config.h"
 #include <stddef.h>                     // for size_t
 #ifdef HAVE_STDINT_H
 #include <stdint.h>                     // for uintptr_t, uint64_t
 #endif
 #include "free_list.h"  // for SIZE_CLASS macros
 #include "internal_logging.h"  // for ASSERT, etc
@@ skipping 12 matching lines @@
 // Deallocation may speed up by a factor as the page map gets 8x smaller, so
 // lookups in the page map result in fewer L2 cache misses, which translates to
 // speedup for application/platform combinations with high L2 cache pressure.
 // As the number of size classes increases with large pages, we increase
 // the thread cache allowance to avoid passing more free ranges to and from
 // central lists.  Also, larger pages are less likely to get freed.
 // These two factors cause a bounded increase in memory use.
 
 static const size_t kAlignment  = 8;
 
-// Constants dependant on tcmalloc configuration and archetecture.
+// Constants dependant on tcmalloc configuration and archetecture.  Chromium
+// tunes these constants.
 // We need to guarantee the smallest class size is big enough to hold the
 // pointers that form the free list.
 static const size_t kNumFreeListPointers = 
   (tcmalloc::kSupportsDoublyLinkedList ? 2 : 1);
 static const size_t kLinkSize = kNumFreeListPointers * sizeof(void *);
 static const size_t kMinClassSize = 
   (kLinkSize > kAlignment ? kLinkSize : kAlignment);
 static const size_t kSkippedClasses = (kAlignment < kMinClassSize ? 1 : 0);
 
 #if defined(TCMALLOC_LARGE_PAGES)
 static const size_t kPageShift  = 15;
-static const size_t kNumClasses = 95 - kSkippedClasses;
+static const size_t kNumClasses = 78 - kSkippedClasses;
+#else
+static const size_t kPageShift  = 13;
+static const size_t kNumClasses = 86 - kSkippedClasses;
+#endif
 static const size_t kMaxThreadCacheSize = 4 << 20;
-#else
-static const size_t kPageShift  = 12;
-static const size_t kNumClasses = 61 - kSkippedClasses;
-static const size_t kMaxThreadCacheSize = 2 << 20;
-#endif
 
 static const size_t kPageSize   = 1 << kPageShift;
-static const size_t kMaxSize    = 8u * kPageSize;
+// TODO(dmikurube): We Chromium may want to tune this kMaxSize.
+static const size_t kMaxSize    = 256 * 1024;
 // For all span-lengths < kMaxPages we keep an exact-size list.
 static const size_t kMaxPages = 1 << (20 - kPageShift);
 
 // Default bound on the total amount of thread caches.
 #ifdef TCMALLOC_SMALL_BUT_SLOW
 // Make the overall thread cache no bigger than that of a single thread
 // for the small memory footprint case.
 static const size_t kDefaultOverallThreadCacheSize = kMaxThreadCacheSize;
 #else
 static const size_t kDefaultOverallThreadCacheSize = 8u * kMaxThreadCacheSize;
@@ skipping 71 matching lines @@
   //   -------------------------------------------------------
   //   0          (0 + 7) / 8                     0
   //   1          (1 + 7) / 8                     1
   //   ...
   //   1024       (1024 + 7) / 8                  128
   //   1025       (1025 + 127 + (120<<7)) / 128   129
   //   ...
   //   32768      (32768 + 127 + (120<<7)) / 128  376
   static const int kMaxSmallSize = 1024;
   static const size_t kClassArraySize =
-      (((1 << kPageShift) * 8u + 127 + (120 << 7)) >> 7) + 1;
+      ((kMaxSize + 127 + (120 << 7)) >> 7) + 1;
   unsigned char class_array_[kClassArraySize];
 
   // Compute index of the class_array[] entry for a given size
   static inline int ClassIndex(int s) {
     ASSERT(0 <= s);
     ASSERT(s <= kMaxSize);
     const bool big = (s > kMaxSmallSize);
     const int add_amount = big ? (127 + (120<<7)) : 7;
     const int shift_amount = big ? 7 : 3;
     return (s + add_amount) >> shift_amount;
@@ skipping 35 matching lines @@
   }
 
   // Number of objects to move between a per-thread list and a central
   // list in one shot.  We want this to be not too small so we can
   // amortize the lock overhead for accessing the central list.  Making
   // it too big may temporarily cause unnecessary memory wastage in the
   // per-thread free list until the scavenger cleans up the list.
   inline int num_objects_to_move(size_t cl) {
     return num_objects_to_move_[cl];
   }
-
-  // Dump contents of the computed size map
-  void Dump(TCMalloc_Printer* out);
 };
 
 // Allocates "bytes" worth of memory and returns it.  Increments
 // metadata_system_bytes appropriately.  May return NULL if allocation
 // fails.  Requires pageheap_lock is held.
 void* MetaDataAlloc(size_t bytes);
 
 // Returns the total number of bytes allocated from the system.
 // Requires pageheap_lock is held.
 uint64_t metadata_system_bytes();
 
 // Adjust metadata_system_bytes to indicate that bytes are actually committed.
 // Requires pageheap_lock is held.
 void increment_metadata_system_bytes(size_t bytes);
 
 // size/depth are made the same size as a pointer so that some generic
 // code below can conveniently cast them back and forth to void*.
 static const int kMaxStackDepth = 31;
 struct StackTrace {
   uintptr_t size;          // Size of object
   uintptr_t depth;         // Number of PC values stored in array below
   void*     stack[kMaxStackDepth];
 };
 
 }  // namespace tcmalloc
 
 #endif  // TCMALLOC_COMMON_H_