Background finalization.

runtime/vm/dart_api_state.h

 // 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.
 
 #ifndef VM_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
@@ skipping 209 matching lines @@
   void SetExternalSize(intptr_t size, Isolate* isolate) {
     ASSERT(size >= 0);
     set_external_size(Utils::RoundUp(size, kObjectAlignment));
     if (SpaceForExternal() == Heap::kNew) {
       SetExternalNewSpaceBit();
     }
     isolate->heap()->AllocateExternal(external_size(), SpaceForExternal());
   }
 
   // Called when the referent becomes unreachable.
-  void UpdateUnreachable(Isolate* isolate) {
+  void UpdateUnreachableFinalizeNow(Isolate* isolate) {
     EnsureFreeExternal(isolate);
     Finalize(isolate, this);
   }
 
+  void UpdateUnreachableFinalizeLater(Isolate* isolate) {
+    EnsureFreeExternal(isolate);
+    MarkForFinalization();
+  }

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

Maybe more readable as

void UpdateUnreachable(Isolate* isolate, FinalizationQueue* queue) {
  EnsureFreeExternal(isolate);
  if (queue != NULL) {
    MarkForFinalization();
    queue->Add(this);
  } else {
    Finalize(isolate, this);
  }
}

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

Yes, I like that better.

+
   // Called when the referent has moved, potentially between generations.
   void UpdateRelocated(Isolate* isolate) {
     if (IsSetNewSpaceBit() && (SpaceForExternal() == Heap::kOld)) {
       isolate->heap()->PromoteExternal(external_size());
       ClearExternalNewSpaceBit();
     }
   }
 
   // Idempotent. Called when the handle is explicitly deleted or the
   // referent becomes unreachable.
@@ skipping 47 matching lines @@
     SetNext(free_list);
   }
 
   void Clear() {
     raw_ = Object::null();
     peer_ = NULL;
     external_data_ = 0;
     callback_ = NULL;
   }
 
+  void MarkForFinalization() {
+    raw_ = Object::null();
+    ASSERT(callback_ != NULL);
+  }
+
   void set_raw(RawObject* raw) { raw_ = raw; }
   void set_raw(const LocalHandle& ref) { raw_ = ref.raw(); }
   void set_raw(const Object& object) { raw_ = object.raw(); }
 
   void set_peer(void* peer) { peer_ = peer; }
 
   void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
     callback_ = callback;
   }
 
@@ skipping 14 matching lines @@
     external_data_ = ExternalNewSpaceBit::update(false, external_data_);
   }
 
   // Returns the space to charge for the external size.
   Heap::Space SpaceForExternal() const {
     // Non-heap and VM-heap objects count as old space here.
     return (raw_->IsHeapObject() && raw_->IsNewObject()) ?
            Heap::kNew : Heap::kOld;
   }
 
+  friend class BackgroundFinalizer;
+
   RawObject* raw_;
   void* peer_;
   uword external_data_;
   Dart_WeakPersistentHandleFinalizer callback_;
+
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandle);
 };
 
 
 // Local handles repository structure.
 static const int kLocalHandleSizeInWords = sizeof(LocalHandle) / kWordSize;
 static const int kLocalHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInLocalHandle = 0;
 class LocalHandles : Handles<kLocalHandleSizeInWords,
@@ skipping 144 matching lines @@
 static const int kOffsetOfRawPtrInFinalizablePersistentHandle = 0;
 class FinalizablePersistentHandles
     : Handles<kFinalizablePersistentHandleSizeInWords,
               kFinalizablePersistentHandlesPerChunk,
               kOffsetOfRawPtrInFinalizablePersistentHandle> {
  public:
   FinalizablePersistentHandles()
       : Handles<kFinalizablePersistentHandleSizeInWords,
                 kFinalizablePersistentHandlesPerChunk,
                 kOffsetOfRawPtrInFinalizablePersistentHandle>(),
-        free_list_(NULL) { }
+      free_list_(NULL), mutex_(new Mutex()) { }
   ~FinalizablePersistentHandles() {
     free_list_ = NULL;
+    delete mutex_;
+    mutex_ = NULL;
   }
 
   // Accessors.
   FinalizablePersistentHandle* free_list() const { return free_list_; }
   void set_free_list(FinalizablePersistentHandle* value) { free_list_ = value; }
 
   // Visit all handles stored in the various handle blocks.
   void VisitHandles(HandleVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::Visit(
                 visitor);
   }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kFinalizablePersistentHandleSizeInWords,
             kFinalizablePersistentHandlesPerChunk,
             kOffsetOfRawPtrInFinalizablePersistentHandle>::VisitObjectPointers(
                 visitor);
   }
 
   // Allocates a persistent handle, these have to be destroyed explicitly
   // by calling FreeHandle.
   FinalizablePersistentHandle* AllocateHandle() {
+    MutexLocker ml(mutex_);
     FinalizablePersistentHandle* handle;
     if (free_list_ != NULL) {
       handle = free_list_;
       free_list_ = handle->Next();
       handle->set_raw(Object::null());
     } else {
       handle = reinterpret_cast<FinalizablePersistentHandle*>(
           AllocateScopedHandle());
       handle->Clear();
     }
     return handle;
   }
 
   void FreeHandle(FinalizablePersistentHandle* handle) {
+    MutexLocker ml(mutex_);
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_WeakPersistentHandle object) const {
+    MutexLocker ml(mutex_);
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const {
     return CountScopedHandles();
   }
 
  private:
   FinalizablePersistentHandle* free_list_;
+  Mutex* mutex_;
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandles);
 };
 
 
 // Structure used for the implementation of local scopes used in dart_api.
 // These local scopes manage handles and memory allocated in the scope.
 class ApiLocalScope {
  public:
   ApiLocalScope(ApiLocalScope* previous, uword stack_marker) :
       previous_(previous), stack_marker_(stack_marker) { }
@@ skipping 190 matching lines @@
   ref->set_peer(peer);
   ref->set_callback(callback);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_