Track external allocated memory for weak persistent handles.

runtime/vm/dart_api_impl_test.cc

 // 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.
 
 #include "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
@@ skipping 1776 matching lines @@
 
 TEST_CASE(ExternalTypedDataCallback) {
   int peer = 0;
   {
     Dart_EnterScope();
     uint8_t data[] = { 1, 2, 3, 4 };
     Dart_Handle obj = Dart_NewExternalTypedData(
         Dart_TypedData_kUint8,
         data,
         ARRAY_SIZE(data));
-    Dart_NewWeakPersistentHandle(obj, &peer, ExternalTypedDataFinalizer);
+    Dart_NewWeakPersistentHandle(
+        obj, &peer, sizeof(data), ExternalTypedDataFinalizer);
     EXPECT_VALID(obj);
     Dart_ExitScope();
   }
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(peer == 42);
 }
 
@@ skipping 34 matching lines @@
   float data[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
   // Push a scope so that we can collect the local handle created as part of
   // Dart_NewExternalTypedData.
   Dart_EnterScope();
   {
     Dart_Handle lcl = Dart_NewExternalTypedData(
         Dart_TypedData_kFloat32x4, data, 10);
-    Dart_NewWeakPersistentHandle(lcl, &peer, ExternalTypedDataFinalizer);
+    Dart_NewWeakPersistentHandle(
+        lcl, &peer, sizeof(data), ExternalTypedDataFinalizer);
     CheckFloat32x4Data(lcl);
   }
   Dart_ExitScope();
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(peer == 42);
 }
 
 
 // Unit test for entering a scope, creating a local handle and exiting
 // the scope.
@@ skipping 167 matching lines @@
 
 
 static Dart_Handle AsHandle(Dart_WeakPersistentHandle weak) {
   return Dart_HandleFromWeakPersistent(weak);
 }
 
 
 TEST_CASE(WeakPersistentHandle) {
   Dart_Handle local_new_ref = Dart_Null();
   Dart_WeakPersistentHandle weak_new_ref = Dart_NewWeakPersistentHandle(
-      local_new_ref, NULL, NULL);
+      local_new_ref, NULL, 0, NULL);
 
   Dart_Handle local_old_ref = Dart_Null();
   Dart_WeakPersistentHandle weak_old_ref = Dart_NewWeakPersistentHandle(
-      local_old_ref, NULL, NULL);
+      local_old_ref, NULL, 0, NULL);
 
   {
     Dart_EnterScope();
 
     // Create an object in new space.
     Dart_Handle new_ref = NewString("new string");
     EXPECT_VALID(new_ref);
 
     // Create an object in old space.
     Dart_Handle old_ref;
     {
       Isolate* isolate = Isolate::Current();
       DARTSCOPE(isolate);
       old_ref = Api::NewHandle(isolate, String::New("old string", Heap::kOld));
       EXPECT_VALID(old_ref);
     }
 
     // Create a weak ref to the new space object.
-    weak_new_ref = Dart_NewWeakPersistentHandle(new_ref, NULL, NULL);
+    weak_new_ref = Dart_NewWeakPersistentHandle(new_ref, NULL, 0, NULL);
     EXPECT_VALID(AsHandle(weak_new_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
 
     // Create a weak ref to the old space object.
-    weak_old_ref = Dart_NewWeakPersistentHandle(old_ref, NULL, NULL);
+    weak_old_ref = Dart_NewWeakPersistentHandle(old_ref, NULL, 0, NULL);
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
 
     // Garbage collect new space.
     GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
     // Nothing should be invalidated or cleared.
     EXPECT_VALID(new_ref);
     EXPECT(!Dart_IsNull(new_ref));
     EXPECT_VALID(old_ref);
@@ skipping 71 matching lines @@
 }
 
 
 TEST_CASE(WeakPersistentHandleCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
-    weak_ref = Dart_NewWeakPersistentHandle(obj, &peer,
+    weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     EXPECT_VALID(AsHandle(weak_ref));
     EXPECT(peer == 0);
     Dart_ExitScope();
   }
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT(peer == 42);
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak_ref);
 }
 
 
 TEST_CASE(WeakPersistentHandleNoCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
-    weak_ref = Dart_NewWeakPersistentHandle(obj, &peer,
+    weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     Dart_ExitScope();
   }
   // A finalizer is not invoked on a deleted handle.  Therefore, the
   // peer value should not change after the referent is collected.
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak_ref);
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT(peer == 0);
 }
 
 
 UNIT_TEST_CASE(WeakPersistentHandlesCallbackShutdown) {
   TestCase::CreateTestIsolate();
   Dart_EnterScope();
   Dart_Handle ref = Dart_True();
   int peer = 1234;
   Dart_NewWeakPersistentHandle(ref,
                                &peer,
+                               0,
                                WeakPersistentHandlePeerFinalizer);
   Dart_ShutdownIsolate();
   EXPECT(peer == 42);
 }
 
 
+TEST_CASE(WeakPersistentHandleExternalAllocationSize) {
+  Heap* heap = Isolate::Current()->heap();
+  EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
+  EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+  Dart_WeakPersistentHandle weak1 = NULL;
+  static const intptr_t kWeak1ExternalSize = 1 * KB;
+  {
+    Dart_EnterScope();
+    Dart_Handle obj = NewString("weakly referenced string");
+    EXPECT_VALID(obj);
+    weak1 = Dart_NewWeakPersistentHandle(obj, NULL, kWeak1ExternalSize, NULL);
+    EXPECT_VALID(AsHandle(weak1));
+    EXPECT(!Dart_IsPrologueWeakPersistentHandle(weak1));
+    Dart_ExitScope();
+  }
+  Dart_PersistentHandle strong_ref = NULL;
+  Dart_WeakPersistentHandle weak2 = NULL;
+  static const intptr_t kWeak2ExternalSize = 2 * KB;
+  {
+    Dart_EnterScope();
+    Dart_Handle obj = NewString("strongly referenced string");
+    EXPECT_VALID(obj);
+    strong_ref = Dart_NewPersistentHandle(obj);
+    weak2 = Dart_NewWeakPersistentHandle(obj, NULL, kWeak2ExternalSize, NULL);
+    EXPECT_VALID(AsHandle(strong_ref));
+    Dart_ExitScope();
+  }
+  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  EXPECT(heap->ExternalInWords(Heap::kNew) ==
+         (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
+  // Collect weakly referenced string, and promote strongly referenced string.
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+  EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
+  EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak2ExternalSize / kWordSize);
+  Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
+  Dart_DeleteWeakPersistentHandle(isolate, weak1);
+  Dart_DeleteWeakPersistentHandle(isolate, weak2);
+  Dart_DeletePersistentHandle(strong_ref);
+  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+}
+
+
+TEST_CASE(WeakPersistentHandleExternalAllocationSizeOversized) {
+  Heap* heap = Isolate::Current()->heap();
+  Dart_WeakPersistentHandle weak1 = NULL;
+  const intptr_t kWeak1ExternalSize = 100 * MB;
+  {
+    Dart_EnterScope();
+    Dart_Handle obj = NewString("weakly referenced string");
+    EXPECT_VALID(obj);
+    weak1 = Dart_NewWeakPersistentHandle(obj, NULL, kWeak1ExternalSize, NULL);
+    EXPECT_VALID(AsHandle(weak1));
+    // While new space is "full" of external data, any allocation will
+    // trigger GC, so after two of them, obj should be promoted.
+    Dart_Handle trigger1 = NewString("trigger1");
+    EXPECT_VALID(trigger1);
+    Dart_Handle trigger2 = NewString("trigger2");
+    EXPECT_VALID(trigger2);
+    {
+      DARTSCOPE(Isolate::Current());
+      String& handle = String::Handle();
+      handle ^= Api::UnwrapHandle(obj);
+      EXPECT(handle.IsOld());
+    }
+    EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
+    EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak1ExternalSize / kWordSize);
+    Dart_ExitScope();
+  }
+  Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
+  Dart_DeleteWeakPersistentHandle(isolate, weak1);
+  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+}
+
+
+TEST_CASE(WeakPersistentHandleExternalAllocationSizeOddReferents) {
+  Heap* heap = Isolate::Current()->heap();
+  Dart_WeakPersistentHandle weak1 = NULL;
+  static const intptr_t kWeak1ExternalSize = 1 * KB;
+  Dart_WeakPersistentHandle weak2 = NULL;
+  static const intptr_t kWeak2ExternalSize = 2 * KB;
+  {
+    Dart_EnterScope();
+    Dart_Handle dart_null = Dart_Null();  // VM heap object.
+    EXPECT_VALID(dart_null);
+    weak1 = Dart_NewWeakPersistentHandle(
+        dart_null, NULL, kWeak1ExternalSize, NULL);
+    EXPECT_VALID(AsHandle(weak1));
+    Dart_Handle zero = Dart_NewInteger(0);  // Smi.
+    EXPECT_VALID(dart_null);
+    weak2 = Dart_NewWeakPersistentHandle(
+        zero, NULL, kWeak2ExternalSize, NULL);
+    EXPECT_VALID(AsHandle(weak2));
+    // Both should be charged to old space.
+    EXPECT(heap->ExternalInWords(Heap::kOld) ==
+           (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
+    Dart_ExitScope();
+  }
+  Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
+  Dart_DeleteWeakPersistentHandle(isolate, weak1);
+  Dart_DeleteWeakPersistentHandle(isolate, weak2);
+  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+}
+
+
 TEST_CASE(ObjectGroups) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_WeakPersistentHandle weak1 = NULL;
   Dart_WeakPersistentHandle weak2 = NULL;
   Dart_WeakPersistentHandle weak3 = NULL;
   Dart_WeakPersistentHandle weak4 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
 
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
-    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
+    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NULL);
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong)));
 
     weak1 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT_VALID(AsHandle(weak1));
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
 
     weak2 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT_VALID(AsHandle(weak2));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
 
     weak3 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT_VALID(AsHandle(weak3));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
 
     weak4 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 4", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT_VALID(AsHandle(weak4));
     EXPECT(!Dart_IsNull(AsHandle(weak4)));
   }
   Dart_ExitScope();
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong));
     EXPECT_VALID(AsHandle(weak1));
     EXPECT_VALID(AsHandle(weak2));
@@ skipping 172 matching lines @@
   Dart_WeakPersistentHandle old_pwph = NULL;
   Dart_WeakPersistentHandle new_pwph = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
     new_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("new space prologue weak", Heap::kNew)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT_VALID(AsHandle(new_pwph));
     EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
     old_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("old space prologue weak", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT_VALID(AsHandle(old_pwph));
     EXPECT(!Dart_IsNull(AsHandle(old_pwph)));
   }
   Dart_ExitScope();
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(new_pwph));
     EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
     EXPECT(Dart_IsPrologueWeakPersistentHandle(new_pwph));
@@ skipping 61 matching lines @@
   Dart_WeakPersistentHandle weak3 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
 
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
-    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
+    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NULL);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
     weak1 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT_VALID(AsHandle(weak1));
 
     weak2 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT_VALID(AsHandle(weak2));
 
     weak3 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kOld)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     EXPECT_VALID(AsHandle(weak3));
   }
   Dart_ExitScope();
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
     EXPECT_VALID(AsHandle(weak2));
@@ skipping 63 matching lines @@
   Dart_WeakPersistentHandle weak3 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
 
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
-    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
+    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NULL);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
     weak1 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kNew)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT_VALID(AsHandle(weak1));
 
     weak2 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kNew)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT_VALID(AsHandle(weak2));
 
     weak3 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kNew)),
-        NULL, NULL);
+        NULL, 0, NULL);
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     EXPECT_VALID(AsHandle(weak3));
   }
   Dart_ExitScope();
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
     EXPECT_VALID(AsHandle(weak2));
@@ skipping 5326 matching lines @@
                                    NewString("main"),
                                    1,
                                    dart_args);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(6, value);
 }
 
 }  // namespace dart