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();

[Ivan Posva, 2015/10/28 19:31:53]

Does not match our discussion from earlier today. Why does the ThreadInterrupter
get kicked here?

[Cutch, 2015/10/28 19:50:33]

Forgot to remove this. It's gone now.

 }
 
 
 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 110 matching lines @@
 #define REUSABLE_HANDLE_SCOPE_INIT(object)
 #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_(1),  // Thread interrupts disabled by default.
       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 95 matching lines @@
   ASSERT(thread->isolate() == NULL);
   ASSERT(!isolate->HasMutatorThread());
   thread->isolate_ = isolate;
   isolate->MakeCurrentThreadMutator(thread);
   thread->set_vm_tag(VMTag::kVMTagId);
   ASSERT(thread->store_buffer_block_ == NULL);
   thread->StoreBufferAcquire();
   ASSERT(isolate->heap() != NULL);
   thread->heap_ = isolate->heap();
   thread->Schedule(isolate);
-  // TODO(koda): Migrate profiler interface to use Thread.
-  Profiler::BeginExecution(isolate);
+  thread->EnableThreadInterrupts();
 }
 
 
 void Thread::ExitIsolate() {
   Thread* thread = Thread::Current();
   // TODO(koda): Audit callers; they should know whether they're in an isolate.
   if (thread == NULL || thread->isolate() == NULL) return;
 #if defined(DEBUG)
   ASSERT(!thread->IsAnyReusableHandleScopeActive());
 #endif  // DEBUG
+  thread->DisableThreadInterrupts();
   // Clear since GC will not visit the thread once it is unscheduled.
   thread->ClearReusableHandles();
   Isolate* isolate = thread->isolate();
-  Profiler::EndExecution(isolate);
   thread->Unschedule();
   // TODO(koda): Move store_buffer_block_ into State.
   thread->StoreBufferRelease();
   if (isolate->is_runnable()) {
     thread->set_vm_tag(VMTag::kIdleTagId);
   } else {
     thread->set_vm_tag(VMTag::kLoadWaitTagId);
   }
   isolate->ClearMutatorThread();
   thread->isolate_ = NULL;
   ASSERT(Isolate::Current() == NULL);
   thread->heap_ = NULL;
 }
 
 
 void Thread::EnterIsolateAsHelper(Isolate* isolate, bool bypass_safepoint) {
   Thread* thread = Thread::Current();
   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);
+  thread->EnableThreadInterrupts();
 }
 
 
 void Thread::ExitIsolateAsHelper(bool bypass_safepoint) {
   Thread* thread = Thread::Current();
+  thread->DisableThreadInterrupts();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   thread->Unschedule(bypass_safepoint);
   // TODO(koda): Move store_buffer_block_ into State.
   thread->StoreBufferRelease();
   thread->isolate_ = NULL;
   thread->heap_ = NULL;
   ASSERT(!thread->IsMutatorThread());
 }
 
@@ skipping 43 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 {
-#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);
+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;
+}
+
+
 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;
 }
 
 
 intptr_t Thread::OffsetFromThread(const Object& object) {
@@ skipping 51 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;
 }
 
 
+DisableThreadInterruptsScope::DisableThreadInterruptsScope(Thread* thread)
+    : StackResource(thread) {
+  if (thread != NULL) {
+    thread->DisableThreadInterrupts();
+  }
+}
+
+
+DisableThreadInterruptsScope::~DisableThreadInterruptsScope() {
+  if (thread() != NULL) {
+    thread()->EnableThreadInterrupts();
+  }
+}
+
 }  // namespace dart