Move reusable handles from isolate to thread.

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 87 matching lines @@
 #if defined(TARGET_OS_WINDOWS)
 void Thread::CleanUp() {
   Thread* current = Current();
   if (current != NULL) {
     SetCurrent(NULL);
     delete current;
   }
 }
 #endif
 
+#if defined(DEBUG)
+#define REUSABLE_HANDLE_SCOPE_INIT(object)                                     \
+  reusable_##object##_handle_scope_active_(false),
+#else
+#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()),
       thread_interrupt_callback_(NULL),
       thread_interrupt_data_(NULL),
       isolate_(NULL),
       heap_(NULL),
       store_buffer_block_(NULL),
       log_(new class Log()),
-      vm_tag_(0) {
+      vm_tag_(0),
+      REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
+      REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_INIT)
+      reusable_handles_() {
   ClearState();
 
 #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)
@@ skipping 27 matching lines @@
   ASSERT(name##_entry_point_ == 0);                                            \
   name##_entry_point_ = k##name##RuntimeEntry.GetEntryPoint();
 RUNTIME_ENTRY_LIST(INIT_VALUE)
 #undef INIT_VALUE
 
 #define INIT_VALUE(returntype, name, ...)                                      \
   ASSERT(name##_entry_point_ == 0);                                            \
   name##_entry_point_ = k##name##RuntimeEntry.GetEntryPoint();
 LEAF_RUNTIME_ENTRY_LIST(INIT_VALUE)
 #undef INIT_VALUE
+
+  // Setup the thread specific reusable handles.
+#define REUSABLE_HANDLE_ALLOCATION(object)                                     \
+  this->object##_handle_ = this->AllocateReusableHandle<object>();
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_ALLOCATION)
+#undef REUSABLE_HANDLE_ALLOCATION
 }
 
 
 void Thread::Schedule(Isolate* isolate, bool bypass_safepoint) {
   State st;
   if (isolate->thread_registry()->RestoreStateTo(this, &st, bypass_safepoint)) {
     ASSERT(isolate->thread_registry()->Contains(this));
     state_ = st;
   }
 }
@@ skipping 33 matching lines @@
   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;

[koda, 2015/10/07 21:02:54]

In debug mode, please zap all the reusable handles when exiting an isolate.

As previously mentioned, we could also add debug mode checks that the isolate is
never exited during a reusable handle scope.

[srdjan, 2015/10/08 16:22:01]

ReusableHandleScope already makes sure that nobody can access the handles
outside the scope. I could clear them by reallocating them anew in
Thread::ExitIsolate, but I am not sure if it would improve reliability.
I could add a check that sees that none of the reusable handle scopes are
active. (not yet uploaded)

   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;
@@ skipping 82 matching lines @@
   ASSERT(isolate_ != NULL);
   isolate_->cha_ = value;
 }
 
 
 Log* Thread::log() const {
   return log_;
 }
 
 
+template<class C>
+C* Thread::AllocateReusableHandle() {
+  C* handle = reinterpret_cast<C*>(reusable_handles_.AllocateScopedHandle());
+  C::initializeHandle(handle, C::null());
+  return handle;
+}
+
+
+void Thread::VisitObjectPointers(ObjectPointerVisitor* visitor) {
+  ASSERT(visitor != NULL);
+
+  // Visit objects in thread specific handles area.
+  reusable_handles_.VisitObjectPointers(visitor);
+}
+
+
 void Thread::SetThreadInterrupter(ThreadInterruptCallback callback,
                                   void* data) {
   ASSERT(Thread::Current() == this);
   thread_interrupt_callback_ = callback;
   thread_interrupt_data_ = data;
 }
 
 
 bool Thread::IsThreadInterrupterEnabled(ThreadInterruptCallback* callback,
                                         void** data) const {
@@ skipping 46 matching lines @@
     return Thread::name##_entry_point_offset();                                \
   }
 LEAF_RUNTIME_ENTRY_LIST(COMPUTE_OFFSET)
 #undef COMPUTE_OFFSET
 
   UNREACHABLE();
   return -1;
 }
 
 }  // namespace dart