Implement safepointing of threads

runtime/vm/thread.h

 // 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.
 
 #ifndef VM_THREAD_H_
 #define VM_THREAD_H_
 
 #include "include/dart_api.h"
+#include "platform/assert.h"
+#include "vm/atomic.h"
+#include "vm/bitfield.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/os_thread.h"
 #include "vm/store_buffer.h"
 #include "vm/runtime_entry_list.h"
 
 namespace dart {
 
 class AbstractType;
 class ApiLocalScope;
@@ skipping 117 matching lines @@
 
   // Empties the store buffer block into the isolate.
   void PrepareForGC();
 
   // OSThread corresponding to this thread.
   OSThread* os_thread() const { return os_thread_; }
   void set_os_thread(OSThread* os_thread) {
     os_thread_ = os_thread;
   }
 
+  // Monitor corresponding to this thread.
+  Monitor* thread_lock() const { return thread_lock_; }
+
   // The topmost zone used for allocation in this thread.
   Zone* zone() const { return zone_; }
 
   // The reusable api local scope for this thread.
   ApiLocalScope* api_reusable_scope() const { return api_reusable_scope_; }
   void set_api_reusable_scope(ApiLocalScope* value) {
     ASSERT(value == NULL || api_reusable_scope_ == NULL);
     api_reusable_scope_ = value;
   }
 
@@ skipping 46 matching lines @@
 #if defined(TESTING)
   bool StoreBufferContains(RawObject* obj) const {
     return store_buffer_block_->Contains(obj);
   }
 #endif
   void StoreBufferBlockProcess(StoreBuffer::ThresholdPolicy policy);
   static intptr_t store_buffer_block_offset() {
     return OFFSET_OF(Thread, store_buffer_block_);
   }
 
-  uword top_exit_frame_info() const { return top_exit_frame_info_; }
+  uword top_exit_frame_info() const {
+    return top_exit_frame_info_;
+  }
   static intptr_t top_exit_frame_info_offset() {
     return OFFSET_OF(Thread, top_exit_frame_info_);
   }
 
   StackResource* top_resource() const { return top_resource_; }
   void set_top_resource(StackResource* value) {
     top_resource_ = value;
   }
   static intptr_t top_resource_offset() {
     return OFFSET_OF(Thread, top_resource_);
@@ skipping 126 matching lines @@
   uword vm_tag() const {
     return vm_tag_;
   }
   void set_vm_tag(uword tag) {
     vm_tag_ = tag;
   }
   static intptr_t vm_tag_offset() {
     return OFFSET_OF(Thread, vm_tag_);
   }
 
+  RawGrowableObjectArray* pending_functions();
+
 #if defined(DEBUG)
 #define REUSABLE_HANDLE_SCOPE_ACCESSORS(object)                                \
   void set_reusable_##object##_handle_scope_active(bool value) {               \
     reusable_##object##_handle_scope_active_ = value;                          \
   }                                                                            \
   bool reusable_##object##_handle_scope_active() const {                       \
     return reusable_##object##_handle_scope_active_;                           \
   }
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_ACCESSORS)
 #undef REUSABLE_HANDLE_SCOPE_ACCESSORS
 
   bool IsAnyReusableHandleScopeActive() const {
 #define IS_REUSABLE_HANDLE_SCOPE_ACTIVE(object)                                \
     if (reusable_##object##_handle_scope_active_) return true;
     REUSABLE_HANDLE_LIST(IS_REUSABLE_HANDLE_SCOPE_ACTIVE)
     return false;
 #undef IS_REUSABLE_HANDLE_SCOPE_ACTIVE
   }
 #endif  // defined(DEBUG)
 
   void ClearReusableHandles();
 
 #define REUSABLE_HANDLE(object)                                                \
   object& object##Handle() const {                                             \
     return *object##_handle_;                                                  \
   }
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE)
 #undef REUSABLE_HANDLE
 
-  RawGrowableObjectArray* pending_functions();
+  /*
+   * Fields used to support safepointing a thread.
+   *
+   * - Bit 0 of the safepoint_state_ field is used to indicate if the thread is
+   *   already at a safepoint,
+   * - Bit 1 of the safepoint_state_ field is used to indicate if a safepoint
+   *   operation is requested for this thread.
+   * - Bit 2 of the safepoint_state_ field is used to indicate that the thread
+   *   is blocked for the safepoint operation to complete.
+   *
+   * The safepoint execution state (described above) for a thread is stored in
+   * in the execution_state_ field.
+   * Potential execution states a thread could be in:
+   *   kThreadInGenerated - The thread is running jitted dart/stub code.
+   *   kThreadInVM - The thread is running VM code.
+   *   kThreadInNative - The thread is running native code.
+   *   kThreadInBlockedState - The thread is blocked waiting for a resource.
+   */
+  static intptr_t safepoint_state_offset() {
+    return OFFSET_OF(Thread, safepoint_state_);
+  }
+  static bool IsAtSafepoint(uint32_t state) {
+    return AtSafepointField::decode(state);
+  }
+  bool IsAtSafepoint() const {
+    return AtSafepointField::decode(safepoint_state_);
+  }
+  static uint32_t SetAtSafepoint(bool value, uint32_t state) {
+    return AtSafepointField::update(value, state);
+  }
+  void SetAtSafepoint(bool value) {
+    ASSERT(thread_lock()->IsOwnedByCurrentThread());
+    safepoint_state_ = AtSafepointField::update(value, safepoint_state_);
+  }
+  bool IsSafepointRequested() const {
+    return SafepointRequestedField::decode(safepoint_state_);
+  }
+  static uint32_t SetSafepointRequested(bool value, uint32_t state) {
+    return SafepointRequestedField::update(value, state);
+  }
+  uint32_t SetSafepointRequested(bool value) {
+    ASSERT(thread_lock()->IsOwnedByCurrentThread());
+    uint32_t old_state;
+    uint32_t new_state;
+    do {
+      old_state = safepoint_state_;
+      new_state = SafepointRequestedField::update(value, old_state);
+    } while (AtomicOperations::CompareAndSwapUint32(&safepoint_state_,
+                                                    old_state,
+                                                    new_state) != old_state);
+    return old_state;
+  }
+  static bool IsBlockedForSafepoint(uint32_t state) {
+    return BlockedForSafepointField::decode(state);
+  }
+  bool IsBlockedForSafepoint() const {
+    return BlockedForSafepointField::decode(safepoint_state_);
+  }
+  void SetBlockedForSafepoint(bool value) {
+    ASSERT(thread_lock()->IsOwnedByCurrentThread());
+    safepoint_state_ =
+        BlockedForSafepointField::update(value, safepoint_state_);
+  }
+
+  enum ExecutionState {
+    kThreadInVM = 0,
+    kThreadInGenerated,
+    kThreadInNative,
+    kThreadInBlockedState
+  };
+
+  ExecutionState execution_state() const {
+    return static_cast<ExecutionState>(execution_state_);
+  }
+  void set_execution_state(ExecutionState state) {
+    execution_state_ = static_cast<uint32_t>(state);
+  }
+  static intptr_t execution_state_offset() {
+    return OFFSET_OF(Thread, execution_state_);
+  }
+
+  void EnterSafepoint() {
+    // First try a fast update of the thread state to indicate it is at a
+    // safepoint.
+    uint32_t new_state = SetAtSafepoint(true, 0);
+    uword addr = reinterpret_cast<uword>(this) + safepoint_state_offset();
+    if (AtomicOperations::CompareAndSwapUint32(
+            reinterpret_cast<uint32_t*>(addr), 0, new_state) != 0) {
+      // Fast update failed which means we could potentially be in the middle
+      // of a safepoint operation.
+      EnterSafepointUsingLock();
+    }
+  }
+
+  void ExitSafepoint() {
+    // First try a fast update of the thread state to indicate it is not at a
+    // safepoint anymore.
+    uint32_t old_state = SetAtSafepoint(true, 0);
+    uword addr = reinterpret_cast<uword>(this) + safepoint_state_offset();
+    if (AtomicOperations::CompareAndSwapUint32(
+            reinterpret_cast<uint32_t*>(addr), old_state, 0) != old_state) {
+      // Fast update failed which means we could potentially be in the middle
+      // of a safepoint operation.
+      ExitSafepointUsingLock();
+    }
+  }
+
+  void CheckForSafepoint() {
+    if (IsSafepointRequested()) {
+      BlockForSafepoint();
+    }
+  }
+
+  Thread* next() const { return next_; }
 
   // Visit all object pointers.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   bool IsValidLocalHandle(Dart_Handle object) const;
   int CountLocalHandles() const;
   int ZoneSizeInBytes() const;
   void UnwindScopes(uword stack_marker);
 
   void InitVMConstants();
 
  private:
   template<class T> T* AllocateReusableHandle();
 
   OSThread* os_thread_;
+  Monitor* thread_lock_;
   Isolate* isolate_;
   Heap* heap_;
   Zone* zone_;
   ApiLocalScope* api_reusable_scope_;
   ApiLocalScope* api_top_scope_;
   uword top_exit_frame_info_;
   StackResource* top_resource_;
   LongJumpScope* long_jump_base_;
   StoreBufferBlock* store_buffer_block_;
   int32_t no_callback_scope_depth_;
@@ skipping 32 matching lines @@
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_FIELDS)
 #undef REUSABLE_HANDLE_FIELDS
 
 #if defined(DEBUG)
 #define REUSABLE_HANDLE_SCOPE_VARIABLE(object)                                 \
   bool reusable_##object##_handle_scope_active_;
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_VARIABLE);
 #undef REUSABLE_HANDLE_SCOPE_VARIABLE
 #endif  // defined(DEBUG)
 
+  class AtSafepointField : public BitField<bool, 0, 1> {};
+  class SafepointRequestedField : public BitField<bool, 1, 1> {};
+  class BlockedForSafepointField : public BitField<bool, 2, 1> {};
+  uint32_t safepoint_state_;
+  uint32_t execution_state_;
+
   Thread* next_;  // Used to chain the thread structures in an isolate.
 
   explicit Thread(Isolate* isolate);
 
   void StoreBufferRelease(
       StoreBuffer::ThresholdPolicy policy = StoreBuffer::kCheckThreshold);
   void StoreBufferAcquire();
 
   void set_zone(Zone* zone) {
     zone_ = zone;
   }
 
   void set_top_exit_frame_info(uword top_exit_frame_info) {
     top_exit_frame_info_ = top_exit_frame_info;
   }
 
+  void set_safepoint_state(uint32_t value) {
+    safepoint_state_ = value;
+  }
+  void EnterSafepointUsingLock();
+  void ExitSafepointUsingLock();
+  void BlockForSafepoint();
+
   static void SetCurrent(Thread* current) {
     OSThread::SetCurrentTLS(reinterpret_cast<uword>(current));
   }
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
   friend class ApiZone;
@@ skipping 15 matching lines @@
 // Disable thread interrupts.
 class DisableThreadInterruptsScope : public StackResource {
  public:
   explicit DisableThreadInterruptsScope(Thread* thread);
   ~DisableThreadInterruptsScope();
 };
 
 }  // namespace dart
 
 #endif  // VM_THREAD_H_