Revert "Switch profiler from isolates to threads"

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/thread_interrupter.h"
 
 #include "vm/flags.h"
 #include "vm/lockers.h"
 #include "vm/os.h"
 #include "vm/simulator.h"
@@ skipping 33 matching lines @@
 // thread local storage pointer is set again. This has an important side
 // effect: if the thread is interrupted by a signal handler during a ThreadState
 // update the signal handler will immediately return.
 
 DEFINE_FLAG(bool, trace_thread_interrupter, false,
             "Trace thread interrupter");
 
 bool ThreadInterrupter::initialized_ = false;
 bool ThreadInterrupter::shutdown_ = false;
 bool ThreadInterrupter::thread_running_ = false;
-bool ThreadInterrupter::woken_up_ = false;
 ThreadJoinId ThreadInterrupter::interrupter_thread_id_ =
     OSThread::kInvalidThreadJoinId;
 Monitor* ThreadInterrupter::monitor_ = NULL;
 intptr_t ThreadInterrupter::interrupt_period_ = 1000;
 intptr_t ThreadInterrupter::current_wait_time_ = Monitor::kNoTimeout;
 
 
 void ThreadInterrupter::InitOnce() {
   ASSERT(!initialized_);
   monitor_ = new Monitor();
@@ skipping 53 matching lines @@
   if (shutdown_) {
     return;
   }
   ASSERT(initialized_);
   ASSERT(period > 0);
   interrupt_period_ = period;
 }
 
 
 void ThreadInterrupter::WakeUp() {
-  if (!initialized_) {
-    // Early call.
-    return;
-  }
   ASSERT(initialized_);
   {
     MonitorLocker ml(monitor_);
-    woken_up_ = true;
     if (!InDeepSleep()) {
       // No need to notify, regularly waking up.
       return;
     }
     // Notify the interrupter to wake it from its deep sleep.
     ml.Notify();
   }
 }
 
 
+void ThreadInterruptNoOp(const InterruptedThreadState& state, void* data) {
+  // NoOp.
+}
+
+
+class ThreadInterrupterVisitIsolates : public IsolateVisitor {
+ public:
+  ThreadInterrupterVisitIsolates() {
+    profiled_thread_count_ = 0;
+  }
+
+  void VisitIsolate(Isolate* isolate) {
+    ASSERT(isolate != NULL);
+    profiled_thread_count_ += isolate->ProfileInterrupt();
+  }
+
+  intptr_t profiled_thread_count() const {
+    return profiled_thread_count_;
+  }
+
+  void set_profiled_thread_count(intptr_t profiled_thread_count) {
+    profiled_thread_count_ = profiled_thread_count;
+  }
+
+ private:
+  intptr_t profiled_thread_count_;
+};
+
+
 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_);
     interrupter_thread_id_ = OSThread::GetCurrentThreadJoinId();
     thread_running_ = true;
     startup_ml.Notify();
   }
   {
-    intptr_t interrupted_thread_count = 0;
+    ThreadInterrupterVisitIsolates visitor;
     current_wait_time_ = interrupt_period_;
     MonitorLocker wait_ml(monitor_);
     while (!shutdown_) {
       intptr_t r = wait_ml.WaitMicros(current_wait_time_);
 
-      if (shutdown_) {
+      if ((r == Monitor::kNotified) && shutdown_) {
         break;
       }
 
       if ((r == Monitor::kNotified) && InDeepSleep()) {
         // Woken up from deep sleep.
-        ASSERT(interrupted_thread_count == 0);
+        ASSERT(visitor.profiled_thread_count() == 0);
         // Return to regular interrupts.
         current_wait_time_ = interrupt_period_;
       }
 
-      // Reset count before interrupting any threads.
-      interrupted_thread_count = 0;
+      // Reset count before visiting isolates.
+      visitor.set_profiled_thread_count(0);
+      Isolate::VisitIsolates(&visitor);
 
-      // Temporarily drop the monitor while we interrupt threads.
-      monitor_->Exit();
-
-      {
-        ThreadIterator it;
-        while (it.HasNext()) {
-          Thread* thread = it.Next();
-          if (thread->ThreadInterruptsEnabled()) {
-            interrupted_thread_count++;
-            InterruptThread(thread);
-          }
-        }
-      }
-
-      // Take the monitor lock again.
-      monitor_->Enter();
-
-      // Now that we have the lock, check if we were signaled to wake up while
-      // interrupting threads.
-      if (!woken_up_ && (interrupted_thread_count == 0)) {
-        // No threads were interrupted and we were not signaled to interrupt
-        // new threads. In order to reduce unnecessary CPU load, we will wait
-        // until we are notified before attempting to interrupt again.
+      if (visitor.profiled_thread_count() == 0) {
+        // No isolates were profiled. In order to reduce unnecessary CPU
+        // load, we will wait until we are notified before attempting to
+        // interrupt again.
         current_wait_time_ = Monitor::kNoTimeout;
         continue;
       }
 
-      woken_up_ = false;
-
       ASSERT(current_wait_time_ != Monitor::kNoTimeout);
     }
   }
   RemoveSignalHandler();
   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