Add Timeline to dart:developer

runtime/vm/timeline.h

 // Copyright (c) 2015, 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_TIMELINE_H_
 #define VM_TIMELINE_H_
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 
 namespace dart {
 
 class JSONArray;
 class JSONObject;
 class JSONStream;
 class Object;
 class ObjectPointerVisitor;
+class Isolate;
 class RawArray;
 class Thread;
 class TimelineEvent;
 class TimelineEventBlock;
 class TimelineEventRecorder;
 class TimelineStream;
+class Zone;
 
 // (name, enabled by default for isolate).
 #define ISOLATE_TIMELINE_STREAM_LIST(V)                                        \
   V(API, false)                                                                \
   V(Compiler, false)                                                           \
+  V(Dart, false)                                                               \
   V(Embedder, false)                                                           \
   V(GC, false)                                                                 \
   V(Isolate, false)                                                            \
 
 class Timeline : public AllStatic {
  public:
   // Initialize timeline system. Not thread safe.
   static void InitOnce();
 
   // Shutdown timeline system. Not thread safe.
@@ skipping 158 matching lines @@
   const char* category_;
   ThreadId thread_;
   Isolate* isolate_;
 
   void FreeArguments();
 
   void StreamInit(TimelineStream* stream);
   void Init(EventType event_type, const char* label);
 
   void set_event_type(EventType event_type) {
+    // We only reserve 4 bits to hold the event type.
+    COMPILE_ASSERT(kNumEventTypes < 16);
     state_ = EventTypeField::update(event_type, state_);
   }
 
   enum StateBits {
     kEventTypeBit = 0,
     // reserve 4 bits for type.
     kNextBit = 4,
   };
 
   class EventTypeField : public BitField<EventType, kEventTypeBit, 4> {};
@@ skipping 256 matching lines @@
     // Not empty, not in use, and isolate match.
     return !block->IsEmpty() && !block->in_use() &&
            (block->isolate() == isolate_);
   }
 
  private:
   Isolate* isolate_;
 };
 
 
+// Timeline events from Dart code are eagerly converted to JSON and stored
+// as a C string.
+class DartTimelineEvent {
+ public:
+  DartTimelineEvent();
+  ~DartTimelineEvent();
+
+  void Clear();
+
+  // This function makes a copy of |event|.
+  void Init(Isolate* isolate, const char* event);
+
+  bool IsValid() const {
+    return (isolate_ != NULL) &&
+           (event_as_json_ != NULL);
+  }
+
+  Isolate* isolate() const {
+    return isolate_;
+  }
+
+  char* event_as_json() const {
+    return event_as_json_;
+  }
+
+ private:
+  Isolate* isolate_;
+  char* event_as_json_;
+
+  DISALLOW_COPY_AND_ASSIGN(DartTimelineEvent);
+};
+
+
 // Recorder of |TimelineEvent|s.
 class TimelineEventRecorder {
  public:
   TimelineEventRecorder();
   virtual ~TimelineEventRecorder() {}
 
   TimelineEventBlock* GetNewBlock();
 
   // Interface method(s) which must be implemented.
   virtual void PrintJSON(JSONStream* js, TimelineEventFilter* filter) = 0;
   virtual void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter) = 0;
 
   int64_t GetNextAsyncId();
 
   void FinishBlock(TimelineEventBlock* block);
 
+  // Interface method(s) which must be implemented.
+  virtual void AppendDartEvent(Isolate* isolate, const char* event) = 0;
+
  protected:
   void WriteTo(const char* directory);
 
   // Interface method(s) which must be implemented.
   virtual TimelineEvent* StartEvent() = 0;
   virtual void CompleteEvent(TimelineEvent* event) = 0;
   virtual TimelineEventBlock* GetHeadBlockLocked() = 0;
   virtual TimelineEventBlock* GetNewBlockLocked(Isolate* isolate) = 0;
+  virtual intptr_t NumDartEventsLocked() = 0;
+  virtual DartTimelineEvent* DartEventAtLocked(intptr_t i) = 0;
 
   // Utility method(s).
   void PrintJSONMeta(JSONArray* array) const;
   TimelineEvent* ThreadBlockStartEvent();
   TimelineEvent* GlobalBlockStartEvent();
 
   Mutex lock_;
   // Only accessed under |lock_|.
   TimelineEventBlock* global_block_;
   void ReclaimGlobalBlock();
 
   uintptr_t async_id_;
 
+  friend class DartTimelineEventIterator;
   friend class TimelineEvent;
   friend class TimelineEventBlockIterator;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   friend class Timeline;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventRecorder);
 };
 
 
 // A recorder that stores events in a ring buffer of fixed capacity.
 class TimelineEventRingRecorder : public TimelineEventRecorder {
  public:
   static const intptr_t kDefaultCapacity = 8192;
 
   explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity);
   ~TimelineEventRingRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
+  void AppendDartEvent(Isolate* isolate, const char* event);
+
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetHeadBlockLocked();
   intptr_t FindOldestBlockIndex() const;
   TimelineEventBlock* GetNewBlockLocked(Isolate* isolate);
+  intptr_t NumDartEventsLocked();
+  DartTimelineEvent* DartEventAtLocked(intptr_t i);
 
   void PrintJSONEvents(JSONArray* array, TimelineEventFilter* filter) const;
 
   TimelineEventBlock** blocks_;
   intptr_t capacity_;
   intptr_t num_blocks_;
   intptr_t block_cursor_;
+
+  DartTimelineEvent** dart_events_;
+  intptr_t dart_events_capacity_;
+  intptr_t dart_events_cursor_;
 };
 
 
 // An abstract recorder that calls |StreamEvent| whenever an event is complete.
 class TimelineEventStreamingRecorder : public TimelineEventRecorder {
  public:
   TimelineEventStreamingRecorder();
   ~TimelineEventStreamingRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
+  void AppendDartEvent(Isolate* isolate, const char* event);
+
   // Called when |event| is ready to be streamed. It is unsafe to keep a
   // reference to |event| as it may be freed as soon as this function returns.
   virtual void StreamEvent(TimelineEvent* event) = 0;
+  virtual void StreamDartEvent(const char* event) = 0;
 
  protected:
   TimelineEventBlock* GetNewBlockLocked(Isolate* isolate) {
     return NULL;
   }
   TimelineEventBlock* GetHeadBlockLocked() {
     return NULL;
   }
+  intptr_t NumDartEventsLocked();
+  DartTimelineEvent* DartEventAtLocked(intptr_t i);
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
 };
 
 
 // A recorder that stores events in chains of blocks of events.
 // NOTE: This recorder will continue to allocate blocks until it exhausts
 // memory.
 class TimelineEventEndlessRecorder : public TimelineEventRecorder {
  public:
   TimelineEventEndlessRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
+  void AppendDartEvent(Isolate* isolate, const char* event);
+
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetNewBlockLocked(Isolate* isolate);
   TimelineEventBlock* GetHeadBlockLocked();
+  intptr_t NumDartEventsLocked();
+  DartTimelineEvent* DartEventAtLocked(intptr_t i);
 
   void PrintJSONEvents(JSONArray* array, TimelineEventFilter* filter) const;
 
   // Useful only for testing. Only works for one thread.
   void Clear();
 
   TimelineEventBlock* head_;
   intptr_t block_index_;
 
+  DartTimelineEvent** dart_events_;
+  intptr_t dart_events_capacity_;
+  intptr_t dart_events_cursor_;
+
   friend class TimelineTestHelper;
 };
 
 
 // An iterator for blocks.
 class TimelineEventBlockIterator {
  public:
   explicit TimelineEventBlockIterator(TimelineEventRecorder* recorder);
   ~TimelineEventBlockIterator();
 
   void Reset(TimelineEventRecorder* recorder);
 
   // Returns false when there are no more blocks.
   bool HasNext() const;
 
   // Returns the next block and moves forward.
   TimelineEventBlock* Next();
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
+
+// An iterator for timeline events.
+class DartTimelineEventIterator {
+ public:
+  explicit DartTimelineEventIterator(TimelineEventRecorder* recorder);
+  ~DartTimelineEventIterator();
+
+  void Reset(TimelineEventRecorder* recorder);
+
+  // Returns true if there is another event.
+  bool HasNext() const;
+
+  // Returns the next event and moves forward.
+  DartTimelineEvent* Next();
+
+  // Returns a zone allocated string of all trace events for isolate.
+  // If isolate is NULL, all isolates' events will be included.
+  static const char* PrintTraceEvents(TimelineEventRecorder* recorder,
+                                      Zone* zone,
+                                      Isolate* isolate);
+
+ private:
+  intptr_t cursor_;
+  intptr_t num_events_;
+  TimelineEventRecorder* recorder_;
+};
+
 }  // namespace dart
 
 #endif  // VM_TIMELINE_H_