Remove and Add the mutator thread from the active thread list when unscheduling and scheduling the …

runtime/vm/thread_registry.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_registry.h"
 
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 
 namespace dart {
 
 ThreadRegistry::~ThreadRegistry() {
   // Go over the free thread list and delete the thread objects.
   {
     MonitorLocker ml(monitor_);
-    // At this point the mutator thread should be the only thread
-    // in the active list, delete it.
-    ASSERT(active_list_->next_ == NULL);
-    ASSERT(active_list_ == mutator_thread_);
+    // At this point the active list should be empty.
+    ASSERT(active_list_ == NULL);
+    // We have cached the mutator thread, delete it.
     delete mutator_thread_;
-    active_list_ = NULL;
     mutator_thread_ = NULL;
     // Now delete all the threads in the free list.
     while (free_list_ != NULL) {
       Thread* thread = free_list_;
       free_list_ = thread->next_;
       delete thread;
     }
   }
 
   // Delete monitor.
@@ skipping 41 matching lines @@
                                  bool bypass_safepoint) {
   MonitorLocker ml(monitor_);
   // Wait for any rendezvous in progress.
   while (!bypass_safepoint && in_rendezvous_) {
     ml.Wait(Monitor::kNoTimeout);
   }
   Thread* thread = NULL;
   OSThread* os_thread = OSThread::Current();
   ASSERT(os_thread != NULL);
   ASSERT(isolate->heap() != NULL);
+  // First get a Thread structure. (we special case the mutator thread
+  // by reusing the cached structure, see comment in 'thread_registry.h').
   if (is_mutator) {
     if (mutator_thread_ == NULL) {
       mutator_thread_ = GetThreadFromFreelist(isolate);
     }
     thread = mutator_thread_;
   } else {
     thread = GetThreadFromFreelist(isolate);
     ASSERT(thread->api_top_scope() == NULL);
   }
+  // Now add this Thread to the active list for the isolate.
+  AddThreadToActiveList(thread);
+  // Set up other values and set the TLS value.
   thread->isolate_ = isolate;
   thread->heap_ = isolate->heap();
   thread->set_os_thread(os_thread);
   os_thread->set_thread(thread);
   Thread::SetCurrent(thread);
   os_thread->EnableThreadInterrupts();
   return thread;
 }
 
 
 void ThreadRegistry::Unschedule(Thread* thread,
                                 bool is_mutator,
                                 bool bypass_safepoint) {
   MonitorLocker ml(monitor_);
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   os_thread->DisableThreadInterrupts();
   os_thread->set_thread(NULL);
   OSThread::SetCurrent(os_thread);
   thread->isolate_ = NULL;
   thread->heap_ = NULL;
   thread->set_os_thread(NULL);
+  // Remove thread from the active list for the isolate.
+  RemoveThreadFromActiveList(thread);
+  // Return thread to the free list (we special case the mutator
+  // thread by holding on to it, see comment in 'thread_registry.h').
   if (!is_mutator) {
     ASSERT(thread->api_top_scope() == NULL);
     ReturnThreadToFreelist(thread);
   }
   if (!bypass_safepoint && in_rendezvous_) {
     // Don't wait for this thread.
     ASSERT(remaining_ > 0);
     if (--remaining_ == 0) {
       ml.NotifyAll();
     }
@@ skipping 16 matching lines @@
     StackFrame* frame = frames_iterator.NextFrame();
     while (frame != NULL) {
       frame->VisitObjectPointers(visitor);
       frame = frames_iterator.NextFrame();
     }
     thread = thread->next_;
   }
 }
 
 
-Thread* ThreadRegistry::GetThreadFromFreelist(Isolate* isolate) {
+void ThreadRegistry::AddThreadToActiveList(Thread* thread) {
+  ASSERT(thread != NULL);
   ASSERT(monitor_->IsOwnedByCurrentThread());
-  Thread* thread = NULL;
-  // Get thread structure from free list or create a new one.
-  if (free_list_ == NULL) {
-    thread = new Thread(isolate);
-  } else {
-    thread = free_list_;
-    free_list_ = thread->next_;
-  }
-  // Add thread to active list.
   thread->next_ = active_list_;
   active_list_ = thread;
-  return thread;
 }
 
-void ThreadRegistry::ReturnThreadToFreelist(Thread* thread) {
+
+void ThreadRegistry::RemoveThreadFromActiveList(Thread* thread) {
   ASSERT(thread != NULL);
-  ASSERT(thread->os_thread_ == NULL);
-  ASSERT(thread->isolate_ == NULL);
-  ASSERT(thread->heap_ == NULL);
   ASSERT(monitor_->IsOwnedByCurrentThread());
-  // First remove the thread from the active list.
   Thread* prev = NULL;
   Thread* current = active_list_;
   while (current != NULL) {
     if (current == thread) {
       if (prev == NULL) {
         active_list_ = current->next_;
       } else {
         prev->next_ = current->next_;
       }
       break;
     }
     prev = current;
     current = current->next_;
   }
-  // Now add thread to the free list.
+}
+
+
+Thread* ThreadRegistry::GetThreadFromFreelist(Isolate* isolate) {
+  ASSERT(monitor_->IsOwnedByCurrentThread());
+  Thread* thread = NULL;
+  // Get thread structure from free list or create a new one.
+  if (free_list_ == NULL) {
+    thread = new Thread(isolate);
+  } else {
+    thread = free_list_;
+    free_list_ = thread->next_;
+  }
+  return thread;
+}
+
+void ThreadRegistry::ReturnThreadToFreelist(Thread* thread) {
+  ASSERT(thread != NULL);
+  ASSERT(thread->os_thread_ == NULL);
+  ASSERT(thread->isolate_ == NULL);
+  ASSERT(thread->heap_ == NULL);
+  ASSERT(monitor_->IsOwnedByCurrentThread());
+  // Add thread to the free list.
   thread->next_ = free_list_;
   free_list_ = thread;
 }
 
 
 void ThreadRegistry::CheckSafepointLocked() {
   int64_t last_round = -1;
   while (in_rendezvous_) {
     ASSERT(round_ >= last_round);
     if (round_ != last_round) {
@@ skipping 22 matching lines @@
   intptr_t count = 0;
   Thread* current = active_list_;
   while (current != NULL) {
     ++count;
     current = current->next_;
   }
   return count;
 }
 
 }  // namespace dart