Support instruction-level perf event profiling to Dart VM using V8's ll_prof.py.

runtime/vm/os_linux.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 "vm/globals.h"
 #if defined(TARGET_OS_LINUX)
 
 #include "vm/os.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 14 matching lines @@
 
 
 namespace dart {
 
 // Linux CodeObservers.
 
 DEFINE_FLAG(bool, generate_gdb_symbols, false,
     "Generate symbols of generated dart functions for debugging with GDB");
 DEFINE_FLAG(bool, generate_perf_events_symbols, false,
     "Generate events symbols for profiling with perf");
+DEFINE_FLAG(bool, ll_prof, false,
+    "Generate compiled code log file for processing with ll_prof.py.");
 DEFINE_FLAG(charp, generate_pprof_symbols, NULL,
     "Writes pprof events symbols to the provided file");
 
+class LowLevelProfileCodeObserver : public CodeObserver {
+ public:
+  LowLevelProfileCodeObserver() {
+    Dart_FileOpenCallback file_open = Isolate::file_open_callback();
+    if (file_open == NULL) {
+      return;
+    }
+    const char* filename = "v8.log.ll";

[Vyacheslav Egorov (Google), 2013/02/26 14:19:25]

I like the name. 

You can consider making ll_prof.py more generic to handle both Dart and V8. 

You can also write the tag denoting type of the runtime into the stream.

+    log_file_ = (*file_open)(filename);
+#if defined(TARGET_ARCH_IA32)
+    const char arch[] = "ia32";
+#elif defined(TARGET_ARCH_X64)
+    const char arch[] = "x64";
+#elif defined(TARGET_ARCH_ARM)
+    const char arch[] = "arm";
+#elif defined(TARGET_ARCH_MIPS)
+    const char arch[] = "mips";
+#else
+    const char arch[] = "unknown";
+#endif
+    LowLevelLogWriteBytes(arch, sizeof(arch));
+  }
+
+  ~LowLevelProfileCodeObserver() {
+    Dart_FileCloseCallback file_close = Isolate::file_close_callback();
+    if (file_close == NULL) {
+      return;
+    }
+    ASSERT(log_file_ != NULL);
+    (*file_close)(log_file_);
+  }
+
+  virtual bool IsActive() const {
+    return FLAG_ll_prof;
+  }
+
+  struct LowLevelCodeCreateStruct {
+    static const char kTag = 'C';
+
+    intptr_t name_size;
+    uword code_address;
+    uword code_size;
+  };
+
+  template <typename T>
+  void LowLevelLogWriteStruct(const T& s) {

[Vyacheslav Egorov (Google), 2013/02/26 14:19:25]

There is only a single structure so for now we don't need templated version.

However I understand that this code was taken from the V8 where multiple events
exist.

+    char tag = T::kTag;
+    LowLevelLogWriteBytes(reinterpret_cast<const char*>(&tag), sizeof(tag));
+    LowLevelLogWriteBytes(reinterpret_cast<const char*>(&s), sizeof(s));
+  }
+
+  void LowLevelLogWriteBytes(const char* bytes, int size) {
+    Dart_FileWriteCallback file_write = Isolate::file_write_callback();
+    ASSERT(file_write != NULL);
+    (file_write)(bytes, size, log_file_);
+  }
+
+  virtual void Notify(const char* name,
+                      uword base,
+                      uword prologue_offset,
+                      uword size,
+                      bool optimized) {
+    const char* format = "%s%s";

[Vyacheslav Egorov (Google), 2013/02/26 14:24:17]

Use Zone::PrintToString here.

+    const char* marker = optimized ? "*" : "";
+    intptr_t len = OS::SNPrint(NULL, 0, format, marker, name);
+    char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+    OS::SNPrint(buffer, len + 1, format, marker, name);
+
+    LowLevelCodeCreateStruct event;
+    event.name_size = len;
+    event.code_address = base;
+    event.code_size = size;
+
+    LowLevelLogWriteStruct(event);
+    LowLevelLogWriteBytes(buffer, len);
+    LowLevelLogWriteBytes(reinterpret_cast<char*>(base), size);
+  }
+
+ private:
+  void* log_file_;
+
+  DISALLOW_COPY_AND_ASSIGN(LowLevelProfileCodeObserver);
+};
+
+
 class PerfCodeObserver : public CodeObserver {
  public:
   PerfCodeObserver() {
     Dart_FileOpenCallback file_open = Isolate::file_open_callback();
     if (file_open == NULL) {
       return;
     }
     const char* format = "/tmp/perf-%ld.map";
     intptr_t pid = getpid();
     intptr_t len = OS::SNPrint(NULL, 0, format, pid);
@@ skipping 323 matching lines @@
       (str[i + 2] != '\0')) {
     base = 16;
   }
   errno = 0;
   *value = strtoll(str, &endptr, base);
   return ((errno == 0) && (endptr != str) && (*endptr == 0));
 }
 
 
 void OS::RegisterCodeObservers() {
+  if (FLAG_ll_prof) {
+    CodeObservers::Register(new LowLevelProfileCodeObserver);
+  }
   if (FLAG_generate_perf_events_symbols) {
     CodeObservers::Register(new PerfCodeObserver);
   }
   if (FLAG_generate_gdb_symbols) {
     CodeObservers::Register(new GdbCodeObserver);
   }
   if (FLAG_generate_pprof_symbols != NULL) {
     CodeObservers::Register(new PprofCodeObserver);
   }
 #if defined(DART_VTUNE_SUPPORT)
@@ skipping 29 matching lines @@
 }
 
 
 void OS::Exit(int code) {
   exit(code);
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)