Implement weak references sets and provide an embedding API.

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
@@ skipping 1353 matching lines @@
   EXPECT_VALID(weak_ref);
   EXPECT(*peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(*peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(*peer == 42);
   delete peer;
   Dart_DeletePersistentHandle(weak_ref);
 }
 
+
+TEST_CASE(ObjectGroups) {
+  Dart_Handle strong = Dart_Null();
+  EXPECT(Dart_IsNull(strong));
+
+  Dart_Handle weak1 = Dart_Null();
+  EXPECT(Dart_IsNull(weak1));
+
+  Dart_Handle weak2 = Dart_Null();
+  EXPECT(Dart_IsNull(weak2));
+
+  Dart_Handle weak3 = Dart_Null();
+  EXPECT(Dart_IsNull(weak3));
+
+  Dart_Handle weak4 = Dart_Null();
+  EXPECT(Dart_IsNull(weak4));
+
+  Dart_EnterScope();
+  {
+    DARTSCOPE(Isolate::Current());
+    String& str = String::Handle();
+
+    str ^= String::New("strongly reachable", Heap::kOld);
+    strong = Dart_NewPersistentHandle(Api::NewLocalHandle(str));
+    EXPECT_VALID(strong);
+    EXPECT(!Dart_IsNull(strong));
+
+    str ^= String::New("weakly reachable 1", Heap::kOld);
+    weak1 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT_VALID(weak1);
+    EXPECT(!Dart_IsNull(weak1));
+
+    str ^= String::New("weakly reachable 2", Heap::kOld);
+    weak2 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT_VALID(weak2);
+    EXPECT(!Dart_IsNull(weak2));
+
+    str ^= String::New("weakly reachable 3", Heap::kOld);
+    weak3 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT_VALID(weak3);
+    EXPECT(!Dart_IsNull(weak3));
+
+    str ^= String::New("weakly reachable 4", Heap::kOld);
+    weak4 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT_VALID(weak4);
+    EXPECT(!Dart_IsNull(weak4));
+  }
+  Dart_ExitScope();
+
+  EXPECT_VALID(strong);
+
+  EXPECT_VALID(weak1);
+  EXPECT_VALID(weak2);
+  EXPECT_VALID(weak3);
+  EXPECT_VALID(weak4);
+
+  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+
+  // New space collection should not affect old space objects
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(!Dart_IsNull(weak3));
+  EXPECT(!Dart_IsNull(weak4));
+
+  {
+    Dart_Handle array1[] = { weak1, strong };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
+                                          array1, ARRAY_SIZE(array1)));
+
+    Dart_Handle array2[] = { weak2, weak1 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
+                                          array2, ARRAY_SIZE(array2)));
+
+    Dart_Handle array3[] = { weak3, weak2 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array3, ARRAY_SIZE(array3),
+                                          array3, ARRAY_SIZE(array3)));
+
+    Dart_Handle array4[] = { weak4, weak3 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array4, ARRAY_SIZE(array4),
+                                          array4, ARRAY_SIZE(array4)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
+
+  // All weak references should be preserved.
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(!Dart_IsNull(weak3));
+  EXPECT(!Dart_IsNull(weak4));
+
+  {
+    Dart_Handle array1[] = { weak1, strong };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
+                                          array1, ARRAY_SIZE(array1)));
+
+    Dart_Handle array2[] = { weak2, weak1 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
+                                          array2, ARRAY_SIZE(array2)));
+
+    Dart_Handle array3[] = { weak2 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array3, ARRAY_SIZE(array3),
+                                          array3, ARRAY_SIZE(array3)));
+
+    // Strong reference to weak3 to retain weak3 and weak4.
+    Dart_Handle weak3_strong_ref = Dart_NewPersistentHandle(weak3);
+    EXPECT_VALID(weak3_strong_ref);
+
+    Dart_Handle array4[] = { weak4, weak3 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array4, ARRAY_SIZE(array4),
+                                          array4, ARRAY_SIZE(array4)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+
+    // Delete strong reference to weak3.
+    Dart_DeletePersistentHandle(weak3_strong_ref);
+  }
+
+  // All weak references should be preserved.
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(!Dart_IsNull(weak3));
+  EXPECT(!Dart_IsNull(weak4));
+
+  {
+    Dart_Handle array1[] = { weak1, strong };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
+                                          array1, ARRAY_SIZE(array1)));
+
+    Dart_Handle array2[] = { weak2, weak1 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
+                                          array2, ARRAY_SIZE(array2)));
+
+    Dart_Handle array3[] = { weak2 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array3, ARRAY_SIZE(array3),
+                                          array3, ARRAY_SIZE(array3)));
+
+    Dart_Handle array4[] = { weak4, weak3 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array4, ARRAY_SIZE(array4),
+                                          array4, ARRAY_SIZE(array4)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
+
+  // Only weak1 and weak2 should be preserved.
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(Dart_IsNull(weak3));
+  EXPECT(Dart_IsNull(weak4));
+
+  {
+    Dart_Handle array1[] = { weak1, strong };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
+                                          array1, ARRAY_SIZE(array1)));
+
+    Dart_Handle array2[] = { weak2, weak3 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
+                                          array2, ARRAY_SIZE(array2)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
+
+  // Only weak1 should be preserved, weak3 should not preserve weak2.
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(Dart_IsNull(weak2));
+  EXPECT(Dart_IsNull(weak3));
+  EXPECT(Dart_IsNull(weak4));

[siva, 2012/03/02 18:30:33]

weak3 and weak4 were already NULL before this test, how do we know that this
test cleared them?

[cshapiro, 2012/03/03 00:03:23]

Yes, weak3 and weak4 were null before the GC on line 1532.  They should stay
that way, which is all I am validating.

There is always a possibility of resurrecting values with algorithms like these
so I am ensuring they are still dead.

+
+  {
+    Dart_Handle array1[] = { strong, weak2, weak3, weak4 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
+                                          array1, ARRAY_SIZE(array1)));
+
+    Dart_Handle array2[] = { weak1 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
+                                          array2, ARRAY_SIZE(array2)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
+
+  // No weak references should be preserved.

[siva, 2012/03/02 18:30:33]

Why should weak2, weak3 and weak4 not be preserved?

[cshapiro, 2012/03/03 00:03:23]

The are still null so they should remain null.

+  EXPECT(Dart_IsNull(weak1));
+  EXPECT(Dart_IsNull(weak2));
+  EXPECT(Dart_IsNull(weak3));
+  EXPECT(Dart_IsNull(weak4));

[siva, 2012/03/02 18:30:33]

I am little confused here, weak3, weak4, weak2 were already cleared in the
previous set, you did not restore weak2, weak3 and weak4 before this test, so
how can we be sure that this test actually cleared the weak references?

[cshapiro, 2012/03/03 00:03:23]

Let me add some comments and see if that makes the intent more clear.  Each of
these tests is not supposed to be stand alone, I'm just decaying the number of
live objects each GC.

+}
+
+
+TEST_CASE(ImplicitReferences) {
+  Dart_Handle strong = Dart_Null();
+  EXPECT(Dart_IsNull(strong));
+
+  Dart_Handle weak1 = Dart_Null();
+  EXPECT(Dart_IsNull(weak1));
+
+  Dart_Handle weak2 = Dart_Null();
+  EXPECT(Dart_IsNull(weak2));
+
+  Dart_Handle weak3 = Dart_Null();
+  EXPECT(Dart_IsNull(weak3));
+
+
+  Dart_EnterScope();
+  {
+    DARTSCOPE(Isolate::Current());
+    String& str = String::Handle();
+
+    str ^= String::New("strongly reachable", Heap::kOld);
+    strong = Dart_NewPersistentHandle(Api::NewLocalHandle(str));
+    EXPECT(!Dart_IsNull(strong));
+    EXPECT_VALID(strong);
+
+    str ^= String::New("weakly reachable 1", Heap::kOld);
+    weak1 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT(!Dart_IsNull(weak1));
+    EXPECT_VALID(weak1);
+
+    str ^= String::New("weakly reachable 2", Heap::kOld);
+    weak2 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT(!Dart_IsNull(weak2));
+    EXPECT_VALID(weak2);
+
+    str ^= String::New("weakly reachable 3", Heap::kOld);
+    weak3 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    EXPECT(!Dart_IsNull(weak3));
+    EXPECT_VALID(weak3);
+  }
+  Dart_ExitScope();
+
+  EXPECT_VALID(strong);
+
+  EXPECT_VALID(weak1);
+  EXPECT_VALID(weak2);
+  EXPECT_VALID(weak3);
+
+  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+
+  // New space collection should not affect old space objects
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(!Dart_IsNull(weak3));
+
+  // A strongly referenced key should preserve all the values.
+  {
+    Dart_Handle keys[] = { strong };
+    Dart_Handle values[] = { weak1, weak2, weak3 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(keys, ARRAY_SIZE(keys),
+                                          values, ARRAY_SIZE(values)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
+
+  // All weak references should be preserved.
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(!Dart_IsNull(weak3));
+
+  // Key membership does not imply a strong reference.
+  {
+    Dart_Handle keys[] = { strong, weak3 };
+    Dart_Handle values[] = { weak1, weak2 };
+    EXPECT_VALID(Dart_NewWeakReferenceSet(keys, ARRAY_SIZE(keys),
+                                          values, ARRAY_SIZE(values)));
+
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
+
+  // All weak references except weak3 should be preserved.
+  EXPECT(!Dart_IsNull(weak1));
+  EXPECT(!Dart_IsNull(weak2));
+  EXPECT(Dart_IsNull(weak3));
+}
+
 #endif
 
 
 // Unit test for creating multiple scopes and local handles within them.
 // Ensure that the local handles get all cleaned out when exiting the
 // scope.
 UNIT_TEST_CASE(LocalHandles) {
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
@@ skipping 2349 matching lines @@
   // We should have received the expected number of interrupts.
   EXPECT_EQ(kInterruptCount, interrupt_count);
 
   // Give the spawned thread enough time to properly exit.
   Isolate::SetInterruptCallback(saved);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart