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 111 matching lines @@
 #endif  // defined(DEBUG)
 
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
 
 Thread::Thread(bool init_vm_constants)
     : id_(OSThread::GetCurrentThreadId()),
       join_id_(OSThread::GetCurrentThreadJoinId()),
       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 138 matching lines @@
   ASSERT(thread != NULL);
   ASSERT(thread->isolate() == NULL);
   thread->isolate_ = isolate;
   ASSERT(thread->store_buffer_block_ == NULL);
   // TODO(koda): Use StoreBufferAcquire once we properly flush before Scavenge.
   thread->store_buffer_block_ =
       thread->isolate()->store_buffer()->PopEmptyBlock();
   ASSERT(isolate->heap() != NULL);
   thread->heap_ = isolate->heap();
   ASSERT(thread->thread_interrupt_callback_ == NULL);
-  ASSERT(thread->thread_interrupt_data_ == NULL);
   // Do not update isolate->mutator_thread, but perform sanity check:
   // this thread should not be both the main mutator and helper.
   ASSERT(!thread->IsMutatorThread());
   thread->Schedule(isolate, bypass_safepoint);
 }
 
 
 void Thread::ExitIsolateAsHelper(bool bypass_safepoint) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
@@ skipping 52 matching lines @@
 void Thread::StoreBufferAcquire() {
   store_buffer_block_ = isolate()->store_buffer()->PopNonFullBlock();
 }
 
 
 bool Thread::IsMutatorThread() const {
   return ((isolate_ != NULL) && (isolate_->mutator_thread() == this));
 }
 
 
+bool Thread::IsExecutingDartCode() const {
+  return (top_exit_frame_info() == 0) &&
+         (vm_tag() == VMTag::kDartTagId);
+}
+
+
+bool Thread::HasExitedDartCode() const {
+  return (top_exit_frame_info() != 0) &&
+         (vm_tag() != VMTag::kDartTagId);
+}
+
+
 CHA* Thread::cha() const {
   ASSERT(isolate_ != NULL);
   return cha_;
 }
 
 
 void Thread::set_cha(CHA* value) {
   ASSERT(isolate_ != NULL);
   cha_ = value;
 }
@@ skipping 26 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::SetThreadInterrupter(ThreadInterruptCallback callback,
-                                  void* data) {
+void Thread::DisableThreadInterrupts() {
   ASSERT(Thread::Current() == this);
-  thread_interrupt_callback_ = callback;
-  thread_interrupt_data_ = data;
+  AtomicOperations::FetchAndIncrement(&thread_interrupt_disabled_);
 }
 
 
-bool Thread::IsThreadInterrupterEnabled(ThreadInterruptCallback* callback,
-                                        void** data) const {
+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();
+  }
+  if (old == 0) {
+    // We just decremented from 0, this means we've got a mismatched pair
+    // of calls to EnableThreadInterrupts and DisableThreadInterrupts.
+    FATAL("Invalid call to Thread::EnableThreadInterrupts()");
+  }
+}
+
+
+bool Thread::ThreadInterruptsEnabled() {
+  return AtomicOperations::LoadRelaxed(&thread_interrupt_disabled_) == 0;
+}
+
+
+void Thread::SetThreadInterruptCallback(ThreadInterruptCallback callback) {
+  ASSERT(Thread::Current() == this);
+  thread_interrupt_callback_ = callback;
+}
+
+
+bool Thread::GetThreadInterruptCallback(
+    ThreadInterruptCallback* callback) const {
 #if defined(TARGET_OS_WINDOWS)
   // On Windows we expect this to be called from the thread interrupter thread.
   ASSERT(id() != OSThread::GetCurrentThreadId());
 #else
   // On posix platforms, we expect this to be called from signal handler.
   ASSERT(id() == OSThread::GetCurrentThreadId());
 #endif
   ASSERT(callback != NULL);
-  ASSERT(data != NULL);
   *callback = thread_interrupt_callback_;
-  *data = thread_interrupt_data_;
-  return (*callback != NULL) &&
-         (*data != NULL);
+  return (*callback != NULL);
 }
 
 
 bool Thread::CanLoadFromThread(const Object& object) {
 #define CHECK_OBJECT(type_name, member_name, expr, default_init_value)         \
   if (object.raw() == expr) return true;
 CACHED_VM_OBJECTS_LIST(CHECK_OBJECT)
 #undef CHECK_OBJECT
   return false;
 }
@@ skipping 55 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