Record Chrome trace events in tcmalloc heap profiles

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

 // Copyright (c) 2006, 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 113 matching lines @@
 
 //----------------------------------------------------------------------
 
 HeapProfileTable::HeapProfileTable(Allocator alloc,
                                    DeAllocator dealloc,
                                    bool profile_mmap)
     : alloc_(alloc),
       dealloc_(dealloc),
       bucket_table_(NULL),
       profile_mmap_(profile_mmap),
+      profile_self_maps_(true),
       num_buckets_(0),
       address_map_(NULL) {
   // Make a hash table for buckets.
   const int table_bytes = kHashTableSize * sizeof(*bucket_table_);
   bucket_table_ = static_cast<Bucket**>(alloc_(table_bytes));
   memset(bucket_table_, 0, table_bytes);
 
   // Make an allocation map.
   address_map_ =
       new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
@@ skipping 242 matching lines @@
   AllocContextInfo info;
   for (int i = 0; i < num_buckets_; ++i) {
     *static_cast<Stats*>(&info) = *static_cast<Stats*>(list[i]);
     info.stack_depth = list[i]->depth;
     info.call_stack = list[i]->stack;
     callback(info);
   }
   dealloc_(list);
 }
 
+void HeapProfileTable::DisableProfileSelfMaps() {
+  profile_self_maps_ = false;
+}
+
 int HeapProfileTable::FillOrderedProfile(char buf[], int size) const {
   Bucket** list = MakeSortedBucketList();
 
-  // Our file format is "bucket, bucket, ..., bucket, proc_self_maps_info".
-  // In the cases buf is too small, we'd rather leave out the last
-  // buckets than leave out the /proc/self/maps info.  To ensure that,
-  // we actually print the /proc/self/maps info first, then move it to
-  // the end of the buffer, then write the bucket info into whatever
-  // is remaining, and then move the maps info one last time to close
-  // any gaps.  Whew!
-  int map_length = snprintf(buf, size, "%s", kProcSelfMapsHeader);
-  if (map_length < 0 || map_length >= size) return 0;
-  bool dummy;   // "wrote_all" -- did /proc/self/maps fit in its entirety?
-  map_length += FillProcSelfMaps(buf + map_length, size - map_length, &dummy);
-  RAW_DCHECK(map_length <= size, "");
-  char* const map_start = buf + size - map_length;      // move to end
-  memmove(map_start, buf, map_length);
-  size -= map_length;
+  int map_length = 0;
+  char* map_start = NULL;
+  // The data from /proc/self/maps is not required for pseudo-stack profiles
+  // and increases the size of the profile dumps significantly.

[Dai Mikurube (NOT FULLTIME), 2013/07/01 05:47:42]

Is maps so large?  Is large output so serious?  I don't think it's so reasonable
to add this option |profile_self_maps| to drop maps...

[James Cook, 2013/07/01 16:59:16]

There's also a problem where attempting to read /proc/self/maps from the GPU
process causes it to hang.  I haven't investigated that in detail because it
seemed easier to skip collection of the data (since I don't use it anyway).

[James Cook, 2013/07/01 22:37:16]

The GPU process hang is due to the security sandbox attempting to allocate
memory inside of a signal handler when attempting to open the file
/proc/self/maps. jorgelo@ on the security team is going to look into it. I'm
going to disable my code in the GPU process until this is sorted out.  You might
also have problems with normal tcmalloc heap profiles of the GPU process, unless
you are disabling the sandbox somehow.

[Dai Mikurube (NOT FULLTIME), 2013/07/02 01:39:06]

Ah, makes sense. Sorry that I forgot it. In case of DMP, it requires
--no-sandbox.

Does the sandbox failure happen in the open() system call?  If not, how about
fixing ProcMapsIterator to "fail cleanly" when it cannot open /proc/self/maps? 
It's a reasonable fix also in upstream tcmalloc.

If it doesn't fix, DisableProfileSelfMaps() might be the second best reasonable
way.

+  if (profile_self_maps_) {
+    // Our file format is "bucket, bucket, ..., bucket, proc_self_maps_info".
+    // In the cases buf is too small, we'd rather leave out the last
+    // buckets than leave out the /proc/self/maps info.  To ensure that,
+    // we actually print the /proc/self/maps info first, then move it to
+    // the end of the buffer, then write the bucket info into whatever
+    // is remaining, and then move the maps info one last time to close
+    // any gaps.  Whew!
+    map_length = snprintf(buf, size, "%s", kProcSelfMapsHeader);
+    if (map_length < 0 || map_length >= size) return 0;
+    bool dummy;   // "wrote_all" -- did /proc/self/maps fit in its entirety?
+    map_length += FillProcSelfMaps(buf + map_length, size - map_length, &dummy);
+    RAW_DCHECK(map_length <= size, "");
+    map_start = buf + size - map_length;      // move to end
+    memmove(map_start, buf, map_length);
+    size -= map_length;
+  }
 
   Stats stats;
   memset(&stats, 0, sizeof(stats));
   int bucket_length = snprintf(buf, size, "%s", kProfileHeader);
   if (bucket_length < 0 || bucket_length >= size) return 0;
   bucket_length = UnparseBucket(total_, buf, bucket_length, size,
                                 " heapprofile", &stats);
 
   // Dump the mmap list first.
   if (profile_mmap_) {
     BufferArgs buffer(buf, bucket_length, size);
     MemoryRegionMap::IterateBuckets<BufferArgs*>(DumpBucketIterator, &buffer);
     bucket_length = buffer.buflen;
   }
 
   for (int i = 0; i < num_buckets_; i++) {
     bucket_length = UnparseBucket(*list[i], buf, bucket_length, size, "",
                                   &stats);
   }
   RAW_DCHECK(bucket_length < size, "");
 
   dealloc_(list);
 
+  if (!profile_self_maps_)
+    return bucket_length;
+
   RAW_DCHECK(buf + bucket_length <= map_start, "");
   memmove(buf + bucket_length, map_start, map_length);  // close the gap
 
   return bucket_length + map_length;
 }
 
 // static
 void HeapProfileTable::DumpBucketIterator(const Bucket* bucket,
                                           BufferArgs* args) {
   args->buflen = UnparseBucket(*bucket, args->buf, args->buflen, args->bufsize,
@@ skipping 294 matching lines @@
                                               char* unused) {
   // Perhaps also log the allocation stack trace (unsymbolized)
   // on this line in case somebody finds it useful.
   RAW_LOG(ERROR, "leaked %"PRIuS" byte object %p", v->bytes, ptr);
 }
 
 void HeapProfileTable::Snapshot::ReportIndividualObjects() {
   char unused;
   map_.Iterate(ReportObject, &unused);
 }