Merge the Merlin heap tracing to top-of-trunk.

runtime/bin/main.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 14 matching lines @@
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
 
 // Global state that indicates whether perf_events symbol information
 // is to be generated or not.
 static File* perf_events_symbols_file = NULL;
 
 
+// Global state that indicates whether heap tracing is on.
+static bool heap_trace = false;
+
+
+// Global state that indicates the file name prefix to use for heap
+// trace output files.
+static const char* heap_trace_file_prefix = "dart_heap_trace";
+
+
 // Global state that indicates whether pprof symbol information is
 // to be generated or not.
 static const char* generate_pprof_symbols_filename = NULL;
 
 
 // Global state that stores a pointer to the application script snapshot.
 static bool use_script_snapshot = false;
 static File* snapshot_file = NULL;
 
 // Global state that indicates whether there is a debug breakpoint.
@@ skipping 128 matching lines @@
 }
 
 
 static bool ProcessPprofOption(const char* filename) {
   ASSERT(filename != NULL);
   generate_pprof_symbols_filename = filename;
   return true;
 }
 
 
+static bool ProcessHeapTraceOption(const char* heap_trace_option) {
+  heap_trace = true;
+  return true;
+}
+
+
+static bool ProcessHeapTraceFilePrefixOption(
+    const char* heap_trace_file_prefix_option) {
+  ASSERT(heap_trace_file_prefix_option != NULL);
+  heap_trace_file_prefix = heap_trace_file_prefix_option;
+  return true;
+}
+
+
 static bool ProcessScriptSnapshotOption(const char* filename) {
   if (filename != NULL && strlen(filename) != 0) {
     use_script_snapshot = true;
     snapshot_file = File::Open(filename, File::kRead);
   }
   return true;
 }
 
 
 static struct {
   const char* option_name;
   bool (*process)(const char* option);
 } main_options[] = {
   // Standard options shared with dart2js.
   { "--version", ProcessVersionOption },
   { "--help", ProcessHelpOption },
   { "-h", ProcessHelpOption },
   { "--verbose", ProcessVerboseOption },
   { "-v", ProcessVerboseOption },
   { "--package-root=", ProcessPackageRootOption },
   { "-p", ProcessPackageRootOption },
   // VM specific options to the standalone dart program.
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
   { "--generate_perf_events_symbols", ProcessPerfEventsOption },
   { "--generate_pprof_symbols=", ProcessPprofOption },
+  { "--heap_trace", ProcessHeapTraceOption },
+  { "--heap_trace_file_prefix=", ProcessHeapTraceFilePrefixOption },
   { "--use_script_snapshot=", ProcessScriptSnapshotOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   while (name != NULL) {
     int length = strlen(name);
     if (strncmp(option, name, length) == 0) {
       return main_options[i].process(option + length);
     }
     i += 1;
     name = main_options[i].option_name;
   }
   return false;
 }
 
 
 static void WriteToPerfEventsFile(const char* buffer, int64_t num_bytes) {
   ASSERT(perf_events_symbols_file != NULL);
   perf_events_symbols_file->WriteFully(buffer, num_bytes);
 }
 
+
+// This function used by the heap trace to open new trace files, one
+// file per isolate.
+static void* OpenHeapTraceFile(const char* name) {
+  File* file = File::Open(name, File::kWriteTruncate);
+  ASSERT(file != NULL);
+  return reinterpret_cast<void*>(file);
+}
+
+
+// Function used by the heap trace to write to trace files.
+static void WriteToHeapTraceFile(const void* buffer,
+                                 intptr_t num_bytes,
+                                 void* stream) {
+  ASSERT(stream != NULL);
+  File* file_stream = reinterpret_cast<File*>(stream);
+  bool bytes_written = file_stream->WriteFully(buffer, num_bytes);
+  ASSERT(bytes_written);
+}
+
+
+// Function used by the heap trace to close trace files.
+static void CloseHeapTraceFile(void* stream) {
+  File* file_stream = reinterpret_cast<File*>(stream);
+  delete file_stream;  // Closes the file.
+}
+
+
 // Convert all the arguments to UTF8. On Windows, the arguments are
 // encoded in the current code page and not UTF8.
 //
 // Returns true if the arguments are converted. In that case
 // each of the arguments need to be deallocated using free.
 static bool Utf8ConvertArgv(int argc, char** argv) {
   bool result = false;
   for (int i = 0; i < argc; i++) {
     char* arg = argv[i];
     argv[i] = StringUtils::SystemStringToUtf8(arg);
@@ skipping 46 matching lines @@
   }
 
   if (perf_events_symbols_file != NULL) {
     Dart_InitPerfEventsSupport(&WriteToPerfEventsFile);
   }
 
   if (generate_pprof_symbols_filename != NULL) {
     Dart_InitPprofSupport();
   }
 
+  if (heap_trace) {
+    Dart_InitHeapTrace(&OpenHeapTraceFile,
+                       &WriteToHeapTraceFile,
+                       &CloseHeapTraceFile,
+                       heap_trace_file_prefix);
+  }
+
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
     i++;
   } else {
     return -1;
   }
 
   // Parse out options to be passed to dart main.
   while (i < argc) {
@@ skipping 464 matching lines @@
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) free(argv[i]);
   }
 
   return 0;
 }