Timeline service protocol support with Observatory UI

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/atomic.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
@@ skipping 66 matching lines @@
       (FLAG_timeline_dir != NULL) || FLAG_timing || FLAG_complete_timeline;
   if (use_endless_recorder) {
     recorder_ = new TimelineEventEndlessRecorder();
   } else if (use_ring_recorder) {
     recorder_ = new TimelineEventRingRecorder();
   }
   vm_stream_ = new TimelineStream();
   vm_stream_->Init("VM", EnableStreamByDefault("VM"), NULL);
   // Global overrides.
 #define ISOLATE_TIMELINE_STREAM_FLAG_DEFAULT(name, not_used)                   \
-  stream_##name##_enabled_ = false;
+  stream_##name##_enabled_ = EnableStreamByDefault(#name);
   ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_FLAG_DEFAULT)
 #undef ISOLATE_TIMELINE_STREAM_FLAG_DEFAULT
 }
 
 
 void Timeline::Shutdown() {
   ASSERT(recorder_ != NULL);
   if (FLAG_timeline_dir != NULL) {
     recorder_->WriteTo(FLAG_timeline_dir);
   }
   delete recorder_;
   recorder_ = NULL;
   delete vm_stream_;
   vm_stream_ = NULL;
 }
 
 
 TimelineEventRecorder* Timeline::recorder() {
   return recorder_;
 }
 
 
 bool Timeline::EnableStreamByDefault(const char* stream_name) {
   // TODO(johnmccutchan): Allow for command line control over streams.
-  return (FLAG_timeline_dir != NULL) || FLAG_timing;
+  return (FLAG_timeline_dir != NULL) || FLAG_timing || FLAG_complete_timeline;
 }
 
 
 TimelineStream* Timeline::GetVMStream() {
   ASSERT(vm_stream_ != NULL);
   return vm_stream_;
 }
 
 
 void Timeline::ReclaimCachedBlocksFromThreads() {
@@ skipping 11 matching lines @@
     TimelineEventBlock* block = thread->timeline_block();
     thread->set_timeline_block(NULL);
     // TODO(johnmccutchan): Consider dropping the timeline_block_lock here
     // if we can do it everywhere. This would simplify the lock ordering
     // requirements.
     recorder->FinishBlock(block);
   }
 }
 
 
+void Timeline::Clear() {
+  TimelineEventRecorder* recorder = Timeline::recorder();
+  if (recorder == NULL) {
+    return;
+  }
+  ReclaimCachedBlocksFromThreads();
+  recorder->Clear();
+}
+
+
 TimelineEventRecorder* Timeline::recorder_ = NULL;
 TimelineStream* Timeline::vm_stream_ = NULL;
 
 #define ISOLATE_TIMELINE_STREAM_DEFINE_FLAG(name, enabled_by_default)          \
-  bool Timeline::stream_##name##_enabled_ = false;
+  bool Timeline::stream_##name##_enabled_ = enabled_by_default;
   ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_DEFINE_FLAG)
 #undef ISOLATE_TIMELINE_STREAM_DEFINE_FLAG
 
 TimelineEvent::TimelineEvent()
     : timestamp0_(0),
       timestamp1_(0),
       arguments_(NULL),
       arguments_length_(0),
       state_(0),
       label_(NULL),
@@ skipping 465 matching lines @@
     : isolate_id_(isolate_id) {
 }
 
 
 TimelineEventRecorder::TimelineEventRecorder()
     : async_id_(0) {
 }
 
 
 void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
+  ThreadIterator it;
+  while (it.HasNext()) {
+    Thread* thread = it.Next();
+    const char* thread_name = thread->name();
+    if (thread_name == NULL) {
+      // Only emit a thread name if one was set.
+      continue;
+    }
+    JSONObject obj(events);
+    int64_t pid = OS::ProcessId();
+    int64_t tid = OSThread::ThreadIdToIntPtr(thread->trace_id());
+    obj.AddProperty("name", "thread_name");
+    obj.AddProperty("ph", "M");
+    obj.AddProperty64("pid", pid);
+    obj.AddProperty64("tid", tid);
+    {
+      JSONObject args(&obj, "args");
+      args.AddPropertyF("name", "%s (%" Pd64 ")", thread_name, tid);
+    }
+  }
 }
 
 
 TimelineEvent* TimelineEventRecorder::ThreadBlockStartEvent() {
   // Grab the current thread.
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   Mutex* thread_block_lock = thread->timeline_block_lock();
   ASSERT(thread_block_lock != NULL);
   // We are accessing the thread's timeline block- so take the lock here.
@@ skipping 132 matching lines @@
   for (intptr_t i = 0; i < num_blocks_; i++) {
     TimelineEventBlock* block = blocks_[i];
     delete block;
   }
   free(blocks_);
 }
 
 
 void TimelineEventRingRecorder::PrintJSONEvents(
     JSONArray* events,
-    TimelineEventFilter* filter) const {
+    TimelineEventFilter* filter) {
+  MutexLocker ml(&lock_);
   intptr_t block_offset = FindOldestBlockIndex();
   if (block_offset == -1) {
     // All blocks are empty.
     return;
   }
   for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
     TimelineEventBlock* block =
         blocks_[(block_idx + block_offset) % num_blocks_];
     if (!filter->IncludeBlock(block)) {
       continue;
     }
     for (intptr_t event_idx = 0; event_idx < block->length(); event_idx++) {
       TimelineEvent* event = block->At(event_idx);
       if (filter->IncludeEvent(event)) {
         events->AddValue(event);
       }
     }
   }
 }
 
 
 void TimelineEventRingRecorder::PrintJSON(JSONStream* js,
                                           TimelineEventFilter* filter) {
-  MutexLocker ml(&lock_);
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events, filter);
   }
 }
 
 
@@ skipping 15 matching lines @@
   if (block_cursor_ == num_blocks_) {
     block_cursor_ = 0;
   }
   TimelineEventBlock* block = blocks_[block_cursor_++];
   block->Reset();
   block->Open();
   return block;
 }
 
 
+void TimelineEventRingRecorder::Clear() {
+  MutexLocker ml(&lock_);
+  for (intptr_t i = 0; i < num_blocks_; i++) {
+    TimelineEventBlock* block = blocks_[i];
+    block->Reset();
+  }
+}
+
+
 intptr_t TimelineEventRingRecorder::FindOldestBlockIndex() const {
   int64_t earliest_time = kMaxInt64;
   intptr_t earliest_index = -1;
   for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
     TimelineEventBlock* block = blocks_[block_idx];
     if (block->IsEmpty()) {
       // Skip empty blocks.
       continue;
     }
     if (block->LowerTimeBound() < earliest_time) {
@@ skipping 60 matching lines @@
 
 
 TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
     : head_(NULL),
       block_index_(0) {
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js,
                                              TimelineEventFilter* filter) {
-  MutexLocker ml(&lock_);
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events, filter);
   }
 }
 
 
@@ skipping 33 matching lines @@
   head_ = block;
   if (FLAG_trace_timeline) {
     OS::Print("Created new block %p\n", block);
   }
   return head_;
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSONEvents(
     JSONArray* events,
-    TimelineEventFilter* filter) const {
+    TimelineEventFilter* filter) {
+  MutexLocker ml(&lock_);
   TimelineEventBlock* current = head_;
-
   while (current != NULL) {
     if (!filter->IncludeBlock(current)) {
       current = current->next();
       continue;
     }
     intptr_t length = current->length();
     for (intptr_t i = 0; i < length; i++) {
       TimelineEvent* event = current->At(i);
       if (!filter->IncludeEvent(event)) {
         continue;
@@ skipping 138 matching lines @@
 
 
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart