Emit symbol maps for compiled code for use by the Linux perf tool.

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 17 matching lines @@
 
 // Global state that stores the original working directory..
 static const char* original_working_directory = NULL;
 
 
 // Global state that stores the import URL map specified on the
 // command line.
 static CommandLineOptions* import_map_options = NULL;
 
 
+// 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 pprof symbol information is
 // to be generated or not.
 static const char* generate_pprof_symbols_filename = NULL;
 
 
 // Global state that stores a file name for flow graph debugging output.
 // NULL if no output is generated.
 static File* flow_graph_file = NULL;
 
 // Global state that indicates whether there is a debug breakpoint.
@@ skipping 73 matching lines @@
   if (debug_port == 0) {
     fprintf(stderr, "unrecognized --debug option syntax. "
                     "Use --debug[:<port number>]\n");
     return;
   }
   breakpoint_at = "main";
   start_debugger = true;
 }
 
 
+static void ProcessPerfEventsOption(const char* option) {
+  ASSERT(option != NULL);
+  if (perf_events_symbols_file == NULL) {
+#if defined(TARGET_OS_LINUX)
+    const char* format = "/tmp/perf-%ld.map";
+    intptr_t pid = Process::CurrentProcessId();
+    intptr_t len = snprintf(NULL, 0, format, pid);
+    char* filename = new char[len + 1];
+    snprintf(filename, len + 1, format, pid);
+    perf_events_symbols_file = File::Open(filename, File::kWriteTruncate);
+    ASSERT(perf_events_symbols_file != NULL);
+    delete[] filename;
+#endif

[siva, 2012/07/25 22:25:23]

Could you abstract this away into os.h as OpenPerfSymbolsFile or something like
that instead of a #if defined(..) over here.

Also you wouldn't need the CurrentProcessId function if this is abstracted out.

[cshapiro, 2012/07/25 22:52:54]

I do not feel good about that as Linux is the only platform that would ever
provide a functioning definition.  And, because of the File::Open call, that
definition cannot appear in VM-specific code.  Having a prototype in os.h and an
implementation somewhere under bin seems awkward, I doubt that is what you
intended in this comment.

As an aside, there are profilers, such as Intel's VTune and some Valgrind tools,
which run on more than one of our targets.  Putting definitions for these
targets in the global namespace seems justifiable.

[siva, 2012/07/25 23:19:52]

Sorry I meant platform.h which is in the 'bin' directory and not os.h

I would think it is ok to have empty unreachable methods on macos and win for
it.

On 2012/07/25 22:52:54, cshapiro wrote:

[cshapiro, 2012/07/26 00:14:19]

Per our off-line conversation, I will add a TODO reminding us to find a better
place for this code.

+  }
+}
+
+
 static void ProcessPprofOption(const char* filename) {
   ASSERT(filename != NULL);
   generate_pprof_symbols_filename = filename;
 }
 
 
 static void ProcessFlowGraphOption(const char* flowgraph_option) {
   ASSERT(flowgraph_option != NULL);
   flow_graph_file = File::Open("flowgraph.cfg", File::kWriteTruncate);
   ASSERT(flow_graph_file != NULL);
 }
 
 
 static void ProcessImportMapOption(const char* map) {
   ASSERT(map != NULL);
   import_map_options->AddArgument(map);
 }
 
 
 static struct {
   const char* option_name;
   void (*process)(const char* option);
 } main_options[] = {
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
+  { "--generate_perf_events_symbols", ProcessPerfEventsOption },
   { "--generate_pprof_symbols=", ProcessPprofOption },
   { "--import_map=", ProcessImportMapOption },
   { "--package-root=", ProcessPackageRootOption },
   { "--generate_flow_graph", ProcessFlowGraphOption },
   { 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) {
       main_options[i].process(option + length);
       return true;
     }
     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);
+}
+
+
 static void WriteToFlowGraphFile(const char* buffer, int64_t num_bytes) {
   ASSERT(flow_graph_file != NULL);
   flow_graph_file->WriteFully(buffer, num_bytes);
 }
 
 
 // Parse out the command line arguments. Returns -1 if the arguments
 // are incorrect, 0 otherwise.
 static int ParseArguments(int argc,
                           char** argv,
@@ skipping 19 matching lines @@
       const char* kPrintFlags1 = "--print-flags";
       const char* kPrintFlags2 = "--print_flags";
       if ((strncmp(argv[i], kPrintFlags1, strlen(kPrintFlags1)) == 0) ||
           (strncmp(argv[i], kPrintFlags2, strlen(kPrintFlags2)) == 0)) {
         *print_flags_seen = true;
       }
       vm_options->AddArgument(argv[i]);
       i++;
     }
   }
+
+  if (perf_events_symbols_file != NULL) {
+    Dart_InitPerfEventsSupport(&WriteToPerfEventsFile);
+  }
+
   if (generate_pprof_symbols_filename != NULL) {
     Dart_InitPprofSupport();
   }
 
   if (flow_graph_file != NULL) {
     Dart_InitFlowGraphPrinting(&WriteToFlowGraphFile);
   }
 
   // Get the script name.
   if (i < argc) {
@@ skipping 587 matching lines @@
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   free(const_cast<char*>(original_working_directory));
 
   return 0;
 }