Use list of isolates in profiler

runtime/vm/thread_interrupter.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/simulator.h"
 #include "vm/thread_interrupter.h"
 
 namespace dart {
 
 // Notes:
@@ skipping 34 matching lines @@
             "Trace thread interrupter");
 
 bool ThreadInterrupter::initialized_ = false;
 bool ThreadInterrupter::shutdown_ = false;
 bool ThreadInterrupter::thread_running_ = false;
 ThreadId ThreadInterrupter::interrupter_thread_id_ = Thread::kInvalidThreadId;
 Monitor* ThreadInterrupter::monitor_ = NULL;
 intptr_t ThreadInterrupter::interrupt_period_ = 1000;
 ThreadLocalKey ThreadInterrupter::thread_state_key_ =
     Thread::kUnsetThreadLocalKey;
-ThreadInterrupter::ThreadState** ThreadInterrupter::threads_ = NULL;
-intptr_t ThreadInterrupter::threads_capacity_ = 0;
-intptr_t ThreadInterrupter::threads_size_ = 0;
 
 
 void ThreadInterrupter::InitOnce() {
   ASSERT(!initialized_);
-  initialized_ = true;
   ASSERT(thread_state_key_ == Thread::kUnsetThreadLocalKey);
   thread_state_key_ = Thread::CreateThreadLocal();
   ASSERT(thread_state_key_ != Thread::kUnsetThreadLocalKey);
   monitor_ = new Monitor();
-  ResizeThreads(16);
+  ASSERT(monitor_ != NULL);
+  initialized_ = true;
+}
+
+
+void ThreadInterrupter::Startup() {
+  ASSERT(initialized_);
   if (FLAG_trace_thread_interrupter) {
     OS::Print("ThreadInterrupter starting up.\n");
   }
   ASSERT(interrupter_thread_id_ == Thread::kInvalidThreadId);
   {
     MonitorLocker startup_ml(monitor_);
     Thread::Start(ThreadMain, 0);
     while (!thread_running_) {
       startup_ml.Wait();
     }
   }
   ASSERT(interrupter_thread_id_ != Thread::kInvalidThreadId);
   if (FLAG_trace_thread_interrupter) {
     OS::Print("ThreadInterrupter running.\n");
   }
 }
 
 
 void ThreadInterrupter::Shutdown() {
   if (shutdown_) {
     // Already shutdown.
     return;
   }
   ASSERT(initialized_);
   if (FLAG_trace_thread_interrupter) {
     OS::Print("ThreadInterrupter shutting down.\n");
   }
-  intptr_t size_at_shutdown = 0;
   {
     MonitorLocker ml(monitor_);
     shutdown_ = true;
-    size_at_shutdown = threads_size_;
-    threads_size_ = 0;
-    threads_capacity_ = 0;
-    free(threads_);
-    threads_ = NULL;
   }
   {
     MonitorLocker shutdown_ml(monitor_);
     while (thread_running_) {
       shutdown_ml.Wait();
     }
   }
   interrupter_thread_id_ = Thread::kInvalidThreadId;
   if (FLAG_trace_thread_interrupter) {
-    OS::Print("ThreadInterrupter shut down (%" Pd ").\n", size_at_shutdown);
+    OS::Print("ThreadInterrupter shut down.\n");
   }
 }
 
 // Delay between interrupts.
 void ThreadInterrupter::SetInterruptPeriod(intptr_t period) {
   if (shutdown_) {
     return;
   }
   ASSERT(initialized_);
   ASSERT(period > 0);
-  {
-    MonitorLocker ml(monitor_);
-    interrupt_period_ = period;
-  }
+  interrupt_period_ = period;
 }
 
 
 // Register the currently running thread for interrupts. If the current thread
 // is already registered, callback and data will be updated.
-void ThreadInterrupter::Register(ThreadInterruptCallback callback, void* data) {
+InterruptableThreadState* ThreadInterrupter::Register(
+    ThreadInterruptCallback callback, void* data) {
   if (shutdown_) {
-    return;
+    return NULL;
   }
   ASSERT(initialized_);
-  {
-    MonitorLocker ml(monitor_);
-    _EnsureThreadStateCreated();
-    // Set callback and data.
-    UpdateStateObject(callback, data);
-    _Enable();
-  }
+  InterruptableThreadState* state = _EnsureThreadStateCreated();
+  // Set callback and data.
+  UpdateStateObject(callback, data);
+  return state;
 }
 
 
 // Unregister the currently running thread for interrupts.
 void ThreadInterrupter::Unregister() {
   if (shutdown_) {
     return;
   }
   ASSERT(initialized_);
-  {
-    MonitorLocker ml(monitor_);
-    _EnsureThreadStateCreated();
-    // Clear callback and data.
-    UpdateStateObject(NULL, NULL);
-    _Disable();
-  }
+  _EnsureThreadStateCreated();
+  // Clear callback and data.
+  UpdateStateObject(NULL, NULL);
 }
 
 
-void ThreadInterrupter::Enable() {
-  if (shutdown_) {
-    return;
-  }
-  ASSERT(initialized_);
-  {
-    MonitorLocker ml(monitor_);
-    _EnsureThreadStateCreated();
-    _Enable();
-  }
-}
-
-
-void ThreadInterrupter::Disable() {
-  if (shutdown_) {
-    return;
-  }
-  ASSERT(initialized_);
-  {
-    MonitorLocker ml(monitor_);
-    _EnsureThreadStateCreated();
-    _Disable();
-  }
-}
-
-
-void ThreadInterrupter::_EnsureThreadStateCreated() {
-  ThreadState* state = CurrentThreadState();
+InterruptableThreadState* ThreadInterrupter::_EnsureThreadStateCreated() {
+  InterruptableThreadState* state = CurrentThreadState();
   if (state == NULL) {
     // Create thread state object lazily.
     ThreadId current_thread = Thread::GetCurrentThreadId();
     if (FLAG_trace_thread_interrupter) {
       intptr_t tid = Thread::ThreadIdToIntPtr(current_thread);
       OS::Print("ThreadInterrupter Tracking %p\n",
                 reinterpret_cast<void*>(tid));
     }
-    state = new ThreadState();
+    // Note: We currently do not free a thread's InterruptableThreadState.
+    state = new InterruptableThreadState();
+    ASSERT(state != NULL);
     state->callback = NULL;
     state->data = NULL;
     state->id = current_thread;
     SetCurrentThreadState(state);
   }
+  return state;
 }
 
 
-void ThreadInterrupter::_Enable() {
-  // Must be called with monitor_ locked.
-  ThreadId current_thread = Thread::GetCurrentThreadId();
-  if (Thread::Compare(current_thread, interrupter_thread_id_)) {
-    return;
-  }
-  intptr_t i = FindThreadIndex(current_thread);
-  if (i >= 0) {
-    return;
-  }
-  AddThread(current_thread);
-  if (FLAG_trace_thread_interrupter) {
-    intptr_t tid = Thread::ThreadIdToIntPtr(current_thread);
-    OS::Print("ThreadInterrupter Added %p\n", reinterpret_cast<void*>(tid));
-  }
-}
-
-void ThreadInterrupter::_Disable() {
-  // Must be called with monitor_ locked.
-  ThreadId current_thread = Thread::GetCurrentThreadId();
-  if (Thread::Compare(current_thread, interrupter_thread_id_)) {
-    return;
-  }
-  intptr_t index = FindThreadIndex(current_thread);
-  if (index < 0) {
-    // Not registered.
-    return;
-  }
-  ThreadState* state = RemoveThread(index);
-  ASSERT(state != NULL);
-  ASSERT(state == ThreadInterrupter::CurrentThreadState());
-  if (FLAG_trace_thread_interrupter) {
-    intptr_t tid = Thread::ThreadIdToIntPtr(current_thread);
-    OS::Print("ThreadInterrupter Removed %p\n", reinterpret_cast<void*>(tid));
-  }
-}
-
 void ThreadInterrupter::UpdateStateObject(ThreadInterruptCallback callback,
                                           void* data) {
-  // Must be called with monitor_ locked.
-  ThreadState* state = CurrentThreadState();
+  InterruptableThreadState* state = CurrentThreadState();
   ThreadId current_thread = Thread::GetCurrentThreadId();
   ASSERT(state != NULL);
   ASSERT(Thread::Compare(state->id, Thread::GetCurrentThreadId()));
   SetCurrentThreadState(NULL);
   // It is now safe to modify the state object. If an interrupt occurs,
   // the current thread state will be NULL.
   state->callback = callback;
   state->data = data;
   SetCurrentThreadState(state);
   if (FLAG_trace_thread_interrupter) {
     intptr_t tid = Thread::ThreadIdToIntPtr(current_thread);
     if (callback == NULL) {
       OS::Print("ThreadInterrupter Cleared %p\n", reinterpret_cast<void*>(tid));
     } else {
       OS::Print("ThreadInterrupter Updated %p\n", reinterpret_cast<void*>(tid));
     }
   }
 }
 
 
-ThreadInterrupter::ThreadState* ThreadInterrupter::CurrentThreadState() {
-  ThreadState* state = reinterpret_cast<ThreadState*>(
+InterruptableThreadState* ThreadInterrupter::GetCurrentThreadState() {
+  return _EnsureThreadStateCreated();
+}
+
+
+InterruptableThreadState* ThreadInterrupter::CurrentThreadState() {
+  InterruptableThreadState* state = reinterpret_cast<InterruptableThreadState*>(
       Thread::GetThreadLocal(thread_state_key_));
   return state;
 }
 
 
-void ThreadInterrupter::SetCurrentThreadState(ThreadState* state) {
+void ThreadInterrupter::SetCurrentThreadState(InterruptableThreadState* state) {
   Thread::SetThreadLocal(thread_state_key_, reinterpret_cast<uword>(state));
 }
 
 
-void ThreadInterrupter::ResizeThreads(intptr_t new_capacity) {
-  // Must be called with monitor_ locked.
-  ASSERT(new_capacity < kMaxThreads);
-  ASSERT(new_capacity > threads_capacity_);
-  ThreadState* state = NULL;
-  threads_ = reinterpret_cast<ThreadState**>(
-      realloc(threads_, sizeof(state) * new_capacity));
-  for (intptr_t i = threads_capacity_; i < new_capacity; i++) {
-    threads_[i] = NULL;
-  }
-  threads_capacity_ = new_capacity;
-}
-
-
-void ThreadInterrupter::AddThread(ThreadId id) {
-  // Must be called with monitor_ locked.
-  if (threads_ == NULL) {
-    // We are shutting down.
-    return;
-  }
-  ThreadState* state = CurrentThreadState();
-  if (state->callback == NULL) {
-    // No callback.
-    return;
-  }
-  if (threads_size_ == threads_capacity_) {
-    ResizeThreads(threads_capacity_ == 0 ? 16 : threads_capacity_ * 2);
-  }
-  threads_[threads_size_] = state;
-  threads_size_++;
-}
-
-
-intptr_t ThreadInterrupter::FindThreadIndex(ThreadId id) {
-  // Must be called with monitor_ locked.
-  if (threads_ == NULL) {
-    // We are shutting down.
-    return -1;
-  }
-  for (intptr_t i = 0; i < threads_size_; i++) {
-    if (threads_[i]->id == id) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-
-ThreadInterrupter::ThreadState* ThreadInterrupter::RemoveThread(intptr_t i) {
-  // Must be called with monitor_ locked.
-  if (threads_ == NULL) {
-    // We are shutting down.
-    return NULL;
-  }
-  ASSERT(i < threads_size_);
-  ThreadState* state = threads_[i];
-  ASSERT(state != NULL);
-  intptr_t last = threads_size_ - 1;
-  if (i != last) {
-    threads_[i] = threads_[last];
-  }
-  // Mark last as NULL.
-  threads_[last] = NULL;
-  // Pop.
-  threads_size_--;
-  return state;
-}
-
-
 void ThreadInterruptNoOp(const InterruptedThreadState& state, void* data) {
   // NoOp.
 }
 
 
+class ThreadInterrupterVisitIsolates : public IsolateVisitor {
+ public:
+  ThreadInterrupterVisitIsolates() { }
+  void VisitIsolate(Isolate* isolate) {
+    ASSERT(isolate != NULL);
+    InterruptableThreadState* state = isolate->thread_state();
+    if (state == NULL) {
+      return;
+    }
+    ASSERT(state->id != Thread::kInvalidThreadId);
+    ThreadInterrupter::InterruptThread(state);
+  }
+};
+
+
 void ThreadInterrupter::ThreadMain(uword parameters) {
   ASSERT(initialized_);
   InstallSignalHandler();
   if (FLAG_trace_thread_interrupter) {
     OS::Print("ThreadInterrupter thread running.\n");
   }
   {
     // Signal to main thread we are ready.
     MonitorLocker startup_ml(monitor_);
     thread_running_ = true;
     interrupter_thread_id_ = Thread::GetCurrentThreadId();
     startup_ml.Notify();
   }
   {
-    MonitorLocker ml(monitor_);
+    MonitorLocker wait_ml(monitor_);
+    ThreadInterrupterVisitIsolates visitor;
     while (!shutdown_) {
-      int64_t current_time = OS::GetCurrentTimeMicros();
-      InterruptThreads(current_time);
-      ml.WaitMicros(interrupt_period_);
+      Isolate::VisitIsolates(&visitor);
+      wait_ml.WaitMicros(interrupt_period_);
     }
   }
   if (FLAG_trace_thread_interrupter) {
     OS::Print("ThreadInterrupter thread exiting.\n");
   }
   {
     // Signal to main thread we are exiting.
     MonitorLocker shutdown_ml(monitor_);
     thread_running_ = false;
     shutdown_ml.Notify();
   }
 }
 
 }  // namespace dart