src/third_party/tcmalloc/chromium/src/heap-profile-table.cc

   1 // Copyright (c) 2006, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 // ---
  31 // Author: Sanjay Ghemawat
  32 //         Maxim Lifantsev (refactoring)
  33 //
  34
  35 #include <config.h>
  36
  37 #ifdef HAVE_UNISTD_H
  38 #include <unistd.h>   // for write()
  39 #endif
  40 #include <fcntl.h>    // for open()
  41 #ifdef HAVE_GLOB_H
  42 #include <glob.h>
  43 #ifndef GLOB_NOMATCH  // true on some old cygwins
  44 # define GLOB_NOMATCH 0
  45 #endif
  46 #endif
  47 #ifdef HAVE_INTTYPES_H
  48 #include <inttypes.h> // for PRIxPTR
  49 #endif
  50 #ifdef HAVE_POLL_H
  51 #include <poll.h>
  52 #endif
  53 #include <errno.h>
  54 #include <stdarg.h>
  55 #include <string>
  56 #include <map>
  57 #include <algorithm>  // for sort(), equal(), and copy()
  58
  59 #include "heap-profile-table.h"
  60
  61 #include "base/logging.h"
  62 #include "raw_printer.h"
  63 #include "symbolize.h"
  64 #include <gperftools/stacktrace.h>
  65 #include <gperftools/malloc_hook.h>
  66 #include "memory_region_map.h"
  67 #include "base/commandlineflags.h"
  68 #include "base/logging.h"    // for the RawFD I/O commands
  69 #include "base/sysinfo.h"
  70
  71 using std::sort;
  72 using std::equal;
  73 using std::copy;
  74 using std::string;
  75 using std::map;
  76
  77 using tcmalloc::FillProcSelfMaps;   // from sysinfo.h
  78 using tcmalloc::DumpProcSelfMaps;   // from sysinfo.h
  79
  80 //----------------------------------------------------------------------
  81
  82 DEFINE_bool(cleanup_old_heap_profiles,
  83             EnvToBool("HEAP_PROFILE_CLEANUP", true),
  84             "At initialization time, delete old heap profiles.");
  85
  86 DEFINE_int32(heap_check_max_leaks,
  87              EnvToInt("HEAP_CHECK_MAX_LEAKS", 20),
  88              "The maximum number of leak reports to print.");
  89
  90 //----------------------------------------------------------------------
  91
  92 // header of the dumped heap profile
  93 static const char kProfileHeader[] = "heap profile: ";
  94 static const char kProcSelfMapsHeader[] = "\nMAPPED_LIBRARIES:\n";
  95 #if defined(TYPE_PROFILING)
  96 static const char kTypeProfileStatsHeader[] = "type statistics:\n";
  97 #endif  // defined(TYPE_PROFILING)
  98
  99 //----------------------------------------------------------------------
 100
 101 const char HeapProfileTable::kFileExt[] = ".heap";
 102
 103 //----------------------------------------------------------------------
 104
 105 static const int kHashTableSize = 179999;   // Size for bucket_table_.
 106 // GCC requires this declaration, but MSVC does not allow it.
 107 #if !defined(COMPILER_MSVC)
 108 /*static*/ const int HeapProfileTable::kMaxStackDepth;
 109 #endif
 110
 111 //----------------------------------------------------------------------
 112
 113 // We strip out different number of stack frames in debug mode
 114 // because less inlining happens in that case
 115 #ifdef NDEBUG
 116 static const int kStripFrames = 2;
 117 #else
 118 static const int kStripFrames = 3;
 119 #endif
 120
 121 // For sorting Stats or Buckets by in-use space
 122 static bool ByAllocatedSpace(HeapProfileTable::Stats* a,
 123                              HeapProfileTable::Stats* b) {
 124   // Return true iff "a" has more allocated space than "b"
 125   return (a->alloc_size - a->free_size) > (b->alloc_size - b->free_size);
 126 }
 127
 128 //----------------------------------------------------------------------
 129
 130 HeapProfileTable::HeapProfileTable(Allocator alloc,
 131                                    DeAllocator dealloc,
 132                                    bool profile_mmap)
 133     : alloc_(alloc),
 134       dealloc_(dealloc),
 135       bucket_table_(NULL),
 136       profile_mmap_(profile_mmap),
 137       num_buckets_(0),
 138       address_map_(NULL) {
 139   // Make a hash table for buckets.
 140   const int table_bytes = kHashTableSize * sizeof(*bucket_table_);
 141   bucket_table_ = static_cast<Bucket**>(alloc_(table_bytes));
 142   memset(bucket_table_, 0, table_bytes);
 143
 144   // Make an allocation map.
 145   address_map_ =
 146       new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
 147
 148   // Initialize.
 149   memset(&total_, 0, sizeof(total_));
 150   num_buckets_ = 0;
 151 }
 152
 153 HeapProfileTable::~HeapProfileTable() {
 154   // Free the allocation map.
 155   address_map_->~AllocationMap();
 156   dealloc_(address_map_);
 157   address_map_ = NULL;
 158
 159   // Free the hash table.
 160   for (int i = 0; i < kHashTableSize; i++) {
 161     for (Bucket* curr = bucket_table_[i]; curr != 0; /**/) {
 162       Bucket* bucket = curr;
 163       curr = curr->next;
 164       dealloc_(bucket->stack);
 165       dealloc_(bucket);
 166     }
 167   }
 168   dealloc_(bucket_table_);
 169   bucket_table_ = NULL;
 170 }
 171
 172 HeapProfileTable::Bucket* HeapProfileTable::GetBucket(int depth,
 173                                                       const void* const key[]) {
 174   // Make hash-value
 175   uintptr_t h = 0;
 176   for (int i = 0; i < depth; i++) {
 177     h += reinterpret_cast<uintptr_t>(key[i]);
 178     h += h << 10;
 179     h ^= h >> 6;
 180   }
 181   h += h << 3;
 182   h ^= h >> 11;
 183
 184   // Lookup stack trace in table
 185   unsigned int buck = ((unsigned int) h) % kHashTableSize;
 186   for (Bucket* b = bucket_table_[buck]; b != 0; b = b->next) {
 187     if ((b->hash == h) &&
 188         (b->depth == depth) &&
 189         equal(key, key + depth, b->stack)) {
 190       return b;
 191     }
 192   }
 193
 194   // Create new bucket
 195   const size_t key_size = sizeof(key[0]) * depth;
 196   const void** kcopy = reinterpret_cast<const void**>(alloc_(key_size));
 197   copy(key, key + depth, kcopy);
 198   Bucket* b = reinterpret_cast<Bucket*>(alloc_(sizeof(Bucket)));
 199   memset(b, 0, sizeof(*b));
 200   b->hash  = h;
 201   b->depth = depth;
 202   b->stack = kcopy;
 203   b->next  = bucket_table_[buck];
 204   bucket_table_[buck] = b;
 205   num_buckets_++;
 206   return b;
 207 }
 208
 209 int HeapProfileTable::GetCallerStackTrace(
 210     int skip_count, void* stack[kMaxStackDepth]) {
 211   return MallocHook::GetCallerStackTrace(
 212       stack, kMaxStackDepth, kStripFrames + skip_count + 1);
 213 }
 214
 215 void HeapProfileTable::RecordAlloc(
 216     const void* ptr, size_t bytes, int stack_depth,
 217     const void* const call_stack[]) {
 218   Bucket* b = GetBucket(stack_depth, call_stack);
 219   b->allocs++;
 220   b->alloc_size += bytes;
 221   total_.allocs++;
 222   total_.alloc_size += bytes;
 223
 224   AllocValue v;
 225   v.set_bucket(b);  // also did set_live(false); set_ignore(false)
 226   v.bytes = bytes;
 227   address_map_->Insert(ptr, v);
 228 }
 229
 230 void HeapProfileTable::RecordFree(const void* ptr) {
 231   AllocValue v;
 232   if (address_map_->FindAndRemove(ptr, &v)) {
 233     Bucket* b = v.bucket();
 234     b->frees++;
 235     b->free_size += v.bytes;
 236     total_.frees++;
 237     total_.free_size += v.bytes;
 238   }
 239 }
 240
 241 bool HeapProfileTable::FindAlloc(const void* ptr, size_t* object_size) const {
 242   const AllocValue* alloc_value = address_map_->Find(ptr);
 243   if (alloc_value != NULL) *object_size = alloc_value->bytes;
 244   return alloc_value != NULL;
 245 }
 246
 247 bool HeapProfileTable::FindAllocDetails(const void* ptr,
 248                                         AllocInfo* info) const {
 249   const AllocValue* alloc_value = address_map_->Find(ptr);
 250   if (alloc_value != NULL) {
 251     info->object_size = alloc_value->bytes;
 252     info->call_stack = alloc_value->bucket()->stack;
 253     info->stack_depth = alloc_value->bucket()->depth;
 254   }
 255   return alloc_value != NULL;
 256 }
 257
 258 bool HeapProfileTable::FindInsideAlloc(const void* ptr,
 259                                        size_t max_size,
 260                                        const void** object_ptr,
 261                                        size_t* object_size) const {
 262   const AllocValue* alloc_value =
 263     address_map_->FindInside(&AllocValueSize, max_size, ptr, object_ptr);
 264   if (alloc_value != NULL) *object_size = alloc_value->bytes;
 265   return alloc_value != NULL;
 266 }
 267
 268 bool HeapProfileTable::MarkAsLive(const void* ptr) {
 269   AllocValue* alloc = address_map_->FindMutable(ptr);
 270   if (alloc && !alloc->live()) {
 271     alloc->set_live(true);
 272     return true;
 273   }
 274   return false;
 275 }
 276
 277 void HeapProfileTable::MarkAsIgnored(const void* ptr) {
 278   AllocValue* alloc = address_map_->FindMutable(ptr);
 279   if (alloc) {
 280     alloc->set_ignore(true);
 281   }
 282 }
 283
 284 void HeapProfileTable::IterateAllocationAddresses(AddressIterator f,
 285                                                   void* data) {
 286   const AllocationAddressIteratorArgs args(f, data);
 287   address_map_->Iterate<const AllocationAddressIteratorArgs&>(
 288       AllocationAddressesIterator, args);
 289 }
 290
 291 void HeapProfileTable::MarkCurrentAllocations(AllocationMark mark) {
 292   const MarkArgs args(mark, true);
 293   address_map_->Iterate<const MarkArgs&>(MarkIterator, args);
 294 }
 295
 296 void HeapProfileTable::MarkUnmarkedAllocations(AllocationMark mark) {
 297   const MarkArgs args(mark, true);
 298   address_map_->Iterate<const MarkArgs&>(MarkIterator, args);
 299 }
 300
 301 // We'd be happier using snprintfer, but we don't to reduce dependencies.
 302 int HeapProfileTable::UnparseBucket(const Bucket& b,
 303                                     char* buf, int buflen, int bufsize,
 304                                     const char* extra,
 305                                     Stats* profile_stats) {
 306   if (profile_stats != NULL) {
 307     profile_stats->allocs += b.allocs;
 308     profile_stats->alloc_size += b.alloc_size;
 309     profile_stats->frees += b.frees;
 310     profile_stats->free_size += b.free_size;
 311   }
 312   int printed =
 313     snprintf(buf + buflen, bufsize - buflen,
 314              "%6d: %8" PRId64 " [%6d: %8" PRId64 "] @%s",
 315              b.allocs - b.frees,
 316              b.alloc_size - b.free_size,
 317              b.allocs,
 318              b.alloc_size,
 319              extra);
 320   // If it looks like the snprintf failed, ignore the fact we printed anything
 321   if (printed < 0 || printed >= bufsize - buflen) return buflen;
 322   buflen += printed;
 323   for (int d = 0; d < b.depth; d++) {
 324     printed = snprintf(buf + buflen, bufsize - buflen, " 0x%08" PRIxPTR,
 325                        reinterpret_cast<uintptr_t>(b.stack[d]));
 326     if (printed < 0 || printed >= bufsize - buflen) return buflen;
 327     buflen += printed;
 328   }
 329   printed = snprintf(buf + buflen, bufsize - buflen, "\n");
 330   if (printed < 0 || printed >= bufsize - buflen) return buflen;
 331   buflen += printed;
 332   return buflen;
 333 }
 334
 335 HeapProfileTable::Bucket**
 336 HeapProfileTable::MakeSortedBucketList() const {
 337   Bucket** list = static_cast<Bucket**>(alloc_(sizeof(Bucket) * num_buckets_));
 338
 339   int bucket_count = 0;
 340   for (int i = 0; i < kHashTableSize; i++) {
 341     for (Bucket* curr = bucket_table_[i]; curr != 0; curr = curr->next) {
 342       list[bucket_count++] = curr;
 343     }
 344   }
 345   RAW_DCHECK(bucket_count == num_buckets_, "");
 346
 347   sort(list, list + num_buckets_, ByAllocatedSpace);
 348
 349   return list;
 350 }
 351
 352 void HeapProfileTable::DumpMarkedObjects(AllocationMark mark,
 353                                          const char* file_name) {
 354   RawFD fd = RawOpenForWriting(file_name);
 355   if (fd == kIllegalRawFD) {
 356     RAW_LOG(ERROR, "Failed dumping live objects to %s", file_name);
 357     return;
 358   }
 359   const DumpMarkedArgs args(fd, mark);
 360   address_map_->Iterate<const DumpMarkedArgs&>(DumpMarkedIterator, args);
 361   RawClose(fd);
 362 }
 363
 364 #if defined(TYPE_PROFILING)
 365 void HeapProfileTable::DumpTypeStatistics(const char* file_name) const {
 366   RawFD fd = RawOpenForWriting(file_name);
 367   if (fd == kIllegalRawFD) {
 368     RAW_LOG(ERROR, "Failed dumping type statistics to %s", file_name);
 369     return;
 370   }
 371
 372   AddressMap<TypeCount>* type_size_map;
 373   type_size_map = new(alloc_(sizeof(AddressMap<TypeCount>)))
 374       AddressMap<TypeCount>(alloc_, dealloc_);
 375   address_map_->Iterate(TallyTypesItererator, type_size_map);
 376
 377   RawWrite(fd, kTypeProfileStatsHeader, strlen(kTypeProfileStatsHeader));
 378   const DumpArgs args(fd, NULL);
 379   type_size_map->Iterate<const DumpArgs&>(DumpTypesIterator, args);
 380   RawClose(fd);
 381
 382   type_size_map->~AddressMap<TypeCount>();
 383   dealloc_(type_size_map);
 384 }
 385 #endif  // defined(TYPE_PROFILING)
 386
 387 void HeapProfileTable::IterateOrderedAllocContexts(
 388     AllocContextIterator callback) const {
 389   Bucket** list = MakeSortedBucketList();
 390   AllocContextInfo info;
 391   for (int i = 0; i < num_buckets_; ++i) {
 392     *static_cast<Stats*>(&info) = *static_cast<Stats*>(list[i]);
 393     info.stack_depth = list[i]->depth;
 394     info.call_stack = list[i]->stack;
 395     callback(info);
 396   }
 397   dealloc_(list);
 398 }
 399
 400 int HeapProfileTable::FillOrderedProfile(char buf[], int size) const {
 401   Bucket** list = MakeSortedBucketList();
 402
 403   // Our file format is "bucket, bucket, ..., bucket, proc_self_maps_info".
 404   // In the cases buf is too small, we'd rather leave out the last
 405   // buckets than leave out the /proc/self/maps info.  To ensure that,
 406   // we actually print the /proc/self/maps info first, then move it to
 407   // the end of the buffer, then write the bucket info into whatever
 408   // is remaining, and then move the maps info one last time to close
 409   // any gaps.  Whew!
 410   int map_length = snprintf(buf, size, "%s", kProcSelfMapsHeader);
 411   if (map_length < 0 || map_length >= size) return 0;
 412   bool dummy;   // "wrote_all" -- did /proc/self/maps fit in its entirety?
 413   map_length += FillProcSelfMaps(buf + map_length, size - map_length, &dummy);
 414   RAW_DCHECK(map_length <= size, "");
 415   char* const map_start = buf + size - map_length;      // move to end
 416   memmove(map_start, buf, map_length);
 417   size -= map_length;
 418
 419   Stats stats;
 420   memset(&stats, 0, sizeof(stats));
 421   int bucket_length = snprintf(buf, size, "%s", kProfileHeader);
 422   if (bucket_length < 0 || bucket_length >= size) return 0;
 423   bucket_length = UnparseBucket(total_, buf, bucket_length, size,
 424                                 " heapprofile", &stats);
 425
 426   // Dump the mmap list first.
 427   if (profile_mmap_) {
 428     BufferArgs buffer(buf, bucket_length, size);
 429     MemoryRegionMap::IterateBuckets<BufferArgs*>(DumpBucketIterator, &buffer);
 430     bucket_length = buffer.buflen;
 431   }
 432
 433   for (int i = 0; i < num_buckets_; i++) {
 434     bucket_length = UnparseBucket(*list[i], buf, bucket_length, size, "",
 435                                   &stats);
 436   }
 437   RAW_DCHECK(bucket_length < size, "");
 438
 439   dealloc_(list);
 440
 441   RAW_DCHECK(buf + bucket_length <= map_start, "");
 442   memmove(buf + bucket_length, map_start, map_length);  // close the gap
 443
 444   return bucket_length + map_length;
 445 }
 446
 447 // static
 448 void HeapProfileTable::DumpBucketIterator(const Bucket* bucket,
 449                                           BufferArgs* args) {
 450   args->buflen = UnparseBucket(*bucket, args->buf, args->buflen, args->bufsize,
 451                                "", NULL);
 452 }
 453
 454 #if defined(TYPE_PROFILING)
 455 // static
 456 void HeapProfileTable::TallyTypesItererator(
 457     const void* ptr,
 458     AllocValue* value,
 459     AddressMap<TypeCount>* type_size_map) {
 460   const std::type_info* type = LookupType(ptr);
 461
 462   const void* key = NULL;
 463   if (type)
 464     key = type->name();
 465
 466   TypeCount* count = type_size_map->FindMutable(key);
 467   if (count) {
 468     count->bytes += value->bytes;
 469     ++count->objects;
 470   } else {
 471     type_size_map->Insert(key, TypeCount(value->bytes, 1));
 472   }
 473 }
 474
 475 // static
 476 void HeapProfileTable::DumpTypesIterator(const void* ptr,
 477                                          TypeCount* count,
 478                                          const DumpArgs& args) {
 479   char buf[1024];
 480   int len;
 481   const char* mangled_type_name = static_cast<const char*>(ptr);
 482   len = snprintf(buf, sizeof(buf), "%6d: %8" PRId64 " @ %s\n",
 483                  count->objects, count->bytes,
 484                  mangled_type_name ? mangled_type_name : "(no_typeinfo)");
 485   RawWrite(args.fd, buf, len);
 486 }
 487 #endif  // defined(TYPE_PROFILING)
 488
 489 inline
 490 void HeapProfileTable::DumpNonLiveIterator(const void* ptr, AllocValue* v,
 491                                            const DumpArgs& args) {
 492   if (v->live()) {
 493     v->set_live(false);
 494     return;
 495   }
 496   if (v->ignore()) {
 497     return;
 498   }
 499   Bucket b;
 500   memset(&b, 0, sizeof(b));
 501   b.allocs = 1;
 502   b.alloc_size = v->bytes;
 503   b.depth = v->bucket()->depth;
 504   b.stack = v->bucket()->stack;
 505   char buf[1024];
 506   int len = UnparseBucket(b, buf, 0, sizeof(buf), "", args.profile_stats);
 507   RawWrite(args.fd, buf, len);
 508 }
 509
 510 inline
 511 void HeapProfileTable::DumpMarkedIterator(const void* ptr, AllocValue* v,
 512                                           const DumpMarkedArgs& args) {
 513   if (v->mark() != args.mark)
 514     return;
 515   Bucket b;
 516   memset(&b, 0, sizeof(b));
 517   b.allocs = 1;
 518   b.alloc_size = v->bytes;
 519   b.depth = v->bucket()->depth;
 520   b.stack = v->bucket()->stack;
 521   char addr[16];
 522   snprintf(addr, 16, "0x%08" PRIxPTR, ptr);
 523   char buf[1024];
 524   int len = UnparseBucket(b, buf, 0, sizeof(buf), addr, NULL);
 525   RawWrite(args.fd, buf, len);
 526 }
 527
 528 inline
 529 void HeapProfileTable::AllocationAddressesIterator(
 530     const void* ptr,
 531     AllocValue* v,
 532     const AllocationAddressIteratorArgs& args) {
 533   args.callback(args.data, ptr);
 534 }
 535
 536 inline
 537 void HeapProfileTable::MarkIterator(const void* ptr, AllocValue* v,
 538                                     const MarkArgs& args) {
 539   if (!args.mark_all && v->mark() != UNMARKED)
 540     return;
 541   v->set_mark(args.mark);
 542 }
 543
 544 // Callback from NonLiveSnapshot; adds entry to arg->dest
 545 // if not the entry is not live and is not present in arg->base.
 546 void HeapProfileTable::AddIfNonLive(const void* ptr, AllocValue* v,
 547                                     AddNonLiveArgs* arg) {
 548   if (v->live()) {
 549     v->set_live(false);
 550   } else {
 551     if (arg->base != NULL && arg->base->map_.Find(ptr) != NULL) {
 552       // Present in arg->base, so do not save
 553     } else {
 554       arg->dest->Add(ptr, *v);
 555     }
 556   }
 557 }
 558
 559 bool HeapProfileTable::WriteProfile(const char* file_name,
 560                                     const Bucket& total,
 561                                     AllocationMap* allocations) {
 562   RAW_VLOG(1, "Dumping non-live heap profile to %s", file_name);
 563   RawFD fd = RawOpenForWriting(file_name);
 564   if (fd == kIllegalRawFD) {
 565     RAW_LOG(ERROR, "Failed dumping filtered heap profile to %s", file_name);
 566     return false;
 567   }
 568   RawWrite(fd, kProfileHeader, strlen(kProfileHeader));
 569   char buf[512];
 570   int len = UnparseBucket(total, buf, 0, sizeof(buf), " heapprofile",
 571                           NULL);
 572   RawWrite(fd, buf, len);
 573   const DumpArgs args(fd, NULL);
 574   allocations->Iterate<const DumpArgs&>(DumpNonLiveIterator, args);
 575   RawWrite(fd, kProcSelfMapsHeader, strlen(kProcSelfMapsHeader));
 576   DumpProcSelfMaps(fd);
 577   RawClose(fd);
 578   return true;
 579 }
 580
 581 void HeapProfileTable::CleanupOldProfiles(const char* prefix) {
 582   if (!FLAGS_cleanup_old_heap_profiles)
 583     return;
 584   char buf[1000];
 585   snprintf(buf, 1000,"%s.%05d.", prefix, getpid());
 586   string pattern = string(buf) + ".*" + kFileExt;
 587
 588 #if defined(HAVE_GLOB_H)
 589   glob_t g;
 590   const int r = glob(pattern.c_str(), GLOB_ERR, NULL, &g);
 591   if (r == 0 || r == GLOB_NOMATCH) {
 592     const int prefix_length = strlen(prefix);
 593     for (int i = 0; i < g.gl_pathc; i++) {
 594       const char* fname = g.gl_pathv[i];
 595       if ((strlen(fname) >= prefix_length) &&
 596           (memcmp(fname, prefix, prefix_length) == 0)) {
 597         RAW_VLOG(1, "Removing old heap profile %s", fname);
 598         unlink(fname);
 599       }
 600     }
 601   }
 602   globfree(&g);
 603 #else   /* HAVE_GLOB_H */
 604   RAW_LOG(WARNING, "Unable to remove old heap profiles (can't run glob())");
 605 #endif
 606 }
 607
 608 HeapProfileTable::Snapshot* HeapProfileTable::TakeSnapshot() {
 609   Snapshot* s = new (alloc_(sizeof(Snapshot))) Snapshot(alloc_, dealloc_);
 610   address_map_->Iterate(AddToSnapshot, s);
 611   return s;
 612 }
 613
 614 void HeapProfileTable::ReleaseSnapshot(Snapshot* s) {
 615   s->~Snapshot();
 616   dealloc_(s);
 617 }
 618
 619 // Callback from TakeSnapshot; adds a single entry to snapshot
 620 void HeapProfileTable::AddToSnapshot(const void* ptr, AllocValue* v,
 621                                      Snapshot* snapshot) {
 622   snapshot->Add(ptr, *v);
 623 }
 624
 625 HeapProfileTable::Snapshot* HeapProfileTable::NonLiveSnapshot(
 626     Snapshot* base) {
 627   RAW_VLOG(2, "NonLiveSnapshot input: %d %d\n",
 628            int(total_.allocs - total_.frees),
 629            int(total_.alloc_size - total_.free_size));
 630
 631   Snapshot* s = new (alloc_(sizeof(Snapshot))) Snapshot(alloc_, dealloc_);
 632   AddNonLiveArgs args;
 633   args.dest = s;
 634   args.base = base;
 635   address_map_->Iterate<AddNonLiveArgs*>(AddIfNonLive, &args);
 636   RAW_VLOG(2, "NonLiveSnapshot output: %d %d\n",
 637            int(s->total_.allocs - s->total_.frees),
 638            int(s->total_.alloc_size - s->total_.free_size));
 639   return s;
 640 }
 641
 642 // Information kept per unique bucket seen
 643 struct HeapProfileTable::Snapshot::Entry {
 644   int count;
 645   int bytes;
 646   Bucket* bucket;
 647   Entry() : count(0), bytes(0) { }
 648
 649   // Order by decreasing bytes
 650   bool operator<(const Entry& x) const {
 651     return this->bytes > x.bytes;
 652   }
 653 };
 654
 655 // State used to generate leak report.  We keep a mapping from Bucket pointer
 656 // the collected stats for that bucket.
 657 struct HeapProfileTable::Snapshot::ReportState {
 658   map<Bucket*, Entry> buckets_;
 659 };
 660
 661 // Callback from ReportLeaks; updates ReportState.
 662 void HeapProfileTable::Snapshot::ReportCallback(const void* ptr,
 663                                                 AllocValue* v,
 664                                                 ReportState* state) {
 665   Entry* e = &state->buckets_[v->bucket()]; // Creates empty Entry first time
 666   e->bucket = v->bucket();
 667   e->count++;
 668   e->bytes += v->bytes;
 669 }
 670
 671 void HeapProfileTable::Snapshot::ReportLeaks(const char* checker_name,
 672                                              const char* filename,
 673                                              bool should_symbolize) {
 674   // This is only used by the heap leak checker, but is intimately
 675   // tied to the allocation map that belongs in this module and is
 676   // therefore placed here.
 677   RAW_LOG(ERROR, "Leak check %s detected leaks of %" PRIuS " bytes "
 678           "in %" PRIuS " objects",
 679           checker_name,
 680           size_t(total_.alloc_size),
 681           size_t(total_.allocs));
 682
 683   // Group objects by Bucket
 684   ReportState state;
 685   map_.Iterate(&ReportCallback, &state);
 686
 687   // Sort buckets by decreasing leaked size
 688   const int n = state.buckets_.size();
 689   Entry* entries = new Entry[n];
 690   int dst = 0;
 691   for (map<Bucket*,Entry>::const_iterator iter = state.buckets_.begin();
 692        iter != state.buckets_.end();
 693        ++iter) {
 694     entries[dst++] = iter->second;
 695   }
 696   sort(entries, entries + n);
 697
 698   // Report a bounded number of leaks to keep the leak report from
 699   // growing too long.
 700   const int to_report =
 701       (FLAGS_heap_check_max_leaks > 0 &&
 702        n > FLAGS_heap_check_max_leaks) ? FLAGS_heap_check_max_leaks : n;
 703   RAW_LOG(ERROR, "The %d largest leaks:", to_report);
 704
 705   // Print
 706   SymbolTable symbolization_table;
 707   for (int i = 0; i < to_report; i++) {
 708     const Entry& e = entries[i];
 709     for (int j = 0; j < e.bucket->depth; j++) {
 710       symbolization_table.Add(e.bucket->stack[j]);
 711     }
 712   }
 713   static const int kBufSize = 2<<10;
 714   char buffer[kBufSize];
 715   if (should_symbolize)
 716     symbolization_table.Symbolize();
 717   for (int i = 0; i < to_report; i++) {
 718     const Entry& e = entries[i];
 719     base::RawPrinter printer(buffer, kBufSize);
 720     printer.Printf("Leak of %d bytes in %d objects allocated from:\n",
 721                    e.bytes, e.count);
 722     for (int j = 0; j < e.bucket->depth; j++) {
 723       const void* pc = e.bucket->stack[j];
 724       printer.Printf("\t@ %" PRIxPTR " %s\n",
 725           reinterpret_cast<uintptr_t>(pc), symbolization_table.GetSymbol(pc));
 726     }
 727     RAW_LOG(ERROR, "%s", buffer);
 728   }
 729
 730   if (to_report < n) {
 731     RAW_LOG(ERROR, "Skipping leaks numbered %d..%d",
 732             to_report, n-1);
 733   }
 734   delete[] entries;
 735
 736   // TODO: Dump the sorted Entry list instead of dumping raw data?
 737   // (should be much shorter)
 738   if (!HeapProfileTable::WriteProfile(filename, total_, &map_)) {
 739     RAW_LOG(ERROR, "Could not write pprof profile to %s", filename);
 740   }
 741 }
 742
 743 void HeapProfileTable::Snapshot::ReportObject(const void* ptr,
 744                                               AllocValue* v,
 745                                               char* unused) {
 746   // Perhaps also log the allocation stack trace (unsymbolized)
 747   // on this line in case somebody finds it useful.
 748   RAW_LOG(ERROR, "leaked %" PRIuS " byte object %p", v->bytes, ptr);
 749 }
 750
 751 void HeapProfileTable::Snapshot::ReportIndividualObjects() {
 752   char unused;
 753   map_.Iterate(ReportObject, &unused);
 754 }