Switch profiler from isolates to threads

runtime/vm/thread.cc

 // Copyright (c) 2015, 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.h"
 
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
@@ skipping 48 matching lines @@
     while (current != NULL) {
       ASSERT(current != thread);
       current = current->thread_list_next_;
     }
   }
 #endif
 
   // Insert at head of list.
   thread->thread_list_next_ = thread_list_head_;
   thread_list_head_ = thread;
+
+  // Make sure the thread interrupter is awake.
+  ThreadInterrupter::WakeUp();
 }
 
 
 void Thread::RemoveThreadFromList(Thread* thread) {
   ASSERT(thread != NULL);
   ASSERT(thread->isolate() == NULL);
   ASSERT(thread_list_lock_ != NULL);
   MutexLocker ml(thread_list_lock_);
 
   // Handle case where |thread| is head of list.
@@ skipping 94 matching lines @@
 #endif  // defined(DEBUG)
 
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
 
 Thread::Thread(bool init_vm_constants)
     : id_(OSThread::GetCurrentThreadId()),
       thread_interrupt_callback_(NULL),
       thread_interrupt_data_(NULL),
+      thread_interrupt_disabled_(0),
       isolate_(NULL),
       heap_(NULL),
       timeline_block_(NULL),
       store_buffer_block_(NULL),
       log_(new class Log()),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_INIT)
       reusable_handles_(),
       cha_(NULL),
       deopt_id_(0),
@@ skipping 252 matching lines @@
   // Visit objects in thread specific handles area.
   reusable_handles_.VisitObjectPointers(visitor);
 
   if (pending_functions_ != GrowableObjectArray::null()) {
     visitor->VisitPointer(
         reinterpret_cast<RawObject**>(&pending_functions_));
   }
 }
 
 
+void Thread::DisableThreadInterrupts() {
+  ASSERT(Thread::Current() == this);
+  AtomicOperations::FetchAndIncrement(&thread_interrupt_disabled_);
+}
+
+
+void Thread::EnableThreadInterrupts() {
+  ASSERT(Thread::Current() == this);
+  uintptr_t old =
+      AtomicOperations::FetchAndDecrement(&thread_interrupt_disabled_);
+  if (old == 1) {
+    // We just decremented from 1 to 0.
+    // Make sure the thread interrupter is awake.
+    ThreadInterrupter::WakeUp();
+  }
+}
+
+
+bool Thread::ThreadInterruptsEnabled() {
+  return AtomicOperations::LoadRelaxed(&thread_interrupt_disabled_) == 0;
+}
+
+
 void Thread::SetThreadInterrupter(ThreadInterruptCallback callback,
                                   void* data) {
   ASSERT(Thread::Current() == this);
   thread_interrupt_callback_ = callback;
   thread_interrupt_data_ = data;
 }
 
 
 bool Thread::IsThreadInterrupterEnabled(ThreadInterruptCallback* callback,
                                         void** data) const {
@@ skipping 78 matching lines @@
 Thread* ThreadIterator::Next() {
   ASSERT(Thread::thread_list_lock_ != NULL);
   ASSERT(Thread::thread_list_lock_->IsOwnedByCurrentThread());
   Thread* current = next_;
   next_ = next_->thread_list_next_;
   return current;
 }
 
 
 }  // namespace dart