Refactor some Timeline interfaces to be simpler and support streaming

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/object.h"
 #include "vm/thread.h"
@@ skipping 22 matching lines @@
 
 void TimelineEvent::Reset() {
   set_event_type(kNone);
   thread_ = NULL;
   stream_ = NULL;
   label_ = NULL;
   FreeArguments();
 }
 
 
-int64_t TimelineEvent::AsyncBegin(TimelineStream* stream, const char* label) {
-  Init(kAsyncBegin, stream, label);
+int64_t TimelineEvent::AsyncBegin(const char* label) {
+  Init(kAsyncBegin, label);
   timestamp0_ = OS::GetCurrentTimeMicros();
-  int64_t async_id = stream->GetNextSeq();
+  ASSERT(stream_ != NULL);
+  int64_t async_id = stream_->GetNextSeq();
   // Overload timestamp1_ with the async_id.
   timestamp1_ = async_id;
   return async_id;
 }
 
 
-void TimelineEvent::AsyncInstant(TimelineStream* stream,
-                                 const char* label,
+void TimelineEvent::AsyncInstant(const char* label,
                                  int64_t async_id) {
-  Init(kAsyncInstant, stream, label);
+  Init(kAsyncInstant, label);
   timestamp0_ = OS::GetCurrentTimeMicros();
   // Overload timestamp1_ with the async_id.
   timestamp1_ = async_id;
 }
 
 
-void TimelineEvent::AsyncEnd(TimelineStream* stream,
-                             const char* label,
+void TimelineEvent::AsyncEnd(const char* label,
                              int64_t async_id) {
-  Init(kAsyncEnd, stream, label);
+  Init(kAsyncEnd, label);
   timestamp0_ = OS::GetCurrentTimeMicros();
   // Overload timestamp1_ with the async_id.
   timestamp1_ = async_id;
 }
 
 
-void TimelineEvent::DurationBegin(TimelineStream* stream, const char* label) {
-  Init(kDuration, stream, label);
+void TimelineEvent::DurationBegin(const char* label) {
+  Init(kDuration, label);
   timestamp0_ = OS::GetCurrentTimeMicros();
 }
 
 
 void TimelineEvent::DurationEnd() {
   timestamp1_ = OS::GetCurrentTimeMicros();
 }
 
 
-void TimelineEvent::Instant(TimelineStream* stream,
-                            const char* label) {
-  Init(kInstant, stream, label);
+void TimelineEvent::Instant(const char* label) {
+  Init(kInstant, label);
   timestamp0_ = OS::GetCurrentTimeMicros();
 }
 
 
-void TimelineEvent::Duration(TimelineStream* stream,
-                             const char* label,
+void TimelineEvent::Duration(const char* label,
                              int64_t start_micros,
                              int64_t end_micros) {
-  Init(kDuration, stream, label);
+  Init(kDuration, label);
   timestamp0_ = start_micros;
   timestamp1_ = end_micros;
 }
 
 
 void TimelineEvent::SetNumArguments(intptr_t length) {
   // Cannot call this twice.
   ASSERT(arguments_ == NULL);
   ASSERT(arguments_length_ == 0);
   arguments_length_ = length;
@@ skipping 29 matching lines @@
 }
 
 
 void TimelineEvent::CopyArgument(intptr_t i,
                                  const char* name,
                                  const char* argument) {
   SetArgument(i, name, strdup(argument));
 }
 
 
+void TimelineEvent::Complete() {
+  stream_->CompleteEvent(this);
+}
+
+
 void TimelineEvent::FreeArguments() {
   if (arguments_ == NULL) {
     return;
   }
   for (intptr_t i = 0; i < arguments_length_; i++) {
     free(arguments_[i].value);
   }
   free(arguments_);
   arguments_ = NULL;
   arguments_length_ = 0;
 }
 
+
+void TimelineEvent::StreamInit(TimelineStream* stream) {
+  ASSERT(stream != NULL);
+  stream_ = stream;
+}
+
+
 void TimelineEvent::Init(EventType event_type,
-                         TimelineStream* stream,
                          const char* label) {
-  ASSERT(stream != NULL);
   ASSERT(label != NULL);
   set_event_type(event_type);
   timestamp0_ = 0;
   timestamp1_ = 0;
   thread_ = Thread::Current();
-  stream_ = stream;
   label_ = label;
   FreeArguments();
 }
 
 
 static int64_t GetPid(Isolate* isolate) {
   // Some mapping from Isolate* to an integer process id.
   // TODO(Cutch): Investigate if process ids can be strings.
   return static_cast<int64_t>(reinterpret_cast<uintptr_t>(isolate));
 }
@@ skipping 68 matching lines @@
 int64_t TimelineEvent::TimeDuration() const {
   if (timestamp1_ == 0) {
     // This duration is still open, use current time as end.
     return OS::GetCurrentTimeMicros() - timestamp0_;
   }
   return timestamp1_ - timestamp0_;
 }
 
 
 TimelineStream::TimelineStream()
-    : buffer_(NULL),
+    : recorder_(NULL),
       name_(NULL),
       enabled_(false),
       seq_(0) {
 }
 
 
 void TimelineStream::Init(const char* name, bool enabled) {
   name_ = name;
   enabled_ = enabled;
 }
 
 
-TimelineEvent* TimelineStream::RecordEvent(const Object& obj) {
-  if (!enabled_ || (buffer_ == NULL)) {
+TimelineEvent* TimelineStream::StartEvent(const Object& obj) {
+  if (!enabled_ || (recorder_ == NULL)) {
     return NULL;
   }
   ASSERT(name_ != NULL);
-  ASSERT(buffer_ != NULL);
-  return buffer_->RecordEvent(obj);
+  ASSERT(recorder_ != NULL);
+  TimelineEvent* event = recorder_->StartEvent(obj);
+  if (event != NULL) {
+    event->StreamInit(this);
+  }
+  return event;
 }
 
 
-TimelineEvent* TimelineStream::RecordEvent() {
-  if (!enabled_ || (buffer_ == NULL)) {
+TimelineEvent* TimelineStream::StartEvent() {
+  if (!enabled_ || (recorder_ == NULL)) {
     return NULL;
   }
   ASSERT(name_ != NULL);
-  return buffer_->RecordEvent();
+  TimelineEvent* event = recorder_->StartEvent();
+  if (event != NULL) {
+    event->StreamInit(this);
+  }
+  return event;
 }
 
 
+void TimelineStream::CompleteEvent(TimelineEvent* event) {
+  if (!enabled_ || (recorder_ == NULL)) {
+    return;
+  }
+  recorder_->CompleteEvent(event);
+}
+
+
 int64_t TimelineStream::GetNextSeq() {
   seq_++;
   if (seq_ < 0) {
     seq_ = 0;
   }
   return seq_;
 }
 
 
 void TimelineDurationScope::FormatArgument(intptr_t i,
@@ skipping 10 matching lines @@
   char* buffer = reinterpret_cast<char*>(malloc(len + 1));
   va_list args2;
   va_start(args2, fmt);
   OS::VSNPrint(buffer, (len + 1), fmt, args2);
   va_end(args2);
 
   event_->SetArgument(i, name, buffer);
 }
 
 
-intptr_t TimelineEventBuffer::SizeForCapacity(intptr_t capacity) {
+TimelineEventRecorder::TimelineEventRecorder() {
+}
+
+
+void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
+  Isolate* isolate = Isolate::Current();
+  JSONObject obj(events);
+  int64_t pid = GetPid(isolate);
+  obj.AddProperty("ph", "M");
+  obj.AddProperty64("pid", pid);
+  obj.AddProperty("name", "process_name");
+  {
+    JSONObject args(&obj, "args");
+    args.AddProperty("name", isolate->debugger_name());
+  }
+}
+
+
+void TimelineEventRecorder::WriteTo(const char* directory) {
+  Isolate* isolate = Isolate::Current();
+
+  Dart_FileOpenCallback file_open = Isolate::file_open_callback();
+  Dart_FileWriteCallback file_write = Isolate::file_write_callback();
+  Dart_FileCloseCallback file_close = Isolate::file_close_callback();
+  if ((file_open == NULL) || (file_write == NULL) || (file_close == NULL)) {
+    return;
+  }
+
+  JSONStream js;
+  PrintJSON(&js);
+
+  const char* format = "%s/dart-timeline-%" Pd "-%" Pd ".json";
+  intptr_t pid = OS::ProcessId();
+  intptr_t len = OS::SNPrint(NULL, 0, format,
+                             directory, pid, isolate->main_port());
+  char* filename = isolate->current_zone()->Alloc<char>(len + 1);
+  OS::SNPrint(filename, len + 1, format,
+              directory, pid, isolate->main_port());
+  void* file = (*file_open)(filename, true);
+  if (file == NULL) {
+    OS::Print("Failed to write timeline file: %s\n", filename);
+    return;
+  }
+  (*file_write)(js.buffer()->buf(), js.buffer()->length(), file);
+  (*file_close)(file);
+}
+
+
+intptr_t TimelineEventRingRecorder::SizeForCapacity(intptr_t capacity) {
   return sizeof(TimelineEvent) * capacity;
 }
 
 
-TimelineEventBuffer::TimelineEventBuffer(intptr_t capacity)
+TimelineEventRingRecorder::TimelineEventRingRecorder(intptr_t capacity)
     : events_(NULL),
       event_objects_(Array::null()),
       cursor_(0),
       capacity_(capacity) {
   if (FLAG_trace_timeline) {
     // 32-bit: 262,144 bytes per isolate.
     // 64-bit: 393,216 bytes per isolate.
     // NOTE: Internal isolates (vm and service) do not have a timeline
     // event buffer.
-    OS::Print("TimelineEventBuffer is %" Pd " bytes (%" Pd " events)\n",
+    OS::Print("TimelineEventRingRecorder is %" Pd " bytes (%" Pd " events)\n",
               SizeForCapacity(capacity),
               capacity);
   }
   events_ =
       reinterpret_cast<TimelineEvent*>(calloc(capacity, sizeof(TimelineEvent)));
   const Array& array = Array::Handle(Array::New(capacity, Heap::kOld));
   event_objects_ = array.raw();
 }
 
 
-TimelineEventBuffer::~TimelineEventBuffer() {
+TimelineEventRingRecorder::~TimelineEventRingRecorder() {
   for (intptr_t i = 0; i < capacity_; i++) {
     // Clear any extra data.
     events_[i].Reset();
   }
   free(events_);
   event_objects_ = Array::null();
 }
 
 
-void TimelineEventBuffer::PrintJSONMeta(JSONArray* events) const {
-  Isolate* isolate = Isolate::Current();
-  JSONObject obj(events);
-  int64_t pid = GetPid(isolate);
-  obj.AddProperty("ph", "M");
-  obj.AddProperty64("pid", pid);
-  obj.AddProperty("name", "process_name");
-  {
-    JSONObject args(&obj, "args");
-    args.AddProperty("name", isolate->debugger_name());
-  }
-}
-
-
-void TimelineEventBuffer::PrintJSONEvents(JSONArray* events) const {
+void TimelineEventRingRecorder::PrintJSONEvents(JSONArray* events) const {
   for (intptr_t i = 0; i < capacity_; i++) {
     if (events_[i].IsValid()) {
       events->AddValue(&events_[i]);
     }
   }
 }
 
 
-void TimelineEventBuffer::PrintJSON(JSONStream* js) const {
+void TimelineEventRingRecorder::PrintJSON(JSONStream* js) const {
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events);
   }
 }
 
 
-void TimelineEventBuffer::WriteTo(const char* directory) {
-  Isolate* isolate = Isolate::Current();
-
-  Dart_FileOpenCallback file_open = Isolate::file_open_callback();
-  Dart_FileWriteCallback file_write = Isolate::file_write_callback();
-  Dart_FileCloseCallback file_close = Isolate::file_close_callback();
-  if ((file_open == NULL) || (file_write == NULL) || (file_close == NULL)) {
-    return;
-  }
-
-  JSONStream js;
-  PrintJSON(&js);
-
-  const char* format = "%s/dart-timeline-%" Pd "-%" Pd ".json";
-  intptr_t pid = OS::ProcessId();
-  intptr_t len = OS::SNPrint(NULL, 0, format,
-                             directory, pid, isolate->main_port());
-  char* filename = isolate->current_zone()->Alloc<char>(len + 1);
-  OS::SNPrint(filename, len + 1, format,
-              directory, pid, isolate->main_port());
-  void* file = (*file_open)(filename, true);
-  if (file == NULL) {
-    OS::Print("Failed to write timeline file: %s\n", filename);
-    return;
-  }
-  (*file_write)(js.buffer()->buf(), js.buffer()->length(), file);
-  (*file_close)(file);
-}
-
-
-intptr_t TimelineEventBuffer::GetNextIndex() {
+intptr_t TimelineEventRingRecorder::GetNextIndex() {
   uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
   return cursor % capacity_;
 }
 
 
-void TimelineEventBuffer::VisitObjectPointers(ObjectPointerVisitor* visitor) {
+void TimelineEventRingRecorder::VisitObjectPointers(
+    ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&event_objects_));
 }
 
 
-TimelineEvent* TimelineEventBuffer::RecordEvent(const Object& obj) {
+TimelineEvent* TimelineEventRingRecorder::StartEvent(const Object& obj) {
   ASSERT(events_ != NULL);
   uintptr_t index = GetNextIndex();
   const Array& event_objects = Array::Handle(event_objects_);
   event_objects.SetAt(index, obj);
   return &events_[index];
 }
 
 
-TimelineEvent* TimelineEventBuffer::RecordEvent() {
+TimelineEvent* TimelineEventRingRecorder::StartEvent() {
   ASSERT(events_ != NULL);
   uintptr_t index = GetNextIndex();
   return &events_[index];
 }
 
+void TimelineEventRingRecorder::CompleteEvent(TimelineEvent* event) {
+  ASSERT(events_ != NULL);
+  // no-op.
+}
+
+
+TimelineEventStreamingRecorder::TimelineEventStreamingRecorder() {
+}
+
+
+TimelineEventStreamingRecorder::~TimelineEventStreamingRecorder() {
+}
+
+
+void TimelineEventStreamingRecorder::PrintJSON(JSONStream* js) const {
+  JSONObject topLevel(js);
+  topLevel.AddProperty("type", "_Timeline");
+  {
+    JSONArray events(&topLevel, "traceEvents");
+    PrintJSONMeta(&events);
+  }
+}
+
+void TimelineEventStreamingRecorder::VisitObjectPointers(
+    ObjectPointerVisitor* visitor) {
+  // no-op.
+}
+
+
+TimelineEvent* TimelineEventStreamingRecorder::StartEvent(
+    const Object& object) {
+  // The streaming recorder does not track Dart objects.
+  return StartEvent();
+}
+
+
+TimelineEvent* TimelineEventStreamingRecorder::StartEvent() {
+  TimelineEvent* event = new TimelineEvent();
+  return event;
+}
+
+
+void TimelineEventStreamingRecorder::CompleteEvent(TimelineEvent* event) {
+  StreamEvent(event);
+  delete event;
+}
+
 }  // namespace dart