Implement safepointing of threads

runtime/vm/thread_test.cc

 // Copyright (c) 2012, 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 "platform/assert.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
 #include "vm/unit_test.h"
 #include "vm/profiler.h"
+#include "vm/safepoint.h"
+#include "vm/stack_frame.h"
 #include "vm/thread_pool.h"
-#include "vm/thread_registry.h"
 
 namespace dart {
 
 UNIT_TEST_CASE(Mutex) {
   // This unit test case needs a running isolate.
   Dart_CreateIsolate(
       NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, NULL);
 
   Mutex* mutex = new Mutex();
   mutex->Lock();
@@ skipping 143 matching lines @@
   }
 
  private:
   Isolate* isolate_;
   Monitor* monitor_;
   bool* done_;
   intptr_t id_;
 };
 
 
-TEST_CASE(ManyTasksWithZones) {
+VM_TEST_CASE(ManyTasksWithZones) {
   const int kTaskCount = 100;
   Monitor sync[kTaskCount];
   bool done[kTaskCount];
   Isolate* isolate = Thread::Current()->isolate();
   EXPECT(isolate->heap()->GrowthControlState());
   isolate->heap()->DisableGrowthControl();
   for (int i = 0; i < kTaskCount; i++) {
     done[i] = false;
     Dart::thread_pool()->Run(
         new TaskWithZoneAllocation(isolate, &sync[i], &done[i], i));
@@ skipping 15 matching lines @@
     }
     EXPECT(bar.Equals("bar"));
   }
 }
 
 
 TEST_CASE(ThreadRegistry) {
   Isolate* orig = Thread::Current()->isolate();
   Zone* orig_zone = Thread::Current()->zone();
   char* orig_str = orig_zone->PrintToString("foo");
-  Thread::ExitIsolate();
+  Dart_ExitIsolate();
   // Create and enter a new isolate.
   Dart_CreateIsolate(
       NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, NULL);
   Zone* zone0 = Thread::Current()->zone();
   EXPECT(zone0 != orig_zone);
   Dart_ShutdownIsolate();
   // Create and enter yet another isolate.
   Dart_CreateIsolate(
       NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, NULL);
   {
     // Create a stack resource this time, and exercise it.
     StackZone stack_zone(Thread::Current());
     Zone* zone1 = Thread::Current()->zone();
     EXPECT(zone1 != zone0);
     EXPECT(zone1 != orig_zone);
   }
   Dart_ShutdownIsolate();
-  Thread::EnterIsolate(orig);
+  Dart_EnterIsolate(reinterpret_cast<Dart_Isolate>(orig));
   // Original zone should be preserved.
   EXPECT_EQ(orig_zone, Thread::Current()->zone());
   EXPECT_STREQ("foo", orig_str);
 }
 
 
 // A helper thread that alternatingly cooperates and organizes
 // safepoint rendezvous. At rendezvous, it explicitly visits the
 // stacks looking for a specific marker (Smi) to verify that the expected
 // number threads are actually visited. The task is "done" when it has
 // successfully made all other tasks and the main thread rendezvous (may
 // not happen in the first rendezvous, since tasks are still starting up).
 class SafepointTestTask : public ThreadPool::Task {
  public:
   static const intptr_t kTaskCount;
 
   SafepointTestTask(Isolate* isolate,
-                    Mutex* mutex,
+                    Monitor* monitor,
                     intptr_t* expected_count,
                     intptr_t* total_done,
                     intptr_t* exited)
     : isolate_(isolate),
-      mutex_(mutex),
+      monitor_(monitor),
       expected_count_(expected_count),
       total_done_(total_done),
       exited_(exited),
       local_done_(false) {}
 
   virtual void Run() {
     Thread::EnterIsolateAsHelper(isolate_);
     {
-      MutexLocker ml(mutex_);
+      MonitorLocker ml(monitor_);
       ++*expected_count_;
     }
-    for (int i = 0; ; ++i) {
-      Thread* thread = Thread::Current();
+    Thread* thread = Thread::Current();
+    for (int i = reinterpret_cast<intptr_t>(thread); ; ++i) {
       StackZone stack_zone(thread);
       Zone* zone = thread->zone();
       HANDLESCOPE(thread);
       const intptr_t kUniqueSmi = 928327281;
       Smi& smi = Smi::Handle(zone, Smi::New(kUniqueSmi));
       if ((i % 100) != 0) {
         // Usually, we just cooperate.
-        isolate_->thread_registry()->CheckSafepoint();
+        TransitionVMToBlocked transition(thread);
       } else {
         // But occasionally, organize a rendezvous.
-        isolate_->thread_registry()->SafepointThreads();
+        SafepointOperationScope safepoint_scope(thread);
         ObjectCounter counter(isolate_, &smi);
         isolate_->IterateObjectPointers(
             &counter,
             StackFrameIterator::kValidateFrames);
         {
-          MutexLocker ml(mutex_);
+          MonitorLocker ml(monitor_);
           EXPECT_EQ(*expected_count_, counter.count());
         }
         UserTag& tag = UserTag::Handle(zone, isolate_->current_tag());
         if (tag.raw() != isolate_->default_tag()) {
           String& label = String::Handle(zone, tag.label());
           EXPECT(label.Equals("foo"));
-          MutexLocker ml(mutex_);
+          MonitorLocker ml(monitor_);
           if (*expected_count_ == kTaskCount && !local_done_) {
             // Success for the first time! Remember that we are done, and
             // update the total count.
             local_done_ = true;
             ++*total_done_;
           }
         }
-        isolate_->thread_registry()->ResumeAllThreads();
       }
       // Check whether everyone is done.
       {
-        MutexLocker ml(mutex_);
+        MonitorLocker ml(monitor_);
         if (*total_done_ == kTaskCount) {
           // Another task might be at SafepointThreads when resuming. Ensure its
           // expectation reflects reality, since we pop our handles here.
           --*expected_count_;
           break;
         }
       }
     }
     Thread::ExitIsolateAsHelper();
     {
-      MutexLocker ml(mutex_);
+      MonitorLocker ml(monitor_);
       ++*exited_;
+      ml.Notify();
     }
   }
 
  private:
   Isolate* isolate_;
-  Mutex* mutex_;
+  Monitor* monitor_;
   intptr_t* expected_count_;  // # copies of kUniqueSmi we expect to visit.
   intptr_t* total_done_;      // # tasks that successfully safepointed once.
   intptr_t* exited_;          // # tasks that are no longer running.
   bool local_done_;           // this task has successfully safepointed >= once.
 };
 
 
 const intptr_t SafepointTestTask::kTaskCount = 5;
 
 
 // Test rendezvous of:
 // - helpers in VM code,
 // - main thread in pure Dart,
 // organized by
 // - helpers.
 TEST_CASE(SafepointTestDart) {
   Isolate* isolate = Thread::Current()->isolate();
-  Mutex mutex;
+  Monitor monitor;
   intptr_t expected_count = 0;
   intptr_t total_done = 0;
   intptr_t exited = 0;
   for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
     Dart::thread_pool()->Run(new SafepointTestTask(
-        isolate, &mutex, &expected_count, &total_done, &exited));
+        isolate, &monitor, &expected_count, &total_done, &exited));
   }
   // Run Dart code on the main thread long enough to allow all helpers
   // to get their verification done and exit. Use a specific UserTag
   // to enable the helpers to verify that the main thread is
   // successfully interrupted in the pure Dart loop.
 #if defined(USING_SIMULATOR)
   const intptr_t kLoopCount = 12345678;
 #else
   const intptr_t kLoopCount = 1234567890;
 #endif  // USING_SIMULATOR
   char buffer[1024];
   OS::SNPrint(buffer, sizeof(buffer),
       "import 'dart:developer';\n"
       "int dummy = 0;\n"
       "main() {\n"
       "  new UserTag('foo').makeCurrent();\n"
       "  for (dummy = 0; dummy < %" Pd "; ++dummy) {\n"
       "    dummy += (dummy & 1);\n"
       "  }\n"
       "}\n", kLoopCount);
   Dart_Handle lib = TestCase::LoadTestScript(buffer, NULL);
   EXPECT_VALID(lib);
   Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   // Ensure we looped long enough to allow all helpers to succeed and exit.
   {
-    MutexLocker ml(&mutex);
+    MonitorLocker ml(&monitor);
+    while (exited != SafepointTestTask::kTaskCount) {
+      ml.Wait();
+    }
     EXPECT_EQ(SafepointTestTask::kTaskCount, total_done);
     EXPECT_EQ(SafepointTestTask::kTaskCount, exited);
   }
 }
 
 
 // Test rendezvous of:
 // - helpers in VM code, and
 // - main thread in VM code,
 // organized by
 // - helpers.
-TEST_CASE(SafepointTestVM) {
+VM_TEST_CASE(SafepointTestVM) {
   Isolate* isolate = thread->isolate();
-  Mutex mutex;
+  Monitor monitor;
   intptr_t expected_count = 0;
   intptr_t total_done = 0;
   intptr_t exited = 0;
   for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
     Dart::thread_pool()->Run(new SafepointTestTask(
-        isolate, &mutex, &expected_count, &total_done, &exited));
+        isolate, &monitor, &expected_count, &total_done, &exited));
   }
   String& label = String::Handle(String::New("foo"));
   UserTag& tag = UserTag::Handle(UserTag::New(label));
   isolate->set_current_tag(tag);
-  while (true) {
-    isolate->thread_registry()->CheckSafepoint();
-    MutexLocker ml(&mutex);
-    if (exited == SafepointTestTask::kTaskCount) {
-      break;
-    }
+  MonitorLocker ml(&monitor);
+  while (exited != SafepointTestTask::kTaskCount) {
+    ml.WaitWithSafepointCheck(thread);
   }
 }
 
 
-TEST_CASE(ThreadIterator_Count) {
+VM_TEST_CASE(ThreadIterator_Count) {
   intptr_t thread_count_0 = 0;
   intptr_t thread_count_1 = 0;
 
   {
     OSThreadIterator ti;
     while (ti.HasNext()) {
       OSThread* thread = ti.Next();
       EXPECT(thread != NULL);
       thread_count_0++;
     }
   }
 
   {
     OSThreadIterator ti;
     while (ti.HasNext()) {
       OSThread* thread = ti.Next();
       EXPECT(thread != NULL);
       thread_count_1++;
     }
   }
 
   EXPECT(thread_count_0 > 0);
   EXPECT(thread_count_1 > 0);
   EXPECT(thread_count_0 >= thread_count_1);
 }
 
 
-TEST_CASE(ThreadIterator_FindSelf) {
+VM_TEST_CASE(ThreadIterator_FindSelf) {
   OSThread* current = OSThread::Current();
   EXPECT(OSThread::IsThreadInList(current->join_id()));
 }
 
 
 struct ThreadIteratorTestParams {
   ThreadId spawned_thread_join_id;
   Monitor* monitor;
 };
 
@@ skipping 39 matching lines @@
   delete params.monitor;
 }
 
 
 // Test rendezvous of:
 // - helpers in VM code, and
 // - main thread in VM code,
 // organized by
 // - main thread, and
 // - helpers.
-TEST_CASE(SafepointTestVM2) {
+VM_TEST_CASE(SafepointTestVM2) {
   Isolate* isolate = thread->isolate();
-  Mutex mutex;
+  Monitor monitor;
   intptr_t expected_count = 0;
   intptr_t total_done = 0;
   intptr_t exited = 0;
   for (int i = 0; i < SafepointTestTask::kTaskCount; i++) {
     Dart::thread_pool()->Run(new SafepointTestTask(
-        isolate, &mutex, &expected_count, &total_done, &exited));
+        isolate, &monitor, &expected_count, &total_done, &exited));
   }
   bool all_helpers = false;
   do {
-    isolate->thread_registry()->SafepointThreads();
+    SafepointOperationScope safepoint_scope(thread);
     {
-      MutexLocker ml(&mutex);
+      MonitorLocker ml(&monitor);
       if (expected_count == SafepointTestTask::kTaskCount) {
         all_helpers = true;
       }
     }
-    isolate->thread_registry()->ResumeAllThreads();
   } while (!all_helpers);
   String& label = String::Handle(String::New("foo"));
   UserTag& tag = UserTag::Handle(UserTag::New(label));
   isolate->set_current_tag(tag);
-  while (true) {
-    isolate->thread_registry()->CheckSafepoint();
-    MutexLocker ml(&mutex);
-    if (exited == SafepointTestTask::kTaskCount) {
-      break;
-    }
+  MonitorLocker ml(&monitor);
+  while (exited != SafepointTestTask::kTaskCount) {
+    ml.WaitWithSafepointCheck(thread);
   }
 }
 
 
 class AllocAndGCTask : public ThreadPool::Task {
  public:
   AllocAndGCTask(Isolate* isolate,
                  Monitor* done_monitor,
                  bool* done)
     : isolate_(isolate),
@@ skipping 22 matching lines @@
     }
   }
 
  private:
   Isolate* isolate_;
   Monitor* done_monitor_;
   bool* done_;
 };
 
 
-TEST_CASE(HelperAllocAndGC) {
+VM_TEST_CASE(HelperAllocAndGC) {
   Monitor done_monitor;
   bool done = false;
-  Isolate* isolate = Thread::Current()->isolate();
+  Isolate* isolate = thread->isolate();
   Dart::thread_pool()->Run(new AllocAndGCTask(isolate, &done_monitor, &done));
   {
     while (true) {
-      isolate->thread_registry()->CheckSafepoint();
+      TransitionVMToBlocked transition(thread);
       MonitorLocker ml(&done_monitor);
       if (done) {
         break;
       }
     }
   }
 }
 
 }  // namespace dart