Implement safepointing of 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/dart_api_state.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 23 matching lines @@
 #define REUSABLE_HANDLE_SCOPE_INIT(object)
 #endif  // defined(DEBUG)
 
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
 
 Thread::Thread(Isolate* isolate)
     : BaseThread(false),
       os_thread_(NULL),
+      thread_lock_(new Monitor()),
       isolate_(NULL),
       heap_(NULL),
       zone_(NULL),
       api_reusable_scope_(NULL),
       api_top_scope_(NULL),
       top_exit_frame_info_(0),
       top_resource_(NULL),
       long_jump_base_(NULL),
       store_buffer_block_(NULL),
       no_callback_scope_depth_(0),
 #if defined(DEBUG)
       top_handle_scope_(NULL),
       no_handle_scope_depth_(0),
       no_safepoint_scope_depth_(0),
 #endif
       reusable_handles_(),
       cha_(NULL),
       deopt_id_(0),
       vm_tag_(0),
       pending_functions_(GrowableObjectArray::null()),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_INIT)
+      safepoint_state_(0),
+      execution_state_(kThreadInVM),
       next_(NULL) {
 #define DEFAULT_INIT(type_name, member_name, init_expr, default_init_value)    \
   member_name = default_init_value;
 CACHED_CONSTANTS_LIST(DEFAULT_INIT)
 #undef DEFAULT_INIT
 
 #define DEFAULT_INIT(name)                                                     \
   name##_entry_point_ = 0;
 RUNTIME_ENTRY_LIST(DEFAULT_INIT)
 #undef DEFAULT_INIT
@@ skipping 91 matching lines @@
 RawGrowableObjectArray* Thread::pending_functions() {
   if (pending_functions_ == GrowableObjectArray::null()) {
     pending_functions_ = GrowableObjectArray::New(Heap::kOld);
   }
   return pending_functions_;
 }
 
 
 bool Thread::EnterIsolate(Isolate* isolate) {
   const bool kIsMutatorThread = true;
-  const bool kDontBypassSafepoints = false;
-  ThreadRegistry* tr = isolate->thread_registry();
-  Thread* thread = tr->Schedule(
-      isolate, kIsMutatorThread, kDontBypassSafepoints);
+  Thread* thread = isolate->ScheduleThread(kIsMutatorThread);
   if (thread != NULL) {
-    isolate->MakeCurrentThreadMutator(thread);
-    thread->set_vm_tag(VMTag::kVMTagId);
     ASSERT(thread->store_buffer_block_ == NULL);
     thread->StoreBufferAcquire();
     return true;
   }
   return false;
 }
 
 
 void Thread::ExitIsolate() {
   Thread* thread = Thread::Current();
-  ASSERT(thread != NULL);
-  ASSERT(thread->IsMutatorThread());
-#if defined(DEBUG)
-  ASSERT(!thread->IsAnyReusableHandleScopeActive());
-#endif  // DEBUG
+  ASSERT(thread != NULL && thread->IsMutatorThread());
+  DEBUG_ASSERT(!thread->IsAnyReusableHandleScopeActive());
+
+  Isolate* isolate = thread->isolate();
+  ASSERT(isolate != NULL);
+  ASSERT(thread->execution_state() == Thread::kThreadInVM);
   // Clear since GC will not visit the thread once it is unscheduled.
   thread->ClearReusableHandles();
   thread->StoreBufferRelease();
-  Isolate* isolate = thread->isolate();
-  ASSERT(isolate != NULL);
   if (isolate->is_runnable()) {
     thread->set_vm_tag(VMTag::kIdleTagId);
   } else {
     thread->set_vm_tag(VMTag::kLoadWaitTagId);
   }
   const bool kIsMutatorThread = true;
-  const bool kDontBypassSafepoints = false;
-  ThreadRegistry* tr = isolate->thread_registry();
-  tr->Unschedule(thread, kIsMutatorThread, kDontBypassSafepoints);
-  isolate->ClearMutatorThread();
+  isolate->UnscheduleThread(thread, kIsMutatorThread);
 }
 
 
 bool Thread::EnterIsolateAsHelper(Isolate* isolate, bool bypass_safepoint) {
   const bool kIsNotMutatorThread = false;
-  ThreadRegistry* tr = isolate->thread_registry();
-  Thread* thread = tr->Schedule(isolate, kIsNotMutatorThread, bypass_safepoint);
+  Thread* thread = isolate->ScheduleThread(kIsNotMutatorThread,
+                                           bypass_safepoint);
   if (thread != NULL) {
     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();
     // This thread should not be the main mutator.
     ASSERT(!thread->IsMutatorThread());
     return true;
   }
   return false;
 }
 
 
 void Thread::ExitIsolateAsHelper(bool bypass_safepoint) {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   ASSERT(!thread->IsMutatorThread());
+  ASSERT(thread->execution_state() == Thread::kThreadInVM);
   thread->StoreBufferRelease();
   Isolate* isolate = thread->isolate();
   ASSERT(isolate != NULL);
   const bool kIsNotMutatorThread = false;
-  ThreadRegistry* tr = isolate->thread_registry();
-  tr->Unschedule(thread, kIsNotMutatorThread, bypass_safepoint);
+  isolate->UnscheduleThread(thread, kIsNotMutatorThread, bypass_safepoint);
 }
 
 
 void Thread::PrepareForGC() {
-  ASSERT(isolate()->thread_registry()->AtSafepoint());
+  ASSERT(IsAtSafepoint());
   // Prevent scheduling another GC by ignoring the threshold.
+  ASSERT(store_buffer_block_ != NULL);
   StoreBufferRelease(StoreBuffer::kIgnoreThreshold);
   // Make sure to get an *empty* block; the isolate needs all entries
   // at GC time.
   // TODO(koda): Replace with an epilogue (PrepareAfterGC) that acquires.
   store_buffer_block_ = isolate()->store_buffer()->PopEmptyBlock();
 }
 
 
 void Thread::StoreBufferBlockProcess(StoreBuffer::ThresholdPolicy policy) {
   StoreBufferRelease(policy);
@@ skipping 31 matching lines @@
 
 bool Thread::IsMutatorThread() const {
   return ((isolate_ != NULL) && (isolate_->mutator_thread() == this));
 }
 
 
 bool Thread::CanCollectGarbage() const {
   // We have non mutator threads grow the heap instead of triggering
   // a garbage collection when they are at a safepoint (e.g: background
   // compiler thread finalizing and installing code at a safepoint).
-  // Note: This code will change once the new Safepoint logic is in place.
-  return (IsMutatorThread() ||
-          (isolate_ != NULL && !isolate_->thread_registry()->AtSafepoint()));
+  return (IsMutatorThread() || IsAtSafepoint());
 }
 
 
 bool Thread::IsExecutingDartCode() const {
   return (top_exit_frame_info() == 0) &&
          (vm_tag() == VMTag::kDartTagId);
 }
 
 
 bool Thread::HasExitedDartCode() const {
@@ skipping 132 matching lines @@
   while (scope != NULL &&
          scope->stack_marker() != 0 &&
          scope->stack_marker() == stack_marker) {
     api_top_scope_ = scope->previous();
     delete scope;
     scope = api_top_scope_;
   }
 }
 
 
+void Thread::EnterSafepointUsingLock() {
+  isolate()->safepoint_handler()->EnterSafepointUsingLock(this);
+}
+
+
+void Thread::ExitSafepointUsingLock() {
+  isolate()->safepoint_handler()->ExitSafepointUsingLock(this);
+}
+
+
+void Thread::BlockForSafepoint() {
+  isolate()->safepoint_handler()->BlockForSafepoint(this);
+}
+
+
 DisableThreadInterruptsScope::DisableThreadInterruptsScope(Thread* thread)
     : StackResource(thread) {
   if (thread != NULL) {
     OSThread* os_thread = thread->os_thread();
     ASSERT(os_thread != NULL);
     os_thread->DisableThreadInterrupts();
   }
 }
 
 
 DisableThreadInterruptsScope::~DisableThreadInterruptsScope() {
   if (thread() != NULL) {
     OSThread* os_thread = thread()->os_thread();
     ASSERT(os_thread != NULL);
     os_thread->EnableThreadInterrupts();
   }
 }
 
 }  // namespace dart