Implement safepointing of threads

runtime/vm/isolate.h

 // Copyright (c) 2013, 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_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/atomic.h"
@@ skipping 38 matching lines @@
 class RawContext;
 class RawDouble;
 class RawGrowableObjectArray;
 class RawMint;
 class RawObject;
 class RawInteger;
 class RawError;
 class RawFloat32x4;
 class RawInt32x4;
 class RawUserTag;
+class SafepointHandler;
 class SampleBuffer;
 class SendPort;
 class ServiceIdZone;
 class Simulator;
 class StackResource;
 class StackZone;
 class StoreBuffer;
 class StubCode;
 class ThreadRegistry;
 class UserTag;
@@ skipping 50 matching lines @@
   void RegisterClassAt(intptr_t index, const Class& cls);
   void ValidateClassTable();
 
   // Visit all object pointers.
   void IterateObjectPointers(ObjectPointerVisitor* visitor,
                              bool validate_frames);
 
   // Visits weak object pointers.
   void VisitWeakPersistentHandles(HandleVisitor* visitor);
 
+  // Prepares all threads in an isolate for Garbage Collection.
+  void PrepareForGC();
+
   StoreBuffer* store_buffer() { return store_buffer_; }
 
-  ThreadRegistry* thread_registry() { return thread_registry_; }
+  ThreadRegistry* thread_registry() const { return thread_registry_; }
+  SafepointHandler* safepoint_handler() const { return safepoint_handler_; }
 
   ClassTable* class_table() { return &class_table_; }
   static intptr_t class_table_offset() {
     return OFFSET_OF(Isolate, class_table_);
   }
 
   static intptr_t ic_miss_code_offset() {
     return OFFSET_OF(Isolate, ic_miss_code_);
   }
 
@@ skipping 538 matching lines @@
   RawGrowableObjectArray* pending_service_extension_calls() const {
     return pending_service_extension_calls_;
   }
   void set_pending_service_extension_calls(const GrowableObjectArray& value);
   RawGrowableObjectArray* registered_service_extension_handlers() const {
     return registered_service_extension_handlers_;
   }
   void set_registered_service_extension_handlers(
       const GrowableObjectArray& value);
 
-  void ClearMutatorThread() {
-    mutator_thread_ = NULL;
-  }
-  void MakeCurrentThreadMutator(Thread* thread) {
-    ASSERT(thread == Thread::Current());
-    DEBUG_ASSERT(IsIsolateOf(thread));
-    mutator_thread_ = thread;
-  }
-#if defined(DEBUG)
-  bool IsIsolateOf(Thread* thread);
-#endif  // DEBUG
+  Monitor* threads_lock() const;
+  Thread* ScheduleThread(bool is_mutator, bool bypass_safepoint = false);
+  void UnscheduleThread(
+      Thread* thread, bool is_mutator, bool bypass_sfepoint = false);

[rmacnak, 2016/01/27 21:42:32]

safepoint

[siva, 2016/01/28 18:22:46]

Done.

 
   // DEPRECATED: Use Thread's methods instead. During migration, these default
   // to using the mutator thread (which must also be the current thread).
   Zone* current_zone() const {
     ASSERT(Thread::Current() == mutator_thread_);
     return mutator_thread_->zone();
   }
 
   // Accessed from generated code:
   // TODO(asiva): Need to consider moving the stack_limit_ from isolate to
   // being thread specific.
   uword stack_limit_;
   StoreBuffer* store_buffer_;
   Heap* heap_;
   uword user_tag_;
   RawUserTag* current_tag_;
   RawUserTag* default_tag_;
   RawCode* ic_miss_code_;
   ClassTable class_table_;
   bool single_step_;
 
   ThreadRegistry* thread_registry_;
+  SafepointHandler* safepoint_handler_;
   Dart_MessageNotifyCallback message_notify_callback_;
   char* name_;
   char* debugger_name_;
   int64_t start_time_;
   Dart_Port main_port_;
   Dart_Port origin_id_;  // Isolates created by spawnFunc have some origin id.
   uint64_t pause_capability_;
   uint64_t terminate_capability_;
   bool errors_fatal_;
   ObjectStore* object_store_;
@@ skipping 119 matching lines @@
   static Monitor* isolates_list_monitor_;
   static Isolate* isolates_list_head_;
   static bool creation_enabled_;
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
 REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
 #undef REUSABLE_FRIEND_DECLARATION
 
   friend class GCMarker;  // VisitObjectPointers
+  friend class SafepointHandler;
   friend class Scavenger;  // VisitObjectPointers
   friend class ServiceIsolate;
   friend class Thread;
   friend class Timeline;
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
 
 // When we need to execute code in an isolate, we use the
@@ skipping 118 matching lines @@
   intptr_t* spawn_count_;
 
   Isolate::Flags isolate_flags_;
   bool paused_;
   bool errors_are_fatal_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_