Safepointing in GC

runtime/vm/gc_sweeper.cc

 // Copyright (c) 2011, 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/gc_sweeper.h"
 
 #include "vm/freelist.h"
 #include "vm/globals.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
@@ skipping 78 matching lines @@
   return words_to_end;
 }
 
 
 class SweeperTask : public ThreadPool::Task {
  public:
   SweeperTask(Isolate* isolate,
               PageSpace* old_space,
               HeapPage* first,
               HeapPage* last,
-              FreeList* freelist)
+              FreeList* freelist,
+              Monitor* started_monitor,
+              bool* started_flag,
+              SafepointId pass_safepoint)
       : task_isolate_(isolate),
         old_space_(old_space),
         first_(first),
         last_(last),
-        freelist_(freelist) {
+        freelist_(freelist),
+        started_monitor_(started_monitor),
+        started_flag_(started_flag),
+        pass_safepoint_(pass_safepoint) {
     ASSERT(task_isolate_ != NULL);
     ASSERT(first_ != NULL);
     ASSERT(old_space_ != NULL);
     ASSERT(last_ != NULL);
     ASSERT(freelist_ != NULL);
     MonitorLocker ml(old_space_->tasks_lock());
     old_space_->set_tasks(old_space_->tasks() + 1);
     ml.Notify();
   }
 
   virtual void Run() {
-    Thread::EnterIsolateAsHelper(task_isolate_);
+    Thread::EnterIsolateAsHelper(task_isolate_, pass_safepoint_);
+    {
+      MonitorLocker ml(started_monitor_);
+      ASSERT(!*started_flag_);
+      *started_flag_ = true;
+      ml.Notify();
+    }
     GCSweeper sweeper;
 
     HeapPage* page = first_;
     HeapPage* prev_page = NULL;
 
     while (page != NULL) {
       HeapPage* next_page = page->next();
       ASSERT(page->type() == HeapPage::kData);
       bool page_in_use = sweeper.SweepPage(page, freelist_, false);
       if (page_in_use) {
@@ skipping 19 matching lines @@
       ml.Notify();
     }
   }
 
  private:
   Isolate* task_isolate_;
   PageSpace* old_space_;
   HeapPage* first_;
   HeapPage* last_;
   FreeList* freelist_;
+  Monitor* started_monitor_;
+  bool* started_flag_;
+  SafepointId pass_safepoint_;
 };
 
 
 void GCSweeper::SweepConcurrent(Isolate* isolate,
                                 HeapPage* first,
                                 HeapPage* last,
-                                FreeList* freelist) {
+                                FreeList* freelist,
+                                SafepointId pass_safepoint) {
+  Monitor started_monitor;
+  bool started_flag = false;
   SweeperTask* task =
       new SweeperTask(isolate,
                       isolate->heap()->old_space(),
                       first, last,
-                      freelist);
+                      freelist,
+                      &started_monitor,
+                      &started_flag,
+                      pass_safepoint);
   ThreadPool* pool = Dart::thread_pool();
   pool->Run(task);
+  {
+    MonitorLocker ml(&started_monitor);

[Ivan Posva, 2015/08/19 08:00:04]

I don't expect it to be needed to wait for the sweeper threads to start running
before the marker can make further progress.

+    while (!started_flag) {
+      ml.Wait();
+    }
+  }
 }
 
 }  // namespace dart