Get a filename of dumped heap profile in a V8 extension HeapProfilerDump().

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 254 matching lines @@
   char* buffer = reinterpret_cast<char*>(malloc(kProfileBufferSize));
   SpinLockHolder l(&heap_lock);
   return DoGetHeapProfileLocked(buffer, kProfileBufferSize);
 }
 
 // defined below
 static void NewHook(const void* ptr, size_t size);
 static void DeleteHook(const void* ptr);
 
 // Helper for HeapProfilerDump.
-static void DumpProfileLocked(const char* reason) {
+static void DumpProfileLocked(const char* reason,
+                              char* filename_buffer,
+                              int filename_buffer_length) {

[jar (doing other things), 2013/02/14 23:30:09]

nit: int-->size_t

[Dai Mikurube (NOT FULLTIME), 2013/02/15 03:30:42]

Done.

Hmm, int and size_t are mixed for size-like values in this file. ;)

   RAW_DCHECK(heap_lock.IsHeld(), "");
   RAW_DCHECK(is_on, "");
   RAW_DCHECK(!dumping, "");
 
   if (filename_prefix == NULL) return;  // we do not yet need dumping
 
   dumping = true;
 
   // Make file name
-  char file_name[1000];
   dump_count++;
-  snprintf(file_name, sizeof(file_name), "%s.%05d.%04d%s",
+  snprintf(filename_buffer, filename_buffer_length, "%s.%05d.%04d%s",
            filename_prefix, getpid(), dump_count, HeapProfileTable::kFileExt);
 
   // Dump the profile
-  RAW_VLOG(0, "Dumping heap profile to %s (%s)", file_name, reason);
+  RAW_VLOG(0, "Dumping heap profile to %s (%s)", filename_buffer, reason);
   // We must use file routines that don't access memory, since we hold
   // a memory lock now.
-  RawFD fd = RawOpenForWriting(file_name);
+  RawFD fd = RawOpenForWriting(filename_buffer);
   if (fd == kIllegalRawFD) {
-    RAW_LOG(ERROR, "Failed dumping heap profile to %s", file_name);
+    RAW_LOG(ERROR, "Failed dumping heap profile to %s", filename_buffer);
     dumping = false;
     return;
   }
 
   // This case may be impossible, but it's best to be safe.
   // It's safe to use the global buffer: we're protected by heap_lock.
   if (global_profiler_buffer == NULL) {
     global_profiler_buffer =
         reinterpret_cast<char*>(ProfilerMalloc(kProfileBufferSize));
   }
 
   char* profile = DoGetHeapProfileLocked(global_profiler_buffer,
                                          kProfileBufferSize);
   RawWrite(fd, profile, strlen(profile));
   RawClose(fd);
 
 #if defined(TYPE_PROFILING)
   if (FLAGS_heap_profile_type_statistics) {
-    snprintf(file_name, sizeof(file_name), "%s.%05d.%04d.type",
+    snprintf(filename_buffer, filename_buffer_length, "%s.%05d.%04d.type",
              filename_prefix, getpid(), dump_count);
-    RAW_VLOG(0, "Dumping type statistics to %s", file_name);
-    heap_profile->DumpTypeStatistics(file_name);
+    RAW_VLOG(0, "Dumping type statistics to %s", filename_buffer);
+    heap_profile->DumpTypeStatistics(filename_buffer);
   }
 #endif  // defined(TYPE_PROFILING)
 
   dumping = false;
 }
 
 //----------------------------------------------------------------------
 // Profile collection
 //----------------------------------------------------------------------
 
@@ skipping 28 matching lines @@
       need_to_dump = true;
     } else if (FLAGS_heap_profile_time_interval > 0 &&
                current_time - last_dump_time >=
                FLAGS_heap_profile_time_interval) {
       snprintf(buf, sizeof(buf), "%d sec since the last dump",
                current_time - last_dump_time);
       need_to_dump = true;
       last_dump_time = current_time;
     }
     if (need_to_dump) {
-      DumpProfileLocked(buf);
+      char filename_buffer[1000];
+      DumpProfileLocked(buf, filename_buffer, sizeof(filename_buffer));
 
       last_dump_alloc = total.alloc_size;
       last_dump_free = total.free_size;
       if (inuse_bytes > high_water_mark)
         high_water_mark = inuse_bytes;
     }
   }
 }
 
 // Record an allocation in the profile.
@@ skipping 234 matching lines @@
   if (FLAGS_mmap_profile) {
     MemoryRegionMap::Shutdown();
   }
 
   is_on = false;
 }
 
 extern "C" void HeapProfilerDump(const char* reason) {
   SpinLockHolder l(&heap_lock);
   if (is_on && !dumping) {
-    DumpProfileLocked(reason);
+    char filename_buffer[1000];
+    DumpProfileLocked(reason, filename_buffer, sizeof(filename_buffer));
   }
 }
 
+extern "C" void HeapProfilerDumpWithFileName(const char* reason,
+                                             char* dumped_filename_buffer,
+                                             int filename_buffer_length) {
+  SpinLockHolder l(&heap_lock);
+  if (is_on && !dumping) {
+    DumpProfileLocked(reason, dumped_filename_buffer, filename_buffer_length);
+  }
+}
+
 extern "C" void HeapProfilerMarkBaseline() {
   SpinLockHolder l(&heap_lock);
 
   if (!is_on) return;
 
   heap_profile->MarkCurrentAllocations(HeapProfileTable::MARK_ONE);
 }
 
 extern "C" void HeapProfilerMarkInteresting() {
   SpinLockHolder l(&heap_lock);
@@ skipping 38 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;