Start TimelineAnalysis utility

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 RawArray;
 class Thread;
 class TimelineEvent;
 class TimelineEventBlock;
 class TimelineEventRecorder;
 class TimelineStream;
 
 // You should get a |TimelineEvent| from a |TimelineStream|.
 class TimelineEvent {
  public:
@@ skipping 52 matching lines @@
   EventType event_type() const {
     return EventTypeField::decode(state_);
   }
 
   int64_t TimeOrigin() const;
   int64_t AsyncId() const;
   int64_t TimeDuration() const;
 
   void PrintJSON(JSONStream* stream) const;
 
+  ThreadId thread() const {
+    return thread_;
+  }
+
  private:
   struct TimelineEventArgument {
     const char* name;
     char* value;
   };
 
   int64_t timestamp0_;
   int64_t timestamp1_;
   TimelineEventArgument* arguments_;
   intptr_t arguments_length_;
@@ skipping 173 matching lines @@
     return next_;
   }
   void set_next(TimelineEventBlock* next) {
     next_ = next;
   }
 
   intptr_t length() const {
     return length_;
   }
 
+  bool IsEmpty() const {
+    return length_ == 0;
+  }
+
   bool IsFull() const {
     return length_ == kBlockSize;
   }
 
   TimelineEvent* At(intptr_t index) {
     ASSERT(index >= 0);
     ASSERT(index < kBlockSize);
     return &events_[index];
   }
 
+  // Attempt to sniff a thread id from the first event.
+  ThreadId thread() const;
+  // Attempt to sniff the timestamp from the first event.
+  int64_t LowerTimeBound() const;
+
+  // Returns false if |this| violates any of the following invariants:
+  // - events in the block come from one thread.
+  // - events have monotonically increasing timestamps.
+  bool CheckBlock();
+
  protected:
   TimelineEvent* StartEvent();
 
   TimelineEvent events_[kBlockSize];
   TimelineEventBlock* next_;
   intptr_t length_;
 
   friend class TimelineEventEndlessRecorder;
+  friend class TimelineTestHelper;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventBlock);
 };
 
 
 // Recorder of |TimelineEvent|s.
 class TimelineEventRecorder {
  public:
   TimelineEventRecorder();
@@ skipping 22 matching lines @@
   friend class TimelineStream;
   friend class Isolate;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventRecorder);
 };
 
 
 // A recorder that stores events in a ring buffer of fixed capacity.
 // This recorder does track Dart objects.
+// TODO(johnmccutchan): Make this recorder use event blocks too.
 class TimelineEventRingRecorder : public TimelineEventRecorder {
  public:
   static const intptr_t kDefaultCapacity = 8192;
 
   static intptr_t SizeForCapacity(intptr_t capacity);
 
   explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity);
   ~TimelineEventRingRecorder();
 
   void PrintJSON(JSONStream* js);
@@ skipping 61 matching lines @@
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
   TimelineEvent* StartEvent(const Object& object);
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
 
   TimelineEventBlock* GetNewBlockLocked();
   void PrintJSONEvents(JSONArray* array) const;
 
   Mutex lock_;
   TimelineEventBlock* head_;
+
+  friend class TimelineEventBlockIterator;
+};
+
+
+// An iterator for blocks.
+class TimelineEventBlockIterator {
+ public:
+  explicit TimelineEventBlockIterator(TimelineEventEndlessRecorder* recorder);
+  ~TimelineEventBlockIterator();
+
+  void Reset();
+  bool Next();
+
+  TimelineEventBlock* current() const {
+    return current_;
+  }
+
+ private:
+  TimelineEventBlock* current_;
+  TimelineEventEndlessRecorder* recorder_;
 };
 
 }  // namespace dart
 
 #endif  // VM_TIMELINE_H_