Background finalization.

runtime/vm/gc_marker.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_marker.h"
 
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
@@ skipping 404 matching lines @@
   }
   if (!raw_obj->IsOldObject()) {
     return false;
   }
   return !raw_obj->IsMarked();
 }
 
 
 class MarkingWeakVisitor : public HandleVisitor {
  public:
-  MarkingWeakVisitor() : HandleVisitor(Thread::Current()) {
-  }
+  MarkingWeakVisitor(Thread* thread, FinalizationQueue* queue) :
+      HandleVisitor(thread), queue_(queue) { }
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
         reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject* raw_obj = handle->raw();
     if (IsUnreachable(raw_obj)) {
-      handle->UpdateUnreachable(thread()->isolate());
+      handle->UpdateUnreachable(thread()->isolate(), queue_);
     }
   }
 
  private:
+  FinalizationQueue* queue_;
+
   DISALLOW_COPY_AND_ASSIGN(MarkingWeakVisitor);
 };
 
 
 void GCMarker::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks && (isolate->gc_prologue_callback() != NULL)) {
     (isolate->gc_prologue_callback())();
   }
   isolate->PrepareForGC();
   // The store buffers will be rebuilt as part of marking, reset them now.
@@ skipping 213 matching lines @@
     if (num_tasks == 0) {
       // Mark everything on main thread.
       SkippedCodeFunctions* skipped_code_functions =
           collect_code ? new(zone) SkippedCodeFunctions() : NULL;
       UnsyncMarkingVisitor mark(isolate, heap_, page_space, &marking_stack,
                                 skipped_code_functions);
       IterateRoots(isolate, &mark, 0, 1);
       mark.DrainMarkingStack();
       {
         TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
-        MarkingWeakVisitor mark_weak;
+        FinalizationQueue* queue = new FinalizationQueue();
+        MarkingWeakVisitor mark_weak(thread, queue);
         IterateWeakRoots(isolate, &mark_weak);
+        if (queue->length() > 0) {
+          Dart::thread_pool()->Run(new BackgroundFinalizer(isolate, queue));
+        } else {
+          delete queue;
+        }
       }
       // All marking done; detach code, etc.
       FinalizeResultsFrom(&mark);
     } else {
       ThreadBarrier barrier(num_tasks + 1,
                             heap_->barrier(),
                             heap_->barrier_done());
       // Used to coordinate draining among tasks; all start out as 'busy'.
       uintptr_t num_busy = num_tasks;
       // Phase 1: Iterate over roots and drain marking stack in tasks.
       for (intptr_t i = 0; i < num_tasks; ++i) {
         MarkTask* mark_task =
             new MarkTask(this, isolate, heap_, page_space, &marking_stack,
                          &barrier, collect_code,
                          i, num_tasks, &num_busy);
         ThreadPool* pool = Dart::thread_pool();
         pool->Run(mark_task);
       }
       barrier.Sync();
 
       // Phase 2: Weak processing on main thread.
       {
         TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
-        MarkingWeakVisitor mark_weak;
+        FinalizationQueue* queue = new FinalizationQueue();
+        MarkingWeakVisitor mark_weak(thread, queue);
         IterateWeakRoots(isolate, &mark_weak);
+        if (queue->length() > 0) {
+          Dart::thread_pool()->Run(new BackgroundFinalizer(isolate, queue));
+        } else {
+          delete queue;
+        }
       }
       barrier.Sync();
 
       // Phase 3: Finalize results from all markers (detach code, etc.).
       barrier.Exit();
     }
     ProcessWeakTables(page_space);
     ProcessObjectIdTable(isolate);
   }
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart