Endless thread safe timeline recorder

runtime/vm/timeline.cc

 // 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.
 
 #include <cstdlib>
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
+#include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, trace_timeline, false, "Timeline trace");
+DEFINE_FLAG(bool, trace_timeline, false, "Trace timeline code.");
+DEFINE_FLAG(bool, complete_timeline, false, "Record the complete timeline");
 
 TimelineEvent::TimelineEvent()
     : timestamp0_(0),
       timestamp1_(0),
       arguments_(NULL),
       arguments_length_(0),
       state_(0),
       label_(NULL),
       stream_(NULL),
       thread_(NULL) {
@@ skipping 396 matching lines @@
 
 void TimelineEventRingRecorder::PrintJSONEvents(JSONArray* events) const {
   for (intptr_t i = 0; i < capacity_; i++) {
     if (events_[i].IsValid()) {
       events->AddValue(&events_[i]);
     }
   }
 }
 
 
-void TimelineEventRingRecorder::PrintJSON(JSONStream* js) const {
+void TimelineEventRingRecorder::PrintJSON(JSONStream* js) {
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events);
   }
 }
 
 
@@ skipping 31 matching lines @@
 
 
 TimelineEventStreamingRecorder::TimelineEventStreamingRecorder() {
 }
 
 
 TimelineEventStreamingRecorder::~TimelineEventStreamingRecorder() {
 }
 
 
-void TimelineEventStreamingRecorder::PrintJSON(JSONStream* js) const {
+void TimelineEventStreamingRecorder::PrintJSON(JSONStream* js) {
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
   }
 }
 
 void TimelineEventStreamingRecorder::VisitObjectPointers(
     ObjectPointerVisitor* visitor) {
@@ skipping 12 matching lines @@
   TimelineEvent* event = new TimelineEvent();
   return event;
 }
 
 
 void TimelineEventStreamingRecorder::CompleteEvent(TimelineEvent* event) {
   StreamEvent(event);
   delete event;
 }
 
+
+TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
+    : head_(NULL) {
+  GetNewBlock();
+}
+
+
+void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js) {
+  MutexLocker ml(&lock_);
+  JSONObject topLevel(js);
+  topLevel.AddProperty("type", "_Timeline");
+  {
+    JSONArray events(&topLevel, "traceEvents");
+    PrintJSONMeta(&events);
+    PrintJSONEvents(&events);
+  }
+}
+
+
+TimelineEventBlock* TimelineEventEndlessRecorder::GetNewBlock() {
+  MutexLocker ml(&lock_);
+  return GetNewBlockLocked();
+}
+
+
+void TimelineEventEndlessRecorder::VisitObjectPointers(
+    ObjectPointerVisitor* visitor) {
+  // no-op.
+}
+
+
+TimelineEvent* TimelineEventEndlessRecorder::StartEvent(const Object& object) {
+  return StartEvent();
+}
+
+
+TimelineEvent* TimelineEventEndlessRecorder::StartEvent() {
+  // Grab the thread's timeline event block.
+  Thread* thread = Thread::Current();
+  TimelineEventBlock* thread_block = thread->timeline_block();
+  if (thread_block == NULL) {
+    return NULL;
+  }
+  ASSERT(thread_block != NULL);
+  if (thread_block->IsFull()) {
+    // If it is full, request a new block.
+    thread_block = GetNewBlock();
+    thread->set_timeline_block(thread_block);
+  }
+  ASSERT(!thread_block->IsFull());
+  return thread_block->StartEvent();
+}
+
+
+void TimelineEventEndlessRecorder::CompleteEvent(TimelineEvent* event) {
+  // no-op.
+}
+
+
+TimelineEventBlock* TimelineEventEndlessRecorder::GetNewBlockLocked() {
+  TimelineEventBlock* block = new TimelineEventBlock();
+  block->set_next(head_);
+  head_ = block;
+  return head_;
+}
+
+
+void TimelineEventEndlessRecorder::PrintJSONEvents(JSONArray* events) const {
+  TimelineEventBlock* current = head_;
+  while (current != NULL) {
+    intptr_t length = current->length();
+    for (intptr_t i = 0; i < length; i++) {
+      TimelineEvent* event = current->At(i);
+      if (!event->IsValid()) {
+        continue;
+      }
+      events->AddValue(event);
+    }
+    current = current->next();
+  }
+}
+
+
+TimelineEventBlock::TimelineEventBlock()
+    : next_(NULL),
+      length_(0) {
+}
+
+
+TimelineEvent* TimelineEventBlock::StartEvent() {
+  ASSERT(!IsFull());
+  return &events_[length_++];
+}
+
 }  // namespace dart