Track external allocated memory for weak persistent handles.

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/thread.h"
+#include "platform/utils.h"
 #include "vm/dart_api_impl.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/visitor.h"
 
 #include "vm/handles_impl.h"
@@ skipping 184 matching lines @@
   }
   Dart_WeakPersistentHandle apiPrologueHandle() {
     uword addr = reinterpret_cast<uword>(this);
     return reinterpret_cast<Dart_WeakPersistentHandle>(
         addr | kPrologueWeakPersistentTag);
   }
   Dart_WeakPersistentHandle apiHandle() {
     return reinterpret_cast<Dart_WeakPersistentHandle>(this);
   }
 
+  void SetExternalSize(intptr_t size, Isolate* isolate) {
+    ASSERT(size >= 0);
+    external_size_ = Utils::RoundUp(size, kObjectAlignment);
+    // TODO(koda): On repeated/large external allocations for existing objects,
+    // without any intervening normal allocation, GC will not trigger.
+    isolate->heap()->AllocateExternal(external_size_, SpaceForExternal());
+  }
+
+  // Called when the referent becomes unreachable.
+  void UpdateUnreachable(Isolate* isolate, bool is_prologue_weak) {
+    EnsureFreeExternal(isolate);
+    Finalize(isolate, this, is_prologue_weak);
+  }
+
+  // Called when the referent has moved, potentially between generations.
+  void UpdateRelocated(Heap::Space before, Isolate* isolate) {
+    isolate->heap()->FreeExternal(external_size_, before);
+    isolate->heap()->AllocateExternal(external_size_, SpaceForExternal());
+  }
+
+  // Idempotent. Called when the handle is explicitly deleted or the
+  // referent becomes unreachable.
+  void EnsureFreeExternal(Isolate* isolate) {
+    isolate->heap()->FreeExternal(external_size_, SpaceForExternal());
+    external_size_ = 0;
+  }
+
+  // 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;
+  }
+
   static bool IsPrologueWeakPersistentHandle(Dart_WeakPersistentHandle handle) {
     uword addr = reinterpret_cast<uword>(handle);
     return (addr & kWeakPersistentTagMask) == kPrologueWeakPersistentTag;
   }
   static FinalizablePersistentHandle* Cast(Dart_WeakPersistentHandle handle);
   static void Finalize(Isolate* isolate,
                        FinalizablePersistentHandle* handle,
                        bool is_prologue_weak) {

[siva, 2014/03/07 19:53:03]

This should now become a private method I suppose as we do not want anybody
calling it directly.

[koda, 2014/03/07 20:46:54]

It was still called by the isolate shutdown code, which finalizes all weak
persistent handles. I've changed it to UpdateUnreachable.

By the way, the API docs don't really specify what should happen on shutdown
(though I suppose the object does become unreachable, in a sense). I added a
comment to Dart_ShutdownIsolate.

     Dart_WeakPersistentHandleFinalizer callback = handle->callback();
     if (callback != NULL) {
       void* peer = handle->peer();
       handle->Clear();
       Dart_WeakPersistentHandle object = is_prologue_weak ?
           handle->apiPrologueHandle() :
           handle->apiHandle();
       (*callback)(reinterpret_cast<Dart_Isolate>(isolate), object, peer);
     } else {
       handle->Clear();
     }
   }
 
  private:
   enum {
     kWeakPersistentTag = 0,
     kPrologueWeakPersistentTag = 1,
     kWeakPersistentTagSize = 1,
     kWeakPersistentTagMask = 1,
   };
 
   friend class FinalizablePersistentHandles;
 
-  FinalizablePersistentHandle() : raw_(NULL), peer_(NULL), callback_(NULL) { }
+  FinalizablePersistentHandle()
+      : raw_(NULL),
+        peer_(NULL),
+        external_size_(0),
+        callback_(NULL) { }
   ~FinalizablePersistentHandle() { }
 
   // Overload the raw_ field as a next pointer when adding freed
   // handles to the free list.
   FinalizablePersistentHandle* Next() {
     return reinterpret_cast<FinalizablePersistentHandle*>(raw_);
   }
   void SetNext(FinalizablePersistentHandle* free_list) {
     raw_ = reinterpret_cast<RawObject*>(free_list);
     ASSERT(!raw_->IsHeapObject());
   }
   void FreeHandle(FinalizablePersistentHandle* free_list) {
     Clear();
     SetNext(free_list);
   }
 
   void Clear() {
     raw_ = Object::null();
     peer_ = NULL;
+    external_size_ = 0;
     callback_ = NULL;
   }
 
   RawObject* raw_;
   void* peer_;
+  intptr_t external_size_;
   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;
@@ skipping 182 matching lines @@
   // by calling FreeHandle.
   FinalizablePersistentHandle* AllocateHandle() {
     FinalizablePersistentHandle* handle;
     if (free_list_ != NULL) {
       handle = free_list_;
       free_list_ = handle->Next();
     } else {
       handle = reinterpret_cast<FinalizablePersistentHandle*>(
           AllocateScopedHandle());
     }
-    handle->set_callback(NULL);
+    handle->Clear();
     return handle;
   }
 
   void FreeHandle(FinalizablePersistentHandle* handle) {
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_WeakPersistentHandle object) const {
@@ skipping 332 matching lines @@
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_