Add --timing

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"
+#include "vm/log.h"
 #include "vm/object.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, trace_timeline, false, "Trace timeline backend");
 DEFINE_FLAG(bool, complete_timeline, false, "Record the complete timeline");
-
+DEFINE_FLAG(bool, trace_timeline, false,
+            "Trace timeline backend");
+DEFINE_FLAG(bool, trace_timeline_analysis, false,
+            "Trace timeline analysis backend");
+DEFINE_FLAG(bool, timing, false,
+            "Dump isolate timing information from timeline.");
 DEFINE_FLAG(charp, timeline_dir, NULL,
             "Enable all timeline trace streams and output VM global trace "
             "into specified directory.");
 
 void Timeline::InitOnce() {
   ASSERT(recorder_ == NULL);
   // Default to ring recorder being enabled.
   const bool use_ring_recorder = true;
   // Some flags require that we use the endless recorder.
-  const bool use_endless_recorder = (FLAG_timeline_dir != NULL);
+  const bool use_endless_recorder =
+      (FLAG_timeline_dir != NULL) || FLAG_timing;
   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"));
 }
 
 
 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;
+  return (FLAG_timeline_dir != NULL) || FLAG_timing;
 }
 
 
 TimelineStream* Timeline::GetVMStream() {
   ASSERT(vm_stream_ != NULL);
   return vm_stream_;
 }
 
 
 TimelineEventRecorder* Timeline::recorder_ = NULL;
@@ skipping 333 matching lines @@
     ASSERT(!thread_block->IsFull());
     return thread_block->StartEvent();
   }
   return NULL;
 }
 
 
 
 TimelineEvent* TimelineEventRecorder::GlobalBlockStartEvent() {
   MutexLocker ml(&lock_);
+  if (FLAG_trace_timeline) {
+    OS::Print("GlobalBlockStartEvent in block %p for thread %" Px "\n",
+              global_block_, OSThread::CurrentCurrentThreadIdAsIntPtr());
+  }
   if ((global_block_ != NULL) && global_block_->IsFull()) {
     // Global block is full.
     global_block_->Finish();
     global_block_ = NULL;
   }
   if (global_block_ == NULL) {
     // Allocate a new block.
     global_block_ = GetNewBlockLocked(NULL);
+    ASSERT(global_block_ != NULL);
   }
   if (global_block_ != NULL) {
     ASSERT(!global_block_->IsFull());
     return global_block_->StartEvent();
   }
   return NULL;
 }
 
 
 void TimelineEventRecorder::WriteTo(const char* directory) {
@@ skipping 194 matching lines @@
 
 void TimelineEventStreamingRecorder::CompleteEvent(TimelineEvent* event) {
   StreamEvent(event);
   delete event;
 }
 
 
 TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
     : head_(NULL),
       block_index_(0) {
-  GetNewBlock();
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js,
                                              TimelineEventFilter* filter) {
   MutexLocker ml(&lock_);
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
@@ skipping 17 matching lines @@
   // no-op.
 }
 
 
 TimelineEventBlock* TimelineEventEndlessRecorder::GetNewBlockLocked(
     Isolate* isolate) {
   TimelineEventBlock* block = new TimelineEventBlock(block_index_++);
   block->set_next(head_);
   block->Open(isolate);
   head_ = block;
+  if (FLAG_trace_timeline) {
+    if (isolate != NULL) {
+      OS::Print("Created new isolate block %p for %s\n",
+                block, isolate->name());
+    } else {
+      OS::Print("Created new global block %p\n", block);
+    }
+  }
   return head_;
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSONEvents(
     JSONArray* events,
     TimelineEventFilter* filter) const {
   TimelineEventBlock* current = head_;
 
   while (current != NULL) {
@@ skipping 35 matching lines @@
 }
 
 
 TimelineEventBlock::~TimelineEventBlock() {
   Reset();
 }
 
 
 TimelineEvent* TimelineEventBlock::StartEvent() {
   ASSERT(!IsFull());
+  if (FLAG_trace_timeline) {
+    OS::Print("StartEvent in block %p for thread %" Px "\n",
+              this, OSThread::CurrentCurrentThreadIdAsIntPtr());
+  }
   return &events_[length_++];
 }
 
 
 ThreadId TimelineEventBlock::thread() const {
   ASSERT(length_ > 0);
   return events_[0].thread();
 }
 
 
@@ skipping 40 matching lines @@
 }
 
 
 void TimelineEventBlock::Open(Isolate* isolate) {
   isolate_ = isolate;
   open_ = true;
 }
 
 
 void TimelineEventBlock::Finish() {
+  if (FLAG_trace_timeline) {
+    OS::Print("Finish block %p\n", this);
+  }
   open_ = false;
 }
 
 
 TimelineEventBlockIterator::TimelineEventBlockIterator(
     TimelineEventRecorder* recorder)
     : current_(NULL),
       recorder_(NULL) {
   Reset(recorder);
 }
@@ skipping 28 matching lines @@
 
 
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart