Use list of isolates in profiler

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 "lib/mirrors.h"
@@ skipping 297 matching lines @@
       gc_prologue_callbacks_(),
       gc_epilogue_callbacks_(),
       defer_finalization_count_(0),
       deopt_context_(NULL),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       object_histogram_(NULL),
       cha_used_(false),
       object_id_ring_(NULL),
       profiler_data_(NULL),
+      thread_state_(NULL),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
-      reusable_handles_() {
+      reusable_handles_(),
+      next_(NULL) {
   if (FLAG_print_object_histogram && (Dart::vm_isolate() != NULL)) {
     object_histogram_ = new ObjectHistogram(this);
   }
 }
 #undef REUSABLE_HANDLE_INITIALIZERS
 
 
 Isolate::~Isolate() {
   delete [] name_;
   delete heap_;
   delete object_store_;
   delete api_state_;
   delete stub_code_;
   delete debugger_;
 #if defined(USING_SIMULATOR)
   delete simulator_;
 #endif
   delete mutex_;
   mutex_ = NULL;  // Fail fast if interrupts are scheduled on a dead isolate.
   delete message_handler_;
   message_handler_ = NULL;  // Fail fast if we send messages to a dead isolate.
   ASSERT(deopt_context_ == NULL);  // No deopt in progress when isolate deleted.
   delete object_histogram_;
   delete spawn_state_;
 }
 
+
 void Isolate::SetCurrent(Isolate* current) {
   Isolate* old_current = Current();
-  if (old_current != current) {
+  if (old_current != NULL) {
+    old_current->set_thread_state(NULL);
     Profiler::EndExecution(old_current);
-    Thread::SetThreadLocal(isolate_key, reinterpret_cast<uword>(current));
+  }
+  Thread::SetThreadLocal(isolate_key, reinterpret_cast<uword>(current));
+  if (current != NULL) {
+    ASSERT(current->thread_state() == NULL);
+    InterruptableThreadState* thread_state =
+        ThreadInterrupter::GetCurrentThreadState();
+#if defined(DEBUG)
+    CheckForDuplicateThreadState(thread_state);
+#endif
     Profiler::BeginExecution(current);
+    current->set_thread_state(thread_state);
   }
 }
 
 
 // The single thread local key which stores all the thread local data
 // for a thread. Since an Isolate is the central repository for
 // storing all isolate specific information a single thread local key
 // is sufficient.
 ThreadLocalKey Isolate::isolate_key = Thread::kUnsetThreadLocalKey;
 
 
 void Isolate::InitOnce() {
   ASSERT(isolate_key == Thread::kUnsetThreadLocalKey);
   isolate_key = Thread::CreateThreadLocal();
   ASSERT(isolate_key != Thread::kUnsetThreadLocalKey);
   create_callback_ = NULL;
+  isolates_monitor_ = new Monitor();
+  ASSERT(isolates_monitor_ != NULL);
 }
 
 
 Isolate* Isolate::Init(const char* name_prefix) {
   Isolate* result = new Isolate();
   ASSERT(result != NULL);
 
   // Setup for profiling.
   Profiler::InitProfilingForIsolate(result);
 
+  // Add to isolate list.
+  IsolateCreated(result);
+
   // TODO(5411455): For now just set the recently created isolate as
   // the current isolate.
   SetCurrent(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 354 matching lines @@
       megamorphic_cache_table()->PrintSizes();
       Symbols::DumpStats();
       OS::Print("[-] Stopping isolate:\n"
                 "\tisolate:    %s\n", name());
     }
   }
 
   // TODO(5411455): For now just make sure there are no current isolates
   // as we are shutting down the isolate.
   SetCurrent(NULL);
+  IsolateShutdown(this);
   Profiler::ShutdownProfilingForIsolate(this);
 }
 
 
 Dart_IsolateCreateCallback Isolate::create_callback_ = NULL;
 Dart_IsolateInterruptCallback Isolate::interrupt_callback_ = NULL;
 Dart_IsolateUnhandledExceptionCallback
     Isolate::unhandled_exception_callback_ = NULL;
 Dart_IsolateShutdownCallback Isolate::shutdown_callback_ = NULL;
 Dart_FileOpenCallback Isolate::file_open_callback_ = NULL;
 Dart_FileReadCallback Isolate::file_read_callback_ = NULL;
 Dart_FileWriteCallback Isolate::file_write_callback_ = NULL;
 Dart_FileCloseCallback Isolate::file_close_callback_ = NULL;
 Dart_EntropySource Isolate::entropy_source_callback_ = NULL;
 Dart_IsolateInterruptCallback Isolate::vmstats_callback_ = NULL;
 Dart_ServiceIsolateCreateCalback Isolate::service_create_callback_ = NULL;
 
+Monitor* Isolate::isolates_monitor_ = NULL;
+Isolate* Isolate::isolates_head_ = NULL;
+
+
 void Isolate::VisitObjectPointers(ObjectPointerVisitor* visitor,
                                   bool visit_prologue_weak_handles,
                                   bool validate_frames) {
   ASSERT(visitor != NULL);
 
   // Visit objects in the object store.
   object_store()->VisitObjectPointers(visitor);
 
   // Visit objects in the class table.
   class_table()->VisitObjectPointers(visitor);
@@ skipping 80 matching lines @@
   }
 
   const Library& lib =
       Library::Handle(object_store()->root_library());
   jsobj.AddProperty("rootLib", lib);
 
   timer_list().PrintTimersToJSONProperty(&jsobj);
 }
 
 
+void Isolate::VisitIsolates(IsolateVisitor* visitor) {
+  if (visitor == NULL) {
+    return;
+  }
+  MonitorLocker ml(isolates_monitor_);
+  Isolate* current = isolates_head_;
+  while (current) {
+    visitor->VisitIsolate(current);
+    current = current->next_;
+  }
+}
+
+
+void Isolate::IsolateCreated(Isolate* isolate) {
+  MonitorLocker ml(isolates_monitor_);
+  ASSERT(isolate != NULL);
+  ASSERT(isolate->next_ == NULL);
+  isolate->next_ = isolates_head_;
+  isolates_head_ = isolate;
+}
+
+
+void Isolate::IsolateShutdown(Isolate* isolate) {
+  MonitorLocker ml(isolates_monitor_);
+  ASSERT(isolate != NULL);
+  Isolate* previous = NULL;
+  Isolate* current = isolates_head_;
+  while (current) {
+    if (current == isolate) {
+      if (current == isolates_head_) {
+        isolates_head_ = current->next_;
+      } else {
+        ASSERT(previous != NULL);
+        previous->next_ = current->next_;
+      }
+      return;
+    }
+    previous = current;
+    current = current->next_;
+  }

[siva, 2014/02/06 00:37:24]

Might be more efficient to write this as:

if (isolate == isolates_head_) {
  isolates_head_ = isolates_head_->next_;
  return;
}
Isolate* previous = isolates_head_;
Isolate* current = isolates_head_->next_;
while (current) {
  if (isolate == current) {
    ASSERT(previous != NULL);
    previous->next_ = current->next_;
    return;
  }
  previous = current;
  current = current->next_;
}
UNREACHABLE();

[Cutch, 2014/02/06 17:51:51]

Done.

+  UNREACHABLE();
+}
+
+
+#if defined(DEBUG)
+void Isolate::CheckForDuplicateThreadState(InterruptableThreadState* state) {
+  MonitorLocker ml(isolates_monitor_);
+  ASSERT(state != NULL);
+  Isolate* current = isolates_head_;
+  while (current) {
+    ASSERT(current->thread_state() != state);
+    current = current->next_;
+  }
+}
+#endif
+
+
 template<class T>
 T* Isolate::AllocateReusableHandle() {
   T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
   T::initializeHandle(handle, T::null());
   return handle;
 }
 
 
 IsolateSpawnState::IsolateSpawnState(const Function& func)
     : isolate_(NULL),
@@ skipping 92 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(isolate());
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart