Background finalization.

runtime/vm/scavenger.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/scavenger.h"
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 175 matching lines @@
   RawObject* visiting_old_object_;
 
   friend class Scavenger;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
 class ScavengerWeakVisitor : public HandleVisitor {
  public:
-  explicit ScavengerWeakVisitor(Scavenger* scavenger)
-      :  HandleVisitor(Thread::Current()),
-         scavenger_(scavenger) {
-    ASSERT(scavenger->heap_->isolate() == Thread::Current()->isolate());
+  explicit ScavengerWeakVisitor(
+      Thread* thread,
+      Scavenger* scavenger,
+      MallocGrowableArray<FinalizablePersistentHandle*>* finalization_queue)
+      :  HandleVisitor(thread),
+         scavenger_(scavenger),
+         finalization_queue_(finalization_queue) {
+    ASSERT(scavenger->heap_->isolate() == thread->isolate());
   }
 
   void VisitHandle(uword addr) {
     FinalizablePersistentHandle* handle =
       reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject** p = handle->raw_addr();
     if (scavenger_->IsUnreachable(p)) {
-      handle->UpdateUnreachable(thread()->isolate());
+      handle->UpdateUnreachableFinalizeLater(thread()->isolate());
+      finalization_queue_->Add(handle);

[siva, 2016/06/02 20:18:05]

handle->UpdateUnreachable(thread()->isolate(), finalization_queue);

     } else {
       handle->UpdateRelocated(thread()->isolate());
     }
   }
 
  private:
   Scavenger* scavenger_;
+  MallocGrowableArray<FinalizablePersistentHandle*>* finalization_queue_;

[siva, 2016/06/02 20:18:05]

Maybe typedef MallocGrowableArray<FinalizablePersistentHandle*>
to FinalizationQueue.

[rmacnak, 2016/06/03 01:08:31]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(ScavengerWeakVisitor);
 };
 
 
+class BackgroundFinalizer : public ThreadPool::Task {
+ public:
+  explicit BackgroundFinalizer(

[siva, 2016/06/02 20:18:05]

Why explicit? seems to have more than 1 argument.

[rmacnak, 2016/06/03 01:08:31]

Removed.

+      Isolate* isolate,
+      MallocGrowableArray<FinalizablePersistentHandle*>* handles) :
+          isolate_(isolate),
+          handles_(handles) {
+    MonitorLocker ml(isolate->heap()->finalization_tasks_lock());
+    isolate->heap()->set_finalization_tasks(
+        isolate->heap()->finalization_tasks() + 1);
+    ml.Notify();
+  }
+
+  virtual ~BackgroundFinalizer() { }
+
+  void Run() {
+    bool result = Thread::EnterIsolateAsHelper(isolate_,
+                                               Thread::kFinalizerTask,
+                                               true /* bypass_safepoint */);
+    ASSERT(result);
+
+    {
+      TIMELINE_FUNCTION_GC_DURATION(Thread::Current(),
+                                    "BackgroundFinalization");
+
+      for (intptr_t i = 0; i < handles_->length(); i++) {
+        FinalizablePersistentHandle* handle = (*handles_)[i];
+        FinalizablePersistentHandle::Finalize(isolate_, handle);
+      }
+      delete handles_;
+    }
+
+    // Exit isolate cleanly *before* notifying it, to avoid shutdown race.

[siva, 2016/06/02 20:18:05]

notifying it? (what is it).

+    Thread::ExitIsolateAsHelper();
+
+    {
+      Heap* heap = isolate_->heap();
+      MonitorLocker ml(heap->finalization_tasks_lock());
+      heap->set_finalization_tasks(heap->finalization_tasks() - 1);
+      ml.Notify();

[siva, 2016/06/02 20:18:05]

seems odd that the thread has exited the isolate but is accessing the isolate's
heap.

Why is it necessary to exit the isolate before notifying that one finalization
task is done?

[rmacnak, 2016/06/03 01:08:31]

This pattern comes from the sweeper task. This avoids running
ExitIsolateAsHelper after isolate shutdown.

+    }
+  }
+
+ private:
+  Isolate* isolate_;
+  MallocGrowableArray<FinalizablePersistentHandle*>* handles_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(BackgroundFinalizer);
+};
+
+
 // Visitor used to verify that all old->new references have been added to the
 // StoreBuffers.
 class VerifyStoreBufferPointerVisitor : public ObjectPointerVisitor {
  public:
   VerifyStoreBufferPointerVisitor(Isolate* isolate,
                                   const SemiSpace* to)
       : ObjectPointerVisitor(isolate), to_(to) {}
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
@@ skipping 575 matching lines @@
     StackZone zone(thread);
     // Setup the visitor and run the scavenge.
     ScavengerVisitor visitor(isolate, this, from);
     page_space->AcquireDataLock();
     IterateRoots(isolate, &visitor);
     int64_t start = OS::GetCurrentTimeMicros();
     ProcessToSpace(&visitor);
     int64_t middle = OS::GetCurrentTimeMicros();
     {
       TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
-      ScavengerWeakVisitor weak_visitor(this);
+      MallocGrowableArray<FinalizablePersistentHandle*>* finalization_queue =
+          new MallocGrowableArray<FinalizablePersistentHandle*>();
+      ScavengerWeakVisitor weak_visitor(thread, this, finalization_queue);
       IterateWeakRoots(isolate, &weak_visitor);
+      if (finalization_queue->length() > 0) {
+        Dart::thread_pool()->Run(new BackgroundFinalizer(isolate,
+                                                         finalization_queue));

[siva, 2016/06/02 20:18:05]

I am assuming the BackgroundFinalizer object created here is deleted by the
thread pool.

[rmacnak, 2016/06/03 01:08:31]

Yes, tasks are deleted by the thread pool after they finish.

+      } else {
+        delete finalization_queue;
+      }
     }
     ProcessWeakReferences();
     page_space->ReleaseDataLock();
 
     // Scavenge finished. Run accounting.
     int64_t end = OS::GetCurrentTimeMicros();
     heap_->RecordTime(kProcessToSpace, middle - start);
     heap_->RecordTime(kIterateWeaks, end - middle);
     stats_history_.Add(
         ScavengeStats(start, end,
@@ skipping 57 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart