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 202 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(const char* reason, 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.
     if (deep_profile) {
       bytes_written = deep_profile->FillOrderedProfile(reason, buf, buflen - 1);
+    } else 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';
@@ skipping 121 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) {
+  // 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) {
+  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';
 }
@@ skipping 11 matching lines @@
   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) {
+  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;