Move generate_perf_events_symbols flag to VM (new issue with @google address)

runtime/vm/code_observers.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/code_observers.h"
 
 #include "vm/dart.h"
 #include "vm/debuginfo.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/os.h"
 #include "vm/vtune.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 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");
 
 intptr_t CodeObservers::observers_length_ = 0;
 CodeObserver** CodeObservers::observers_ = NULL;
 
 
 void CodeObservers::Register(CodeObserver* observer) {
   observers_length_++;
   observers_ = reinterpret_cast<CodeObserver**>(
       realloc(observers_, sizeof(observer) * observers_length_));
   if (observers_ == NULL) {
@@ skipping 20 matching lines @@
 bool CodeObservers::AreActive() {
   for (intptr_t i = 0; i < observers_length_; i++) {
     if (observers_[i]->IsActive()) return true;
   }
   return false;
 }
 
 
 class PerfCodeObserver : public CodeObserver {
  public:
+  PerfCodeObserver() {
+    Dart_FileOpenCallback file_open = Isolate::file_open_callback();
+    if (file_open == NULL) {
+      return;
+    }
+// TODO(7321): Move OS-specific code for perf profiling to the OS abstraction
+#if defined(TARGET_OS_LINUX)
+    const char* format = "/tmp/perf-%ld.map";
+    intptr_t pid = getpid();
+    intptr_t len = OS::SNPrint(NULL, 0, format, pid);
+    char* filename = new char[len + 1];
+    OS::SNPrint(filename, len + 1, format, pid);
+    out_file_ = (*file_open)(filename);
+#endif
+  }
+
+  // Not currently being called
+  ~PerfCodeObserver() {
+    Dart_FileCloseCallback file_close = Isolate::file_close_callback();
+    if (file_close == NULL) {
+      return;
+    }
+    ASSERT(out_file_ != NULL);
+    (*file_close)(out_file_);
+  }
+
   virtual bool IsActive() const {
-    return Dart::perf_events_file() != NULL;
+    return FLAG_generate_perf_events_symbols;
   }
 
   virtual void Notify(const char* name,
                       uword base,
                       uword prologue_offset,
                       uword size,
                       bool optimized) {
+    Dart_FileWriteCallback file_write = Isolate::file_write_callback();
+    ASSERT(file_write != NULL);
     const char* format = "%"Px" %"Px" %s%s\n";
     const char* marker = optimized ? "*" : "";
     intptr_t len = OS::SNPrint(NULL, 0, format, base, size, marker, name);
     char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
     OS::SNPrint(buffer, len + 1, format, base, size, marker, name);
-    Dart_FileWriteCallback file_write = Isolate::file_write_callback();
-    ASSERT(file_write != NULL);
-    void* file = Dart::perf_events_file();
-    ASSERT(file != NULL);
-    (*file_write)(buffer, len, file);
+    ASSERT(out_file_ != NULL);
+    (*file_write)(buffer, len, out_file_);
   }
+
+ private:
+  void* out_file_;
 };
 
 
 class PprofCodeObserver : public CodeObserver {
  public:
   virtual bool IsActive() const {
     return Dart::pprof_symbol_generator() != NULL;
   }
 
   virtual void Notify(const char* name,
@@ skipping 35 matching lines @@
                                  (base + prologue_offset),
                                  (size - prologue_offset));
     } else {
       DebugInfo::RegisterSection(name, base, size);
     }
   }
 };
 
 
 void CodeObservers::InitOnce() {
-  Register(new PerfCodeObserver);
+// TODO(7321): Move flag registration to the OS abstraction
+  if (FLAG_generate_perf_events_symbols) {
+    Register(new PerfCodeObserver);
+  }
   Register(new PprofCodeObserver);
   Register(new GdbCodeObserver);
 #if defined(DART_VTUNE_SUPPORT)
   Register(new VTuneCodeObserver);
 #endif
 }
 
 
 }  // namespace dart