Initial Timeline Events

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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 "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 17 matching lines @@
 #include "vm/reusable_handles.h"
 #include "vm/service.h"
 #include "vm/service_event.h"
 #include "vm/service_isolate.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/thread_interrupter.h"
+#include "vm/timeline.h"
 #include "vm/timer.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_isolates, false,
             "Trace isolate creation and shut down.");
 DEFINE_FLAG(bool, pause_isolates_on_start, false,
             "Pause isolates before starting.");
@@ skipping 313 matching lines @@
   if (callback) {
     // Allow the embedder to handle message notification.
     (*callback)(Api::CastIsolate(I));
   }
 }
 
 
 bool IsolateMessageHandler::HandleMessage(Message* message) {
   StackZone zone(I);
   HandleScope handle_scope(I);
+  TimelineDurationScope tds(I, I->GetIsolateStream(), "HandleMessage");
+
   // TODO(turnidge): Rework collection total dart execution.  This can
   // overcount when other things (gc, compilation) are active.
   TIMERSCOPE(isolate_, time_dart_execution);
 
   // If the message is in band we lookup the handler to dispatch to.  If the
   // receive port was closed, we drop the message without deserializing it.
   // Illegal port is a special case for artificially enqueued isolate library
   // messages which are handled in C++ code below.
   Object& msg_handler = Object::Handle(I);
   if (!message->IsOOB() && (message->dest_port() != Message::kIllegalPort)) {
@@ skipping 274 matching lines @@
       edge_counter_increment_size_(-1),
       compiler_stats_(NULL),
       is_service_isolate_(false),
       log_(new class Log()),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       last_allocationprofile_accumulator_reset_timestamp_(0),
       last_allocationprofile_gc_timestamp_(0),
       object_id_ring_(NULL),
       trace_buffer_(NULL),
+      timeline_event_buffer_(NULL),
       profiler_data_(NULL),
       thread_state_(NULL),
       tag_table_(GrowableObjectArray::null()),
       current_tag_(UserTag::null()),
       default_tag_(UserTag::null()),
       deoptimized_code_array_(GrowableObjectArray::null()),
       metrics_list_head_(NULL),
       cha_(NULL),
       next_(NULL),
       pause_loop_monitor_(NULL),
@@ skipping 28 matching lines @@
   delete log_;
   log_ = NULL;
   delete object_id_ring_;
   object_id_ring_ = NULL;
   delete pause_loop_monitor_;
   pause_loop_monitor_ = NULL;
   if (compiler_stats_ != NULL) {
     delete compiler_stats_;
     compiler_stats_ = NULL;
   }
+  RemoveTimelineEventBuffer();
 }
 
 
 #if defined(DEBUG)
 bool Isolate::IsIsolateOf(Thread* thread) {
   return this == thread->isolate();
 }
 #endif  // DEBUG
 
 
 void Isolate::InitOnce() {
   create_callback_ = NULL;
   isolates_list_monitor_ = new Monitor();
   ASSERT(isolates_list_monitor_ != NULL);
 }
 
 
 Isolate* Isolate::Init(const char* name_prefix,
                        const Dart_IsolateFlags& api_flags,
                        bool is_vm_isolate) {
   Isolate* result = new Isolate(api_flags);
   ASSERT(result != NULL);
 
   // Initialize metrics.
 #define ISOLATE_METRIC_INIT(type, variable, name, unit)                        \
   result->metric_##variable##_.Init(result, name, NULL, Metric::unit);
   ISOLATE_METRIC_LIST(ISOLATE_METRIC_INIT);
 #undef ISOLATE_METRIC_INIT
 
+  // Initialize Timeline streams.
+#define ISOLATE_TIMELINE_STREAM_INIT(name, enabled_by_default)                 \
+  result->stream_##name##_.Init(#name, enabled_by_default);
+  ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_INIT);
+#undef ISOLATE_TIMELINE_STREAM_INIT
+
   // TODO(5411455): For now just set the recently created isolate as
   // the current isolate.
   Thread::EnterIsolate(result);
 
   // Setup the isolate specific resuable handles.
 #define REUSABLE_HANDLE_ALLOCATION(object)                                     \
   result->object##_handle_ = result->AllocateReusableHandle<object>();
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_ALLOCATION)
 #undef REUSABLE_HANDLE_ALLOCATION
 
@@ skipping 204 matching lines @@
   set_is_runnable(true);
   if (!ServiceIsolate::IsServiceIsolate(this)) {
     message_handler()->set_pause_on_start(FLAG_pause_isolates_on_start);
     message_handler()->set_pause_on_exit(FLAG_pause_isolates_on_exit);
   }
   IsolateSpawnState* state = spawn_state();
   if (state != NULL) {
     ASSERT(this == state->isolate());
     Run();
   }
+  TimelineStream* stream = GetIsolateStream();
+  ASSERT(stream != NULL);
+  TimelineEvent* event = stream->RecordEvent();
+  if (event != NULL) {
+    event->Instant(stream, "Runnable");
+  }
   return true;
 }
 
 
 bool Isolate::VerifyPauseCapability(const Object& capability) const {
   return !capability.IsNull() &&
       capability.IsCapability() &&
       (pause_capability() == Capability::Cast(capability).Id());
 }
 
@@ skipping 469 matching lines @@
     api_state()->weak_persistent_handles().VisitHandles(&visitor);
     api_state()->prologue_weak_persistent_handles().VisitHandles(&visitor);
 
     if (FLAG_trace_isolates) {
       heap()->PrintSizes();
       megamorphic_cache_table()->PrintSizes();
       Symbols::DumpStats();
       OS::Print("[-] Stopping isolate:\n"
                 "\tisolate:    %s\n", name());
     }
+
+    if (timeline_event_buffer_ != NULL) {

[rmacnak, 2015/06/10 20:25:14]

Behind a flag

[Cutch, 2015/06/10 21:20:57]

This will be gone before I commit.

+      timeline_event_buffer_->Dump();
+    }
   }
 
   // TODO(5411455): For now just make sure there are no current isolates
   // as we are shutting down the isolate.
   Thread::ExitIsolate();
   Profiler::ShutdownProfilingForIsolate(this);
 }
 
 
 Dart_IsolateCreateCallback Isolate::create_callback_ = NULL;
@@ skipping 78 matching lines @@
 }
 
 
 void Isolate::VisitPrologueWeakPersistentHandles(HandleVisitor* visitor) {
   if (api_state() != NULL) {
     api_state()->VisitPrologueWeakHandles(visitor);
   }
 }
 
 
+void Isolate::SetTimelineEventBuffer(
+    TimelineEventBuffer* timeline_event_buffer) {
+#define ISOLATE_TIMELINE_STREAM_SET_BUFFER(name, enabled_by_default)           \
+  stream_##name##_.set_buffer(timeline_event_buffer);
+  ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_SET_BUFFER)
+#undef ISOLATE_TIMELINE_STREAM_SET_BUFFER
+  timeline_event_buffer_ = timeline_event_buffer;
+}
+
+void Isolate::RemoveTimelineEventBuffer() {
+  SetTimelineEventBuffer(NULL);
+  delete timeline_event_buffer_;
+}
+
+
 void Isolate::PrintJSON(JSONStream* stream, bool ref) {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", (ref ? "@Isolate" : "Isolate"));
   jsobj.AddFixedServiceId("isolates/%" Pd "",
                           static_cast<intptr_t>(main_port()));
 
   jsobj.AddProperty("name", debugger_name());
   jsobj.AddPropertyF("number", "%" Pd "",
                      static_cast<intptr_t>(main_port()));
   if (ref) {
@@ skipping 463 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart