Record Chrome trace events in tcmalloc heap profiles

third_party/tcmalloc/chromium/src/heap-profiler.cc

 // Copyright (c) 2005, 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 204 matching lines @@
                                       // (NULL if no need for dumping yet)
 static int   dump_count = 0;          // How many dumps so far
 static int64 last_dump_alloc = 0;     // alloc_size when did we last dump
 static int64 last_dump_free = 0;      // free_size when did we last dump
 static int64 high_water_mark = 0;     // In-use-bytes at last high-water dump
 static int64 last_dump_time = 0;      // The time of the last dump
 
 static HeapProfileTable* heap_profile = NULL;  // the heap profile table
 static DeepHeapProfile* deep_profile = NULL;  // deep memory profiler
 
+// Callback to generate a stack trace for an allocation. May be overriden
+// by an application to provide its own pseudo-stacks.
+static StackGeneratorFunction stack_generator_function =
+    &HeapProfileTable::GetCallerStackTrace;

[jar (doing other things), 2013/07/12 01:24:26]

nit: no need for the ampersand.

[James Cook, 2013/07/12 17:40:27]

Done.

+
 //----------------------------------------------------------------------
 // Profile generation
 //----------------------------------------------------------------------
 
 // Input must be a buffer of size at least 1MB.
 static char* DoGetHeapProfileLocked(char* buf, int buflen) {
   // We used to be smarter about estimating the required memory and
   // then capping it to 1MB and generating the profile into that.
   if (buf == NULL || buflen < 1)
     return NULL;
@@ skipping 132 matching lines @@
       if (inuse_bytes > high_water_mark)
         high_water_mark = inuse_bytes;
     }
   }
 }
 
 // Record an allocation in the profile.
 static void RecordAlloc(const void* ptr, size_t bytes, int skip_count) {
   // Take the stack trace outside the critical section.
   void* stack[HeapProfileTable::kMaxStackDepth];
-  int depth = HeapProfileTable::GetCallerStackTrace(skip_count + 1, stack);
+  int depth = (*stack_generator_function)(skip_count + 1, stack);

[jar (doing other things), 2013/07/12 01:24:26]

nit: no need for the indirection or parens.

stack_generator_function(skip_count + 1, stack);

Should be fine.

[James Cook, 2013/07/12 17:40:27]

Done.  Apparently I have forgotten how to deal with C-style function pointers. 
:-)

   SpinLockHolder l(&heap_lock);
   if (is_on) {
     heap_profile->RecordAlloc(ptr, bytes, depth, stack);
     MaybeDumpProfileLocked();
   }
 }
 
 // Record a deallocation in the profile.
 static void RecordFree(const void* ptr) {
   SpinLockHolder l(&heap_lock);
@@ skipping 147 matching lines @@
   // We do not reset dump_count so if the user does a sequence of
   // HeapProfilerStart/HeapProfileStop, we will get a continuous
   // sequence of profiles.
 
   if (FLAGS_only_mmap_profile == false) {
     // Now set the hooks that capture new/delete and malloc/free.
     RAW_CHECK(MallocHook::AddNewHook(&NewHook), "");
     RAW_CHECK(MallocHook::AddDeleteHook(&DeleteHook), "");
   }
 
-  // Copy filename prefix
+  // Copy filename prefix only if provided.
+  if (!prefix)
+    return;
   RAW_DCHECK(filename_prefix == NULL, "");
   const int prefix_length = strlen(prefix);
   filename_prefix = reinterpret_cast<char*>(ProfilerMalloc(prefix_length + 1));
   memcpy(filename_prefix, prefix, prefix_length);
   filename_prefix[prefix_length] = '\0';
 }
 
+extern "C" void HeapProfilerWithPseudoStackStart(
+    StackGeneratorFunction callback) {
+  {
+    // Ensure the callback is set before allocations can be recorded.
+    SpinLockHolder l(&heap_lock);
+    stack_generator_function = callback;
+  }
+  HeapProfilerStart(NULL);
+}
+
 extern "C" void IterateAllocatedObjects(AddressVisitor visitor, void* data) {
   SpinLockHolder l(&heap_lock);
 
   if (!is_on) return;
 
   heap_profile->IterateAllocationAddresses(visitor, data);
 }
 
 extern "C" int IsHeapProfilerRunning() {
   SpinLockHolder l(&heap_lock);
@@ skipping 106 matching lines @@
 
 // class used for finalization -- dumps the heap-profile at program exit
 struct HeapProfileEndWriter {
   ~HeapProfileEndWriter() { HeapProfilerDump("Exiting"); }
 };
 
 // We want to make sure tcmalloc is up and running before starting the profiler
 static const TCMallocGuard tcmalloc_initializer;
 REGISTER_MODULE_INITIALIZER(heapprofiler, HeapProfilerInit());
 static HeapProfileEndWriter heap_profile_end_writer;