Update the tcmalloc vendor branch to r144 (gperftools 2.0).

third_party/tcmalloc/vendor/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 81 matching lines @@
   // This value strikes a balance between the constraints above.
   if (num > 32) num = 32;
 
   return num;
 }
 
 // Initialize the mapping arrays
 void SizeMap::Init() {
   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
   if (ClassIndex(0) < 0) {
-    CRASH("Invalid class index %d for size 0\n", ClassIndex(0));
+    Log(kCrash, __FILE__, __LINE__,
+        "Invalid class index for size 0", ClassIndex(0));
   }
   if (ClassIndex(kMaxSize) >= sizeof(class_array_)) {
-    CRASH("Invalid class index %d for kMaxSize\n", ClassIndex(kMaxSize));
+    Log(kCrash, __FILE__, __LINE__,
+        "Invalid class index for kMaxSize", ClassIndex(kMaxSize));
   }
 
   // Compute the size classes we want to use
   int sc = 1;   // Next size class to assign
   int alignment = kAlignment;
   CHECK_CONDITION(kAlignment <= 16);
   for (size_t size = kAlignment; size <= kMaxSize; size += alignment) {
     alignment = AlignmentForSize(size);
     CHECK_CONDITION((size % alignment) == 0);
 
@@ skipping 24 matching lines @@
         continue;
       }
     }
 
     // Add new class
     class_to_pages_[sc] = my_pages;
     class_to_size_[sc] = size;
     sc++;
   }
   if (sc != kNumClasses) {
-    CRASH("wrong number of size classes: found %d instead of %d\n",
-          sc, int(kNumClasses));
+    Log(kCrash, __FILE__, __LINE__,
+        "wrong number of size classes: (found vs. expected )", sc, kNumClasses);
   }
 
   // Initialize the mapping arrays
   int next_size = 0;
   for (int c = 1; c < kNumClasses; c++) {
     const int max_size_in_class = class_to_size_[c];
     for (int s = next_size; s <= max_size_in_class; s += kAlignment) {
       class_array_[ClassIndex(s)] = c;
     }
     next_size = max_size_in_class + kAlignment;
   }
 
   // Double-check sizes just to be safe
   for (size_t size = 0; size <= kMaxSize; size++) {
     const int sc = SizeClass(size);
     if (sc <= 0 || sc >= kNumClasses) {
-      CRASH("Bad size class %d for %" PRIuS "\n", sc, size);
+      Log(kCrash, __FILE__, __LINE__,
+          "Bad size class (class, size)", sc, size);
     }
     if (sc > 1 && size <= class_to_size_[sc-1]) {
-      CRASH("Allocating unnecessarily large class %d for %" PRIuS
-            "\n", sc, size);
+      Log(kCrash, __FILE__, __LINE__,
+          "Allocating unnecessarily large class (class, size)", sc, size);
     }
     const size_t s = class_to_size_[sc];
-    if (size > s) {
-      CRASH("Bad size %" PRIuS " for %" PRIuS " (sc = %d)\n", s, size, sc);
-    }
-    if (s == 0) {
-      CRASH("Bad size %" PRIuS " for %" PRIuS " (sc = %d)\n", s, size, sc);
+    if (size > s || s == 0) {
+      Log(kCrash, __FILE__, __LINE__,
+          "Bad (class, size, requested)", sc, s, size);
     }
   }
 
   // Initialize the num_objects_to_move array.
   for (size_t cl = 1; cl  < kNumClasses; ++cl) {
     num_objects_to_move_[cl] = NumMoveSize(ByteSizeForClass(cl));
   }
 }
 
-void SizeMap::Dump(TCMalloc_Printer* out) {
-  // Dump class sizes and maximum external wastage per size class
-  for (size_t cl = 1; cl  < kNumClasses; ++cl) {
-    const int alloc_size = class_to_pages_[cl] << kPageShift;
-    const int alloc_objs = alloc_size / class_to_size_[cl];
-    const int min_used = (class_to_size_[cl-1] + 1) * alloc_objs;
-    const int max_waste = alloc_size - min_used;
-    out->printf("SC %3d [ %8d .. %8d ] from %8d ; %2.0f%% maxwaste\n",
-                int(cl),
-                int(class_to_size_[cl-1] + 1),
-                int(class_to_size_[cl]),
-                int(class_to_pages_[cl] << kPageShift),
-                max_waste * 100.0 / alloc_size
-                );
-  }
-}
-
 // Metadata allocator -- keeps stats about how many bytes allocated.
 static uint64_t metadata_system_bytes_ = 0;
 void* MetaDataAlloc(size_t bytes) {
   void* result = TCMalloc_SystemAlloc(bytes, NULL);
   if (result != NULL) {
     metadata_system_bytes_ += bytes;
   }
   return result;
 }
 
 uint64_t metadata_system_bytes() { return metadata_system_bytes_; }
 
 }  // namespace tcmalloc