- Add and enable concurrent sweeper.

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"
 #include "vm/pages.h"
+#include "vm/thread_pool.h"
 
 namespace dart {
 
 bool GCSweeper::SweepPage(HeapPage* page, FreeList* freelist) {
   // Keep track whether this page is still in use.
   bool in_use = false;
 
   bool is_executable = (page->type() == HeapPage::kExecutable);
   uword start = page->object_start();
   uword end = page->object_end();
@@ skipping 49 matching lines @@
   uword end = page->object_end();
   while (current < end) {
     RawObject* cur_obj = RawObject::FromAddr(current);
     ASSERT(!cur_obj->IsMarked());
     current += cur_obj->Size();
   }
 #endif  // DEBUG
   return words_to_end;
 }
 
+
+class SweeperTask : public ThreadPool::Task {
+ public:
+  SweeperTask(Isolate* isolate,
+              PageSpace* old_space,
+              HeapPage* first,
+              HeapPage* last,
+              FreeList* freelist)
+      : task_isolate_(isolate->ShallowCopy()),
+        old_space_(old_space),
+        first_(first),
+        last_(last),
+        freelist_(freelist) {
+    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() {
+    Isolate::SetCurrent(task_isolate_);
+    GCSweeper sweeper(NULL);
+
+    HeapPage* page = first_;
+    HeapPage* prev_page = NULL;
+
+    while (page != NULL) {
+      HeapPage* next_page = page->next();
+      if (page->type() == HeapPage::kData) {
+        bool page_in_use = true;
+        {
+          MutexLocker ml(freelist_->mutex());
+          page_in_use = sweeper.SweepPage(page, freelist_);
+        }
+        if (page_in_use) {
+          // Notify the mutator thread that we have potentially added elements
+          // to the free list.
+          MonitorLocker ml(old_space_->tasks_lock());
+          ml.Notify();
+          prev_page = page;
+        } else {
+          old_space_->FreePage(page, prev_page);
+        }
+      } else {
+        prev_page = page;

[koda, 2014/08/26 23:34:48]

You are silently skipping non-kData pages. This should at the least be clearly
documented, or better, just make it a precondition that only kData-pages are
passed to SweepConcurrent (now that we have segregated the lists), and ASSERT
here instead.

[Ivan Posva, 2014/08/27 01:00:21]

Changed to an assertion that only data pages are processed.

+      }
+      if (page == last_) break;
+      page = next_page;
+    }
+    {
+      MonitorLocker ml(old_space_->tasks_lock());
+      old_space_->set_tasks(old_space_->tasks() - 1);
+      ml.Notify();
+    }
+    Isolate::SetCurrent(NULL);
+    delete task_isolate_;
+  }
+
+ private:
+  Isolate* task_isolate_;
+  PageSpace* old_space_;
+  HeapPage* first_;
+  HeapPage* last_;
+  FreeList* freelist_;
+};
+
+
+void GCSweeper::SweepConcurrent(Isolate* isolate,
+                                PageSpace* old_space,
+                                HeapPage* first,
+                                HeapPage* last,
+                                FreeList* freelist) {
+  SweeperTask* task =
+      new SweeperTask(isolate, old_space, first, last, freelist);
+  ThreadPool* pool = Dart::thread_pool();
+  pool->Run(task);
+}
+
 }  // namespace dart