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::UnparsePseudoStackBucket(
+    const Bucket& bucket,
+    char* buffer, int written, int buffer_size,
+    Stats* profile_stats) {
+  if (profile_stats != NULL) {
+    profile_stats->allocs += bucket.allocs;
+    profile_stats->alloc_size += bucket.alloc_size;
+    profile_stats->frees += bucket.frees;
+    profile_stats->free_size += bucket.free_size;
+  }
+  int printed = snprintf(buffer + written,

[dsinclair, 2013/06/18 15:30:15]

Would it be possible, instead of converting to JSON format here, returning a
simple struct with the data and doing the JSON conversion in the
ConvertableToTraceFormat?  Doing it here will add a bit of CPU overhead which
may skew the tracing profile a bit.

(Hm, doesn't look like it without creating a new GetHeapProfile, bummer)

[Dai Mikurube (NOT FULLTIME), 2013/06/19 04:34:03]

Agreed with dsinclair.  Would it be possible to keep a similar format with the
original tcmalloc's heap-profiler?  It may allow to use some existing tools.

If I understand correctly, your pseudo-stacks are recorded in the same way with
the existing profiler.  We can use the same "unparser" and "filler", can't we?

Dumping it in a JSON format is a different issue from your pseudo-stacking.  At
least, this function should have a different name while I don't believe we need
it.  Changes in these tcmalloc files should be requisite minimum since it is
third_party.  Changes make it harder to roll up.

+                         buffer_size - written,
+                         "{"
+                         "\"trace\": \"");
+  written += printed;
+  RAW_DCHECK(bucket.depth <= HeapProfileBucket::kMaxStackDepth,
+             "stack depth too deep");
+  for (int d = 0; d < bucket.depth; d++) {
+    printed = snprintf(buffer + written, buffer_size - written, "%s ",
+                       reinterpret_cast<const char*>(bucket.stack[d]));
+    // Brute-force replace any " with ' to keep the JSON correct.
+    for (int i = 0; i < printed; ++i) {
+      char* c = buffer + written + i;
+      if (*c == '"')
+        *c = '\'';
+    }
+    if (printed < 0 || printed >= buffer_size - written) return written;
+    written += printed;
+  }
+  printed = snprintf(buffer + written,
+                     buffer_size - written,
+                     "\", "
+                     "\"current_allocs\": %d, "
+                     "\"current_bytes\": %" PRId64 ", "
+                     "\"total_allocs\": %d, "
+                     "\"total_bytes\": %" PRId64
+                     "}",
+                     bucket.allocs - bucket.frees,
+                     bucket.alloc_size - bucket.free_size,
+                     bucket.allocs,
+                     bucket.alloc_size);
+  // If it looks like the snprintf failed, ignore the fact we printed anything
+  if (printed < 0 || printed >= buffer_size - written) return written;
+  written += printed;
+  return written;
+}
+
 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;
 }
 
+int HeapProfileTable::FillPseudoStackProfile(char buffer[],
+                                             int buffer_size) const {
+  Bucket** list = MakeSortedBucketList();
+
+  Stats stats;
+  memset(&stats, 0, sizeof(stats));
+  int written = snprintf(buffer, buffer_size, "[\n");
+  written = UnparsePseudoStackBucket(
+      total_, buffer, written, buffer_size, &stats);
+
+  for (int i = 0; i < num_buckets_; i++) {
+    written += snprintf(buffer + written, buffer_size - written, ",\n");
+    written = UnparsePseudoStackBucket(
+        *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);
 }