Merge tcmalloc r111 (perftools v. 1.8) with the chromium/ branch.

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 45 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.
 
 #if defined(TCMALLOC_LARGE_PAGES)
 static const size_t kPageShift  = 15;
-static const size_t kNumClasses = 95;
+static const size_t kNumClasses = 78;
+#else
+static const size_t kPageShift  = 13;

[jar (doing other things), 2011/07/31 08:19:39]

This is the change to 8K pages from 4K.  The recent paper suggests this works
well for servers, but we really need to tune this for Chrome (or at least watch
that we don't see a regression when we land this).

+static const size_t kNumClasses = 86;
+#endif
 static const size_t kMaxThreadCacheSize = 4 << 20;

[jar (doing other things), 2011/07/31 08:19:39]

This looks like another change (for us, since we don't use LARGE_PAGES).  I
don't recall seeing a justification for this tuning change.

-#else
-static const size_t kPageShift  = 12;
-static const size_t kNumClasses = 61;
-static const size_t kMaxThreadCacheSize = 2 << 20;
-#endif
 
 static const size_t kPageSize   = 1 << kPageShift;
-static const size_t kMaxSize    = 8u * kPageSize;
+static const size_t kMaxSize    = 256 * 1024;

[jar (doing other things), 2011/07/31 08:19:39]

This is a big tuning change, upping the cutoff point to 256K from 32K.
Although we allocate IO buffers of 32K size, I don't think we do much larger
allocating.  Also, the 32K allocations will now be carved, and might not be
coalesced to spans and returned to the OS... which would notably raise our
committed memory footprint.

This tuning change is especially unclear for us on Chrome (unless I'm
mis-remembering the algorithms and mis-guessing the impact)

 static const size_t kAlignment  = 8;
 // 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
@@ skipping 72 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 65 matching lines @@
 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_