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 296 matching lines @@
       is_runnable_(false),
       gc_prologue_callbacks_(),
       gc_epilogue_callbacks_(),
       defer_finalization_count_(0),
       deopt_context_(NULL),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       object_histogram_(NULL),
       object_id_ring_(NULL),
       profiler_data_(NULL),
+      thread_state_(NULL),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
       reusable_handles_() {
   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) {

[siva, 2014/02/05 19:09:15]

We also need
ASSERT(current->thread_state() == NULL);

[Cutch, 2014/02/05 23:00:31]

Done.

+#if defined(DEBUG)
+    CheckNoIsolateHasThreadData(ThreadInterrupter::GetCurrentThreadState());
+#endif
     Profiler::BeginExecution(current);
+    current->set_thread_state(ThreadInterrupter::GetCurrentThreadState());

[siva, 2014/02/05 19:09:15]

Why not have a local variable
InterruptibleThreadState* current_thread_state =
ThreadInterrupter::GetCurrentThreadState();

and use that local in the two spots.

[Cutch, 2014/02/05 23:00:31]

Done.

   }
 }
 
 
 // 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_ = NULL;
+intptr_t Isolate::isolates_capacity_ = 0;
+intptr_t Isolate::isolates_size_ = 0;
+
 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::IsolateCreated(Isolate* isolate) {
+  MonitorLocker ml(isolates_monitor_);
+  // Not currently registered in the isolates list.
+  ASSERT(FindIsolateIndex(isolate) < 0);
+  if (isolates_size_ == isolates_capacity_) {
+    // Full, grow isolates array.
+    ResizeIsolates(isolates_capacity_ == 0 ? 16 : isolates_capacity_ * 2);
+  }
+  // Add isolate to table.
+  isolates_[isolates_size_] = isolate;
+  isolates_size_++;
+}
+
+
+void Isolate::IsolateShutdown(Isolate* isolate) {
+  MonitorLocker ml(isolates_monitor_);
+  intptr_t index = FindIsolateIndex(isolate);
+  ASSERT(index >= 0);
+  intptr_t last = isolates_size_ - 1;
+  if (index != last) {
+    isolates_[index] = isolates_[last];
+  }
+  isolates_[last] = NULL;
+  isolates_size_--;
+}
+
+
+void Isolate::ResizeIsolates(intptr_t new_capacity) {
+  // Must be called with isolates_monitor_ locked.
+  ASSERT(new_capacity > isolates_capacity_);
+  isolates_ = reinterpret_cast<Isolate**>(
+      realloc(isolates_, sizeof(*isolates_) * new_capacity));
+  for (intptr_t i = isolates_capacity_; i < new_capacity; i++) {
+    isolates_[i] = NULL;
+  }
+  isolates_capacity_ = new_capacity;
+}

[siva, 2014/02/05 19:09:15]

See comment on using a linked list for isolates list.

+
+
+intptr_t Isolate::FindIsolateIndex(Isolate* isolate) {
+  // Must be called with isolates_monitor_ locked.
+  for (intptr_t i = 0; i < isolates_size_; i++) {
+    if (isolates_[i] == isolate) {
+      return i;
+    }
+  }
+  return -1;
+}

[siva, 2014/02/05 19:09:15]

If a singly linked list is used for isolates this function could also
be under
#if defined(DEBUG)
....
#endif
and could be named CheckForDuplicateIsolates

+
+
+void Isolate::CheckNoIsolateHasThreadData(InterruptableThreadState* state) {

[siva, 2014/02/05 19:09:15]

I would call this CheckForDuplicateThreadState and this function can be under
#if defined(DEBUG)
...
#endif
I suppose.

[Cutch, 2014/02/05 23:00:31]

Done.

+  ASSERT(state != NULL);
+  MonitorLocker ml(isolates_monitor_);
+  for (intptr_t i = 0; i < isolates_size_; i++) {
+    Isolate* isolate = isolates_[i];
+    ASSERT(isolate->thread_state() != state);
+  }
+}
+
+
 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