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 310 matching lines @@
                        reinterpret_cast<uintptr_t>(b.stack[d]));
     if (printed < 0 || printed >= bufsize - buflen) return buflen;
     buflen += printed;
   }
   printed = snprintf(buf + buflen, bufsize - buflen, "\n");
   if (printed < 0 || printed >= bufsize - buflen) return buflen;
   buflen += printed;
   return buflen;
 }
 
+int HeapProfileTable::UnparseBucket2(const Bucket& b,
+                                     char* buf, int buflen, int bufsize,
+                                     Stats* profile_stats) {
+  if (profile_stats != NULL) {
+    profile_stats->allocs += b.allocs;
+    profile_stats->alloc_size += b.alloc_size;
+    profile_stats->frees += b.frees;
+    profile_stats->free_size += b.free_size;
+  }
+  int printed = snprintf(buf + buflen,
+                         bufsize - buflen,
+                         "{"
+                         "\"trace\": \"");
+  buflen += printed;
+  for (int d = 0; d < b.depth; d++) {
+    // OMG what a hack
+    printed = snprintf(buf + buflen, bufsize - buflen, "%s ",
+                       reinterpret_cast<const char*>(b.stack[d]));
+    if (printed < 0 || printed >= bufsize - buflen) return buflen;
+    buflen += printed;
+  }
+  printed = snprintf(buf + buflen,
+                     bufsize - buflen,
+                     "\", "
+                     "\"current_allocs\": %d, "
+                     "\"current_bytes\": %" PRId64 ", "
+                     "\"total_allocs\": %d, "
+                     "\"total_bytes\": %" PRId64
+                     "}",
+                     b.allocs - b.frees,
+                     b.alloc_size - b.free_size,
+                     b.allocs,
+                     b.alloc_size);
+  // If it looks like the snprintf failed, ignore the fact we printed anything
+  if (printed < 0 || printed >= bufsize - buflen) return buflen;
+  buflen += printed;
+  return buflen;
+}
+
 HeapProfileTable::Bucket**
 HeapProfileTable::MakeSortedBucketList() const {
   Bucket** list = static_cast<Bucket**>(alloc_(sizeof(Bucket) * num_buckets_));
 
   int bucket_count = 0;
   for (int i = 0; i < kHashTableSize; i++) {
     for (Bucket* curr = bucket_table_[i]; curr != 0; curr = curr->next) {
       list[bucket_count++] = curr;
     }
   }
@@ skipping 92 matching lines @@
   RAW_DCHECK(bucket_length < size, "");
 
   dealloc_(list);
 
   RAW_DCHECK(buf + bucket_length <= map_start, "");
   memmove(buf + bucket_length, map_start, map_length);  // close the gap
 
   return bucket_length + map_length;
 }
 
+// TODO(jamescook): Make a subclass and override this method.
+int HeapProfileTable::FillOrderedProfile2(char buffer[],
+                                          int buffer_size) const {
+  Bucket** list = MakeSortedBucketList();
+
+  Stats stats;
+  memset(&stats, 0, sizeof(stats));
+  int written = snprintf(buffer, buffer_size, "[\n");
+  written = UnparseBucket2(total_, buffer, written, buffer_size, &stats);
+
+  for (int i = 0; i < num_buckets_; i++) {
+    written += snprintf(buffer + written, buffer_size - written, ",\n");
+    written = UnparseBucket2(*list[i], buffer, written, buffer_size, &stats);
+  }
+  RAW_DCHECK(written < buffer_size, "");
+
+  written += snprintf(buffer + written, buffer_size - written, "\n]\n");
+
+  dealloc_(list);
+
+  return written;
+}
+
 // static
 void HeapProfileTable::DumpBucketIterator(const Bucket* bucket,
                                           BufferArgs* args) {
   args->buflen = UnparseBucket(*bucket, args->buf, args->buflen, args->bufsize,
                                "", NULL);
 }
 
 #if defined(TYPE_PROFILING)
 // static
 void HeapProfileTable::TallyTypesItererator(
@@ skipping 288 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);
 }