Profiler Take 2

runtime/vm/profiler.h

 // Copyright (c) 2013, 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.
 
 #ifndef VM_PROFILER_H_
 #define VM_PROFILER_H_
 
-#include "platform/hashmap.h"
-#include "platform/thread.h"
 #include "vm/allocation.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
+#include "vm/thread.h"
+#include "vm/thread_interrupter.h"
 
 namespace dart {
 
 // Forward declarations.
+class JSONArray;
 class JSONStream;
+struct Sample;
 
-// Profiler manager.
-class ProfilerManager : public AllStatic {
+// Profiler
+class Profiler : public AllStatic {
  public:
   static void InitOnce();
   static void Shutdown();
 
-  static void SetupIsolateForProfiling(Isolate* isolate);
-  static void ShutdownIsolateForProfiling(Isolate* isolate);
-  static void ScheduleIsolate(Isolate* isolate, bool inside_signal = false);
-  static void DescheduleIsolate(Isolate* isolate);
+  static void InitProfilingForIsolate(Isolate* isolate,
+                                      bool shared_buffer = false);
+  static void ShutdownProfilingForIsolate(Isolate* isolate);
+
+  static void BeginExecution(Isolate* isolate);
+  static void EndExecution(Isolate* isolate);
 
   static void PrintToJSONStream(Isolate* isolate, JSONStream* stream);
 
-  static void WriteTracing(Isolate* isolate, const char* name, Dart_Port port);
+  static void WriteTracing(Isolate* isolate);
+
+  static SampleBuffer* sample_buffer() {
+    return sample_buffer_;
+  }
 
  private:
-  static const intptr_t kMaxProfiledIsolates = 4096;
   static bool initialized_;
-  static bool shutdown_;
-  static bool thread_running_;
   static Monitor* monitor_;
-  static Monitor* start_stop_monitor_;
 
-  static Isolate** isolates_;
-  static intptr_t isolates_capacity_;
-  static intptr_t isolates_size_;
+  static void WriteTracingSample(Isolate* isolate, intptr_t pid,
+                                 Sample* sample, JSONArray& events);
 
-  static void ScheduleIsolateHelper(Isolate* isolate);
-  static void ResizeIsolates(intptr_t new_capacity);
-  static void AddIsolate(Isolate* isolate);
-  static intptr_t FindIsolate(Isolate* isolate);
-  static void RemoveIsolate(intptr_t i);
+  static void RecordTickInterruptCallback(const InterruptedThreadState& state,
+                                          void* data);
 
-  // Returns the microseconds until the next live timer fires.
-  static int64_t SampleAndRescheduleIsolates(int64_t current_time);
-  static void FreeIsolateProfilingData(Isolate* isolate);
-  static void ThreadMain(uword parameters);
+  static void RecordSampleInterruptCallback(const InterruptedThreadState& state,
+                                            void* data);
+
+  static SampleBuffer* sample_buffer_;
 };
 
 
 class IsolateProfilerData {
  public:
-  static const int64_t kDescheduledCpuUsage = -1;
-  static const int64_t kNoExpirationTime = -2;
-
-  IsolateProfilerData(Isolate* isolate, SampleBuffer* sample_buffer);
+  IsolateProfilerData(SampleBuffer* sample_buffer, bool own_sample_buffer);
   ~IsolateProfilerData();
 
-  int64_t sample_interval_micros() const { return sample_interval_micros_; }
-
-  void set_sample_interval_micros(int64_t sample_interval) {
-    sample_interval_micros_ = sample_interval;
-  }
-
-  bool CanExpire() const {
-    return timer_expiration_micros_ != kNoExpirationTime;
-  }
-
-  bool ShouldSample(int64_t current_time) const {
-    return CanExpire() && TimeUntilExpiration(current_time) <= 0;
-  }
-
-  int64_t TimeUntilExpiration(int64_t current_time_micros) const {
-    ASSERT(CanExpire());
-    return timer_expiration_micros_ - current_time_micros;
-  }
-
-  void set_cpu_usage(int64_t cpu_usage) {
-    cpu_usage_ = cpu_usage;
-  }
-
-  void SampledAt(int64_t current_time);
-
-  void Scheduled(int64_t current_time, ThreadId thread);
-
-  void Descheduled();
-
-  int64_t cpu_usage() const { return cpu_usage_; }
-
-  int64_t ComputeDeltaAndSetCpuUsage(int64_t cpu_usage) {
-    int64_t delta = 0;
-    if (cpu_usage_ != kDescheduledCpuUsage) {
-      // Only compute the real delta if we are being sampled regularly.
-      delta = cpu_usage - cpu_usage_;
-    }
-    set_cpu_usage(cpu_usage);
-    return delta;
-  }
-
-  ThreadId thread_id() const { return thread_id_; }
-
-  Isolate* isolate() const { return isolate_; }
-
   SampleBuffer* sample_buffer() const { return sample_buffer_; }
 
   void set_sample_buffer(SampleBuffer* sample_buffer) {
     sample_buffer_ = sample_buffer;
   }
 
  private:
-  int64_t last_sampled_micros_;
-  int64_t timer_expiration_micros_;
-  int64_t sample_interval_micros_;
-  int64_t cpu_usage_;
-  ThreadId thread_id_;
-  Isolate* isolate_;
   SampleBuffer* sample_buffer_;
+  bool own_sample_buffer_;
   DISALLOW_COPY_AND_ASSIGN(IsolateProfilerData);
 };
 
 
 // Profile sample.
 struct Sample {
   static const char* kLookupSymbol;
   static const char* kNoSymbol;
-  static const intptr_t kNumStackFrames = 4;
-  enum SampleState {
-    kIdle = 0,
-    kExecuting = 1,
-    kNumSampleStates
+  static const char* kNoFrame;
+  static const intptr_t kNumStackFrames = 6;
+  enum SampleType {
+    kIsolateStart,
+    kIsolateStop,
+    kIsolateSample,
   };
   int64_t timestamp;
-  int64_t cpu_usage;
+  ThreadId tid;
+  Isolate* isolate;
   uintptr_t pcs[kNumStackFrames];
+  SampleType type;
   uint16_t vm_tags;
   uint16_t runtime_tags;
-  Sample();
+
+  void Init(SampleType type, Isolate* isolate, int64_t timestamp, ThreadId tid);
 };
 
 
-// Ring buffer of samples. One per isolate.
+// Ring buffer of samples.
 class SampleBuffer {
  public:
   static const intptr_t kDefaultBufferCapacity = 120000;  // 2 minutes @ 1000hz.
 
   explicit SampleBuffer(intptr_t capacity = kDefaultBufferCapacity);
   ~SampleBuffer();
 
   intptr_t capacity() const { return capacity_; }
 
   Sample* ReserveSample();
 
-  Sample* FirstSample() const;
-  Sample* NextSample(Sample* sample) const;
-  Sample* LastSample() const;
+  Sample* GetSample(intptr_t i) const {
+    ASSERT(i >= 0);
+    ASSERT(i < capacity_);
+    return &samples_[i];
+  }
+
  private:
   Sample* samples_;
   intptr_t capacity_;
-  intptr_t start_;
-  intptr_t end_;
+  uintptr_t cursor_;
 
-  intptr_t WrapIncrement(intptr_t i) const;
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
 
 class ProfilerSampleStackWalker : public ValueObject {
  public:
   ProfilerSampleStackWalker(Sample* sample,
                             uintptr_t stack_lower,
                             uintptr_t stack_upper,
                             uintptr_t pc,
@@ skipping 16 matching lines @@
   const uintptr_t original_pc_;
   const uintptr_t original_fp_;
   const uintptr_t original_sp_;
   uintptr_t lower_bound_;
 };
 
 
 }  // namespace dart
 
 #endif  // VM_PROFILER_H_