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 198 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 an appplication can use to generate its own "stacks".
+static PseudoStackGenerator pseudo_stack_generator = NULL;
+
 //----------------------------------------------------------------------
 // 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;
 
   RAW_DCHECK(heap_lock.IsHeld(), "");
   int bytes_written = 0;
   if (is_on) {
     HeapProfileTable::Stats const stats = heap_profile->total();
     (void)stats;   // avoid an unused-variable warning in non-debug mode.
-    bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
+    if (pseudo_stack_generator) {
+      bytes_written = heap_profile->FillPseudoStackProfile(buf, buflen - 1);
+    } else {
+      bytes_written = heap_profile->FillOrderedProfile(buf, buflen - 1);
+    }
     // FillOrderedProfile should not reduce the set of active mmap-ed regions,
     // hence MemoryRegionMap will let us remove everything we've added above:
     RAW_DCHECK(stats.Equivalent(heap_profile->total()), "");
     // if this fails, we somehow removed by FillOrderedProfile
     // more than we have added.
   }
   buf[bytes_written] = '\0';
   RAW_DCHECK(bytes_written == strlen(buf), "");
 
   return buf;
@@ skipping 123 matching lines @@
   // Take the stack trace outside the critical section.
   void* stack[HeapProfileTable::kMaxStackDepth];
   int depth = HeapProfileTable::GetCallerStackTrace(skip_count + 1, stack);
   SpinLockHolder l(&heap_lock);
   if (is_on) {
     heap_profile->RecordAlloc(ptr, bytes, depth, stack);
     MaybeDumpProfileLocked();
   }
 }
 
+// Record an allocation in the profile.
+static void PseudoStackRecordAlloc(const void* ptr,
+                                   size_t bytes,
+                                   int skip_count) {

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

It's almost the same with RecordAlloc().  Why do we need this additional
function?

Also, don't we need RecordFree?

[James Cook, 2013/06/29 00:02:42]

I elected to copy the function because this is performance critical code inside
the allocator - I thought it was better to do this than to combine the common
parts of RecordAlloc and PseudoStackRecordAlloc and introduce an extra function
call or branch.

RecordFree is identical in both cases, the pseudo-stack push/pops are handled in
the Chrome trace-event level and don't need any information about frees.

+  // Take the stack trace outside the critical section.
+  void* stack[HeapProfileTable::kMaxStackDepth];
+  // Generate our pseudo-stack by via callback into the client code.
+  int depth = (*pseudo_stack_generator)(stack);
+  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);
   if (is_on) {
     heap_profile->RecordFree(ptr);
     MaybeDumpProfileLocked();
   }
 }
 
 //----------------------------------------------------------------------
 // Allocation/deallocation hooks for MallocHook
 //----------------------------------------------------------------------
 
 // static
 void NewHook(const void* ptr, size_t size) {
   if (ptr != NULL) RecordAlloc(ptr, size, 0);
 }
 
 // static
 void DeleteHook(const void* ptr) {
   if (ptr != NULL) RecordFree(ptr);
 }
 
+// static
+void PseudoStackNewHook(const void* ptr, size_t size) {

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

ditto.

+  if (ptr != NULL) PseudoStackRecordAlloc(ptr, size, 0);
+}
+
 // TODO(jandrews): Re-enable stack tracing
 #ifdef TODO_REENABLE_STACK_TRACING
 static void RawInfoStackDumper(const char* message, void*) {
   RAW_LOG(INFO, "%.*s", static_cast<int>(strlen(message) - 1), message);
   // -1 is to chop the \n which will be added by RAW_LOG
 }
 #endif
 
 static void MmapHook(const void* result, const void* start, size_t size,
                      int prot, int flags, int fd, off_t offset) {
@@ skipping 112 matching lines @@
     deep_profile = new(ProfilerMalloc(sizeof(DeepHeapProfile)))
         DeepHeapProfile(heap_profile, prefix);
   }
 
   // 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), "");
+    if (pseudo_stack_generator) {
+      RAW_CHECK(MallocHook::AddNewHook(&PseudoStackNewHook), "");
+    } else {
+      RAW_CHECK(MallocHook::AddNewHook(&NewHook), "");
+    }
     RAW_CHECK(MallocHook::AddDeleteHook(&DeleteHook), "");
   }
 
-  // Copy filename prefix
-  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';
+  // Copy filename prefix if provided.
+  if (prefix) {
+    RAW_DCHECK(filename_prefix == NULL, "");
+    const int prefix_length = strlen(prefix);
+    filename_prefix = reinterpret_cast<char*>(ProfilerMalloc(prefix_length + 1));

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

Over 80?

+    memcpy(filename_prefix, prefix, prefix_length);
+    filename_prefix[prefix_length] = '\0';
+  }
 }
 
 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);
   return is_on ? 1 : 0;   // return an int, because C code doesn't have bool
 }
 
 extern "C" void HeapProfilerStop() {
   SpinLockHolder l(&heap_lock);
 
   if (!is_on) return;
 
   if (FLAGS_only_mmap_profile == false) {
     // Unset our new/delete hooks, checking they were set:
-    RAW_CHECK(MallocHook::RemoveNewHook(&NewHook), "");
+    if (pseudo_stack_generator) {
+      RAW_CHECK(MallocHook::RemoveNewHook(&PseudoStackNewHook), "");
+    } else {
+      RAW_CHECK(MallocHook::RemoveNewHook(&NewHook), "");
+    }
     RAW_CHECK(MallocHook::RemoveDeleteHook(&DeleteHook), "");
   }
   if (FLAGS_mmap_log) {
     // Restore mmap/sbrk hooks, checking that our hooks were set:
     RAW_CHECK(MallocHook::RemoveMmapHook(&MmapHook), "");
     RAW_CHECK(MallocHook::RemoveMremapHook(&MremapHook), "");
     RAW_CHECK(MallocHook::RemoveSbrkHook(&SbrkHook), "");
     RAW_CHECK(MallocHook::RemoveMunmapHook(&MunmapHook), "");
   }
 
@@ skipping 51 matching lines @@
 }
 
 extern "C" void HeapProfilerDumpAliveObjects(const char* filename) {
   SpinLockHolder l(&heap_lock);
 
   if (!is_on) return;
 
   heap_profile->DumpMarkedObjects(HeapProfileTable::MARK_TWO, filename);
 }
 
+extern "C" void SetPseudoStackGenerator(PseudoStackGenerator callback) {

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

The function name should contain HeapProfiler or something like that since the
function is in the global namespace.

Also, what happens when this function is called after HeapProfilerStart()?  What
happens when this function is called twice?  I think we should hide it, and have
HeapProfilerStartWithPseudoStack() or something like that.  Wdyt?

[James Cook, 2013/06/29 00:02:42]

Good idea. Done.

+  SpinLockHolder l(&heap_lock);
+  pseudo_stack_generator = callback;
+}
+
 //----------------------------------------------------------------------
 // Initialization/finalization code
 //----------------------------------------------------------------------
 
 // Initialization code
 static void HeapProfilerInit() {
   // Everything after this point is for setting up the profiler based on envvar
   char fname[PATH_MAX];
   if (!GetUniquePathFromEnv(HEAPPROFILE, fname)) {
     return;
@@ skipping 14 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;