Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/common.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 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>
 
 #include "config.h"
+#include "common.h"
 #include "system-alloc.h"
-#include "config.h"
-#include "common.h"
 
 namespace tcmalloc {
 
 // Note: the following only works for "n"s that fit in 32-bits, but
 // that is fine since we only use it for small sizes.
 static inline int LgFloor(size_t n) {
   int log = 0;
   for (int i = 4; i >= 0; --i) {
     int shift = (1 << i);
     size_t x = n >> shift;
     if (x != 0) {
       n = x;
       log += shift;
     }
   }
   ASSERT(n == 1);
   return log;
 }
 
+int AlignmentForSize(size_t size) {
+  int alignment = kAlignment;
+  if (size >= 2048) {
+    // Cap alignment at 256 for large sizes.
+    alignment = 256;
+  } else if (size >= 128) {
+    // Space wasted due to alignment is at most 1/8, i.e., 12.5%.
+    alignment = (1 << LgFloor(size)) / 8;
+  } else if (size >= 16) {
+    // We need an alignment of at least 16 bytes to satisfy
+    // requirements for some SSE types.
+    alignment = 16;
+  }
+  CHECK_CONDITION(size < 16 || alignment >= 16);
+  CHECK_CONDITION((alignment & (alignment - 1)) == 0);
+  return alignment;
+}
+
 int SizeMap::NumMoveSize(size_t size) {
   if (size == 0) return 0;
   // Use approx 64k transfers between thread and central caches.
   int num = static_cast<int>(64.0 * 1024.0 / size);
   if (num < 2) num = 2;
 
   // Avoid bringing too many objects into small object free lists.
   // If this value is too large:
   // - We waste memory with extra objects sitting in the thread caches.
   // - The central freelist holds its lock for too long while
@@ skipping 20 matching lines @@
 
   // Compute the size classes we want to use
   int sc = 1;   // Next size class to assign
   int alignment = kAlignment;
   CHECK_CONDITION(kAlignment <= 16);
   int last_lg = -1;
   for (size_t size = kAlignment; size <= kMaxSize; size += alignment) {
     int lg = LgFloor(size);
     if (lg > last_lg) {
       // Increase alignment every so often to reduce number of size classes.
-      if (size >= 2048) {
-        // Cap alignment at 256 for large sizes
-        alignment = 256;
-      } else if (size >= 128) {
-        // Space wasted due to alignment is at most 1/8, i.e., 12.5%.
-        alignment = size / 8;
-      } else if (size >= 16) {
-        // We need an alignment of at least 16 bytes to satisfy
-        // requirements for some SSE types.
-        alignment = 16;
-      }
-      CHECK_CONDITION(size < 16 || alignment >= 16);
-      CHECK_CONDITION((alignment & (alignment - 1)) == 0);
+      alignment = AlignmentForSize(size);
       last_lg = lg;
     }
     CHECK_CONDITION((size % alignment) == 0);
 
     // Allocate enough pages so leftover is less than 1/8 of total.
     // This bounds wasted space to at most 12.5%.
     size_t psize = kPageSize;
     while ((psize % size) > (psize >> 3)) {
       psize += kPageSize;
     }
@@ skipping 84 matching lines @@
   return result;
 }
 
 uint64_t metadata_system_bytes() { return metadata_system_bytes_; }
 
 void increment_metadata_system_bytes(size_t bytes) {
   metadata_system_bytes_ += bytes;
 }
 
 }  // namespace tcmalloc