Switch to a VM wide timeline recorder

runtime/vm/dart.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/dart.h"
 
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/freelist.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/metrics.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/object_id_ring.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/service_isolate.h"
 #include "vm/simulator.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/thread_interrupter.h"
 #include "vm/thread_pool.h"
-#include "vm/timeline.h"
 #include "vm/virtual_memory.h"
 #include "vm/zone.h"
 
 namespace dart {
 
-DECLARE_FLAG(bool, complete_timeline);
 DECLARE_FLAG(bool, print_class_table);
 DECLARE_FLAG(bool, trace_isolates);
 DEFINE_FLAG(bool, keep_code, false,
             "Keep deoptimized code for profiling.");
 
 Isolate* Dart::vm_isolate_ = NULL;
 ThreadPool* Dart::thread_pool_ = NULL;
 DebugInfo* Dart::pprof_symbol_generator_ = NULL;
 ReadOnlyHandles* Dart::predefined_handles_ = NULL;
 
@@ skipping 33 matching lines @@
                            Dart_EntropySource entropy_source) {
   // TODO(iposva): Fix race condition here.
   if (vm_isolate_ != NULL || !Flags::Initialized()) {
     return "VM already initialized or flags not initialized.";
   }
   Isolate::SetFileCallbacks(file_open, file_read, file_write, file_close);
   Isolate::SetEntropySourceCallback(entropy_source);
   OS::InitOnce();
   VirtualMemory::InitOnce();
   Thread::InitOnceBeforeIsolate();
+  Timeline::InitOnce();
+  Thread::EnsureInit();
+  TimelineDurationScope tds(Timeline::GetVMStream(),
+                            "Dart::InitOnce");
   Isolate::InitOnce();
   PortMap::InitOnce();
   FreeListElement::InitOnce();
   Api::InitOnce();
   CodeObservers::InitOnce();
   ThreadInterrupter::InitOnce();
   Profiler::InitOnce();
   SemiSpace::InitOnce();
   Metric::InitOnce();
   StoreBuffer::InitOnce();
+  Thread::EnsureInit();

[Ivan Posva, 2015/08/21 02:25:38]

Shouldn't this be called ReallyEnsureInit? Since it is called the second time...

 
 #if defined(USING_SIMULATOR)
   Simulator::InitOnce();
 #endif
   // Create the read-only handles area.
   ASSERT(predefined_handles_ == NULL);
   predefined_handles_ = new ReadOnlyHandles();
   // Create the VM isolate and finish the VM initialization.
   ASSERT(thread_pool_ == NULL);
   thread_pool_ = new ThreadPool();
@@ skipping 99 matching lines @@
   Dart_ExitScope();
 
   ShutdownIsolate();
   vm_isolate_ = NULL;
 
   TargetCPUFeatures::Cleanup();
 #endif
 
   Profiler::Shutdown();
   CodeObservers::DeleteAll();
+  Timeline::Shutdown();
 
   return NULL;
 }
 
 
 Isolate* Dart::CreateIsolate(const char* name_prefix,
                              const Dart_IsolateFlags& api_flags) {
   // Create a new isolate.
   Isolate* isolate = Isolate::Init(name_prefix, api_flags);
   ASSERT(isolate != NULL);
   return isolate;
 }
 
 
 RawError* Dart::InitializeIsolate(const uint8_t* snapshot_buffer, void* data) {
   // Initialize the new isolate.
   Isolate* isolate = Isolate::Current();
   TIMERSCOPE(isolate, time_isolate_initialization);
+  TimelineDurationScope tds(isolate,
+                            isolate->GetIsolateStream(),
+                            "InitializeIsolate");
+  tds.SetNumArguments(1);
+  tds.CopyArgument(0, "isolateName", isolate->name());
+
   ASSERT(isolate != NULL);
   StackZone zone(isolate);
   HandleScope handle_scope(isolate);
-  ObjectStore::Init(isolate);
+  {
+    TimelineDurationScope tds(isolate,
+                              isolate->GetIsolateStream(),
+                              "ObjectStore::Init");
+    ObjectStore::Init(isolate);
+  }
 
   // Setup for profiling.
   Profiler::InitProfilingForIsolate(isolate);
 
   const Error& error = Error::Handle(Object::Init(isolate));
   if (!error.IsNull()) {
     return error.raw();
   }
   if (snapshot_buffer != NULL) {
     // Read the snapshot and setup the initial state.
-
+    TimelineDurationScope tds(isolate,
+                              isolate->GetIsolateStream(),
+                              "IsolateSnapshotReader");
     // TODO(turnidge): Remove once length is not part of the snapshot.
     const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_buffer);
     if (snapshot == NULL) {
       const String& message = String::Handle(
           String::New("Invalid snapshot."));
       return ApiError::New(message);
     }
     ASSERT(snapshot->kind() == Snapshot::kFull);
     if (FLAG_trace_isolates) {
       OS::Print("Size of isolate snapshot = %" Pd "\n", snapshot->length());
@@ skipping 13 matching lines @@
   } else {
     // Populate the isolate's symbol table with all symbols from the
     // VM isolate. We do this so that when we generate a full snapshot
     // for the isolate we have a unified symbol table that we can then
     // read into the VM isolate.
     Symbols::AddPredefinedSymbolsToIsolate();
   }
 
   Object::VerifyBuiltinVtables();
 
-  StubCode::Init(isolate);
+  {
+    TimelineDurationScope tds(isolate,
+                              isolate->GetIsolateStream(),
+                              "StubCode::Init");
+    StubCode::Init(isolate);
+  }
+
   isolate->megamorphic_cache_table()->InitMissHandler();
   if (snapshot_buffer == NULL) {
     if (!isolate->object_store()->PreallocateObjects()) {
       return isolate->object_store()->sticky_error();
     }
   }
 
   isolate->heap()->EnableGrowthControl();
   isolate->set_init_callback_data(data);
   Api::SetupAcquiredError(isolate);
   if (FLAG_print_class_table) {
     isolate->class_table()->Print();
   }
 
   ServiceIsolate::MaybeInjectVMServiceLibrary(isolate);
 
   ServiceIsolate::SendIsolateStartupMessage();
   isolate->debugger()->NotifyIsolateCreated();
 
   // Create tag table.
   isolate->set_tag_table(
       GrowableObjectArray::Handle(GrowableObjectArray::New()));
   // Set up default UserTag.
   const UserTag& default_tag = UserTag::Handle(UserTag::DefaultTag());
   isolate->set_current_tag(default_tag);
 
-  if (FLAG_complete_timeline) {
-    isolate->SetTimelineEventRecorder(new TimelineEventEndlessRecorder());
-  } else {
-    isolate->SetTimelineEventRecorder(new TimelineEventRingRecorder());
-  }
-
-
   if (FLAG_keep_code) {
     isolate->set_deoptimized_code_array(
       GrowableObjectArray::Handle(GrowableObjectArray::New()));
   }
   return Error::null();
 }
 
 
 void Dart::RunShutdownCallback() {
   Isolate* isolate = Isolate::Current();
@@ skipping 32 matching lines @@
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 
 bool Dart::IsReadOnlyApiHandle(Dart_Handle handle) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->api_handles_.IsValidHandle(handle);
 }
 
 }  // namespace dart